src/gen/genbox.c

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