src/gen/genbox.c

#ifndef lint
static const char       RCSid[] = "$Id: genbox.c,v 2.8 2020/07/25 19:18:01 greg Exp $";
#endif
/*
 *  genbox.c - generate a parallelepiped.
 *
 *     1/8/86
 */

#include  "rtio.h"
#include  <stdlib.h>
#include  <math.h>


char  let[]="0123456789._ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";

char  *cmtype;          /* ppd material type */

char  *cname;           /* ppd name */

double  size[3];        /* ppd size */

double  bevel = 0.0;    /* bevel amount */

int  rounde = 0;        /* boolean true for round edges */

int  reverse = 0;       /* boolean true for reversed normals */


static void
vertex(int v)
{
        int  i;

        for (i = 0; i < 3; i++) {
                if (v & 010)
                        printf("\t%18.12g", v & 01 ? size[i]-bevel : bevel);
                else
                        printf("\t%18.12g", v & 01 ? size[i] : 0.0);
                v >>= 1;
        }
        fputc('\n', stdout);
}


static void
side(int a, int b, int c, int d)                /* generate a rectangular face */
{
        printf("\n%s polygon %s.%c%c%c%c\n", cmtype, cname,
                        let[a], let[b], let[c], let[d]);
        printf("0\n0\n12\n");
        if (reverse) {
                vertex(d);
                vertex(c);
                vertex(b);
                vertex(a);
        } else {
                vertex(a);
                vertex(b);
                vertex(c);
                vertex(d);
        }
}


static void
corner(int a, int b, int c)                     /* generate a triangular face */
{
        printf("\n%s polygon %s.%c%c%c\n", cmtype, cname,
                        let[a], let[b], let[c]);
        printf("0\n0\n9\n");
        if (reverse) {
                vertex(c);
                vertex(b);
                vertex(a);
        } else {
                vertex(a);
                vertex(b);
                vertex(c);
        }
}


static void
cylinder(int v0, int v1)                /* generate a cylinder */
{
        printf("\n%s cylinder %s.%c%c\n", cmtype, cname, v0+'0', v1+'0');
        printf("0\n0\n7\n");
        vertex(v0);
        vertex(v1);
        printf("\t%18.12g\n", bevel);
}


static void
sphere(int v0)                  /* generate a sphere */
{
        printf("\n%s sphere %s.%c\n", cmtype, cname, v0+'0');
        printf("0\n0\n4\n");
        vertex(v0);
        printf("\t%18.12g\n", bevel);
}


int
main(int argc, char *argv[])
{
        int  i;
        
        if (argc < 6)
                goto userr;

        cmtype = argv[1];
        cname = argv[2];
        size[0] = atof(argv[3]);
        size[1] = atof(argv[4]);
        size[2] = atof(argv[5]);
        if ((size[0] <= 0.0) | (size[1] <= 0.0) | (size[2] <= 0.0))
                goto userr;

        for (i = 6; i < argc; i++) {
                if (argv[i][0] != '-')
                        goto userr;
                switch (argv[i][1]) {
                case 'i':
                        reverse = 1;
                        break;
                case 'r':
                        rounde = 1;
                        /* fall through */
                case 'b':
                        bevel = atof(argv[++i]);
                        if (bevel > 0.0)
                                break;
                        /* fall through on error */
                default:
                        goto userr;
                }
        }
        if (rounde & reverse)
                fprintf(stderr, "%s: warning - option -i ignored with -r\n",
                                argv[0]);

        fputs("# ", stdout);
        printargs(argc, argv, stdout);

        if (bevel > 0.0) {
                                        /* minor faces */
                side(051, 055, 054, 050);
                side(064, 066, 062, 060);
                side(032, 033, 031, 030);
                side(053, 052, 056, 057);
                side(065, 061, 063, 067);
                side(036, 034, 035, 037);
        }
        if (bevel > 0.0 && !rounde) {
                                        /* bevel faces */
                side(031, 051, 050, 030);
                side(060, 062, 032, 030);
                side(050, 054, 064, 060);
                side(034, 036, 066, 064);
                side(037, 057, 056, 036);
                side(052, 062, 066, 056);
                side(052, 053, 033, 032);
                side(057, 067, 063, 053);
                side(061, 031, 033, 063);
                side(065, 067, 037, 035);
                side(055, 051, 061, 065);
                side(034, 054, 055, 035);
                                        /* bevel corners */
                corner(030, 050, 060);
                corner(051, 031, 061);
                corner(032, 062, 052);
                corner(064, 054, 034);
                corner(036, 056, 066);
                corner(065, 035, 055);
                corner(053, 063, 033);
                corner(037, 067, 057);
        }
        if (bevel > 0.0 && rounde) {
                                        /* round edges */
                cylinder(070, 071);
                cylinder(070, 074);
                cylinder(070, 072);
                cylinder(073, 071);
                cylinder(073, 072);
                cylinder(073, 077);
                cylinder(075, 071);
                cylinder(075, 074);
                cylinder(075, 077);
                cylinder(076, 072);
                cylinder(076, 074);
                cylinder(076, 077);
                                        /* round corners */
                sphere(070);
                sphere(071);
                sphere(072);
                sphere(073);
                sphere(074);
                sphere(075);
                sphere(076);
                sphere(077);
        }
        if (bevel == 0.0) {
                                        /* only need major faces */
                side(1, 5, 4, 0);
                side(4, 6, 2, 0);
                side(2, 3, 1, 0);
                side(3, 2, 6, 7);
                side(5, 1, 3, 7);
                side(6, 4, 5, 7);
        }
        return(0);
userr:
        fprintf(stderr, "Usage: %s ", argv[0]);
        fprintf(stderr, "material name xsize ysize zsize ");
        fprintf(stderr, "[-i] [-b bevel | -r round]\n");
        return(1);
}
Revision:	2.9
Committed:	Wed Apr 7 21:13:52 2021 UTC (3 years, 1 month ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.8:	+20 -14 lines
Log Message:	fix(genbox): minor changes and fixing "rounde" in comments and usage
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.9	static const char RCSid[] = "$Id: genbox.c,v 2.8 2020/07/25 19:18:01 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* genbox.c - generate a parallelepiped.
6			*
7			* 1/8/86
8			*/
9
10	greg	2.8	#include "rtio.h"
11			#include <stdlib.h>
12	greg	2.3	#include <math.h>
13
14	greg	1.1
15			char let[]="0123456789._ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
16
17			char cmtype; / ppd material type */
18
19			char cname; / ppd name */
20
21			double size[3]; /* ppd size */
22
23			double bevel = 0.0; /* bevel amount */
24
25	greg	2.9	int rounde = 0; /* boolean true for round edges */
26	greg	1.1
27			int reverse = 0; /* boolean true for reversed normals */
28
29
30	schorsch	2.6
31			static void
32	greg	2.8	vertex(int v)
33	schorsch	2.6	{
34	greg	2.9	int i;
35	schorsch	2.6
36			for (i = 0; i < 3; i++) {
37			if (v & 010)
38			printf("\t%18.12g", v & 01 ? size[i]-bevel : bevel);
39			else
40			printf("\t%18.12g", v & 01 ? size[i] : 0.0);
41			v >>= 1;
42			}
43	greg	2.9	fputc('\n', stdout);
44	schorsch	2.6	}
45
46
47			static void
48	greg	2.8	side(int a, int b, int c, int d) /* generate a rectangular face */
49	schorsch	2.6	{
50			printf("\n%s polygon %s.%c%c%c%c\n", cmtype, cname,
51			let[a], let[b], let[c], let[d]);
52			printf("0\n0\n12\n");
53			if (reverse) {
54			vertex(d);
55			vertex(c);
56			vertex(b);
57			vertex(a);
58			} else {
59			vertex(a);
60			vertex(b);
61			vertex(c);
62			vertex(d);
63			}
64			}
65
66
67			static void
68	greg	2.8	corner(int a, int b, int c) /* generate a triangular face */
69	schorsch	2.6	{
70			printf("\n%s polygon %s.%c%c%c\n", cmtype, cname,
71			let[a], let[b], let[c]);
72			printf("0\n0\n9\n");
73			if (reverse) {
74			vertex(c);
75			vertex(b);
76			vertex(a);
77			} else {
78			vertex(a);
79			vertex(b);
80			vertex(c);
81			}
82			}
83
84
85			static void
86	greg	2.8	cylinder(int v0, int v1) /* generate a cylinder */
87	schorsch	2.6	{
88			printf("\n%s cylinder %s.%c%c\n", cmtype, cname, v0+'0', v1+'0');
89			printf("0\n0\n7\n");
90			vertex(v0);
91			vertex(v1);
92			printf("\t%18.12g\n", bevel);
93			}
94
95
96	schorsch	2.7	static void
97	greg	2.8	sphere(int v0) /* generate a sphere */
98	schorsch	2.6	{
99			printf("\n%s sphere %s.%c\n", cmtype, cname, v0+'0');
100			printf("0\n0\n4\n");
101			vertex(v0);
102			printf("\t%18.12g\n", bevel);
103			}
104
105
106	schorsch	2.7	int
107	greg	2.9	main(int argc, char *argv[])
108	greg	1.1	{
109			int i;
110
111			if (argc < 6)
112			goto userr;
113
114			cmtype = argv[1];
115			cname = argv[2];
116			size[0] = atof(argv[3]);
117			size[1] = atof(argv[4]);
118			size[2] = atof(argv[5]);
119	greg	2.9	if ((size[0] <= 0.0) \| (size[1] <= 0.0) \| (size[2] <= 0.0))
120			goto userr;
121	greg	1.1
122			for (i = 6; i < argc; i++) {
123			if (argv[i][0] != '-')
124			goto userr;
125			switch (argv[i][1]) {
126	greg	2.9	case 'i':
127			reverse = 1;
128			break;
129	greg	1.1	case 'r':
130	greg	2.5	rounde = 1;
131	greg	1.1	/* fall through */
132			case 'b':
133			bevel = atof(argv[++i]);
134	greg	2.9	if (bevel > 0.0)
135			break;
136			/* fall through on error */
137	greg	1.1	default:
138			goto userr;
139			}
140			}
141	greg	2.9	if (rounde & reverse)
142			fprintf(stderr, "%s: warning - option -i ignored with -r\n",
143			argv[0]);
144	greg	1.1
145	greg	2.8	fputs("# ", stdout);
146			printargs(argc, argv, stdout);
147	greg	1.1
148			if (bevel > 0.0) {
149			/* minor faces */
150			side(051, 055, 054, 050);
151			side(064, 066, 062, 060);
152			side(032, 033, 031, 030);
153			side(053, 052, 056, 057);
154			side(065, 061, 063, 067);
155			side(036, 034, 035, 037);
156			}
157	greg	2.5	if (bevel > 0.0 && !rounde) {
158	greg	1.1	/* bevel faces */
159			side(031, 051, 050, 030);
160			side(060, 062, 032, 030);
161			side(050, 054, 064, 060);
162			side(034, 036, 066, 064);
163			side(037, 057, 056, 036);
164			side(052, 062, 066, 056);
165			side(052, 053, 033, 032);
166			side(057, 067, 063, 053);
167			side(061, 031, 033, 063);
168			side(065, 067, 037, 035);
169			side(055, 051, 061, 065);
170			side(034, 054, 055, 035);
171			/* bevel corners */
172			corner(030, 050, 060);
173			corner(051, 031, 061);
174			corner(032, 062, 052);
175			corner(064, 054, 034);
176			corner(036, 056, 066);
177			corner(065, 035, 055);
178			corner(053, 063, 033);
179			corner(037, 067, 057);
180			}
181	greg	2.5	if (bevel > 0.0 && rounde) {
182	greg	2.9	/* round edges */
183	greg	1.1	cylinder(070, 071);
184			cylinder(070, 074);
185			cylinder(070, 072);
186			cylinder(073, 071);
187			cylinder(073, 072);
188			cylinder(073, 077);
189			cylinder(075, 071);
190			cylinder(075, 074);
191			cylinder(075, 077);
192			cylinder(076, 072);
193			cylinder(076, 074);
194			cylinder(076, 077);
195	greg	2.9	/* round corners */
196	greg	1.1	sphere(070);
197			sphere(071);
198			sphere(072);
199			sphere(073);
200			sphere(074);
201			sphere(075);
202			sphere(076);
203			sphere(077);
204			}
205	greg	2.9	if (bevel == 0.0) {
206	greg	1.1	/* only need major faces */
207			side(1, 5, 4, 0);
208			side(4, 6, 2, 0);
209			side(2, 3, 1, 0);
210			side(3, 2, 6, 7);
211			side(5, 1, 3, 7);
212			side(6, 4, 5, 7);
213			}
214	greg	2.8	return(0);
215	greg	1.1	userr:
216			fprintf(stderr, "Usage: %s ", argv[0]);
217			fprintf(stderr, "material name xsize ysize zsize ");
218	greg	2.9	fprintf(stderr, "[-i] [-b bevel \| -r round]\n");
219	greg	2.8	return(1);
220	greg	1.1	}