1 |
– |
/* Copyright (c) 1986 Regents of the University of California */ |
2 |
– |
|
1 |
|
#ifndef lint |
2 |
< |
static char SCCSid[] = "$SunId$ LBL"; |
2 |
> |
static const char RCSid[] = "$Id$"; |
3 |
|
#endif |
6 |
– |
|
4 |
|
/* |
5 |
|
* genbox.c - generate a parallelepiped. |
6 |
|
* |
7 |
|
* 1/8/86 |
8 |
|
*/ |
9 |
|
|
10 |
< |
#include <stdio.h> |
11 |
< |
|
10 |
> |
#include "rtio.h" |
11 |
> |
#include <stdlib.h> |
12 |
|
#include <math.h> |
13 |
|
|
14 |
|
|
18 |
– |
#ifdef DCL_ATOF |
19 |
– |
extern double atof(); |
20 |
– |
#endif |
21 |
– |
|
15 |
|
char let[]="0123456789._ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; |
16 |
|
|
17 |
|
char *cmtype; /* ppd material type */ |
22 |
|
|
23 |
|
double bevel = 0.0; /* bevel amount */ |
24 |
|
|
25 |
< |
int round = 0; /* boolean true for round edges */ |
25 |
> |
int rounde = 0; /* boolean true for round edges */ |
26 |
|
|
27 |
|
int reverse = 0; /* boolean true for reversed normals */ |
28 |
|
|
29 |
|
|
30 |
< |
main(argc, argv) |
31 |
< |
int argc; |
32 |
< |
char **argv; |
30 |
> |
|
31 |
> |
static void |
32 |
> |
vertex(int v) |
33 |
|
{ |
34 |
|
int i; |
35 |
+ |
|
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 |
+ |
fputc('\n', stdout); |
44 |
+ |
} |
45 |
+ |
|
46 |
+ |
|
47 |
+ |
static void |
48 |
+ |
side(int a, int b, int c, int d) /* generate a rectangular face */ |
49 |
+ |
{ |
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 |
+ |
corner(int a, int b, int c) /* generate a triangular face */ |
69 |
+ |
{ |
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 |
+ |
cylinder(int v0, int v1) /* generate a cylinder */ |
87 |
+ |
{ |
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 |
+ |
static void |
97 |
+ |
sphere(int v0) /* generate a sphere */ |
98 |
+ |
{ |
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 |
+ |
int |
107 |
+ |
main(int argc, char *argv[]) |
108 |
+ |
{ |
109 |
+ |
int i; |
110 |
|
|
111 |
|
if (argc < 6) |
112 |
|
goto userr; |
116 |
|
size[0] = atof(argv[3]); |
117 |
|
size[1] = atof(argv[4]); |
118 |
|
size[2] = atof(argv[5]); |
119 |
+ |
if ((size[0] <= 0.0) | (size[1] <= 0.0) | (size[2] <= 0.0)) |
120 |
+ |
goto userr; |
121 |
|
|
122 |
|
for (i = 6; i < argc; i++) { |
123 |
|
if (argv[i][0] != '-') |
124 |
|
goto userr; |
125 |
|
switch (argv[i][1]) { |
126 |
+ |
case 'i': |
127 |
+ |
reverse = 1; |
128 |
+ |
break; |
129 |
|
case 'r': |
130 |
< |
round = 1; |
130 |
> |
rounde = 1; |
131 |
|
/* fall through */ |
132 |
|
case 'b': |
133 |
|
bevel = atof(argv[++i]); |
134 |
< |
break; |
135 |
< |
case 'i': |
136 |
< |
reverse = 1; |
64 |
< |
break; |
134 |
> |
if (bevel > 0.0) |
135 |
> |
break; |
136 |
> |
/* fall through on error */ |
137 |
|
default: |
138 |
|
goto userr; |
139 |
|
} |
140 |
|
} |
141 |
+ |
if (rounde & reverse) |
142 |
+ |
fprintf(stderr, "%s: warning - option -i ignored with -r\n", |
143 |
+ |
argv[0]); |
144 |
|
|
145 |
< |
printhead(argc, argv); |
145 |
> |
fputs("# ", stdout); |
146 |
> |
printargs(argc, argv, stdout); |
147 |
|
|
148 |
|
if (bevel > 0.0) { |
149 |
|
/* minor faces */ |
154 |
|
side(065, 061, 063, 067); |
155 |
|
side(036, 034, 035, 037); |
156 |
|
} |
157 |
< |
if (bevel > 0.0 && !round) { |
157 |
> |
if (bevel > 0.0 && !rounde) { |
158 |
|
/* bevel faces */ |
159 |
|
side(031, 051, 050, 030); |
160 |
|
side(060, 062, 032, 030); |
178 |
|
corner(053, 063, 033); |
179 |
|
corner(037, 067, 057); |
180 |
|
} |
181 |
< |
if (bevel > 0.0 && round) { |
181 |
> |
if (bevel > 0.0 && rounde) { |
182 |
|
/* round edges */ |
183 |
|
cylinder(070, 071); |
184 |
|
cylinder(070, 074); |
202 |
|
sphere(076); |
203 |
|
sphere(077); |
204 |
|
} |
205 |
< |
if (bevel == 0.0 ) { |
205 |
> |
if (bevel == 0.0) { |
206 |
|
/* only need major faces */ |
207 |
|
side(1, 5, 4, 0); |
208 |
|
side(4, 6, 2, 0); |
211 |
|
side(5, 1, 3, 7); |
212 |
|
side(6, 4, 5, 7); |
213 |
|
} |
214 |
< |
exit(0); |
214 |
> |
return(0); |
215 |
|
userr: |
216 |
|
fprintf(stderr, "Usage: %s ", argv[0]); |
217 |
|
fprintf(stderr, "material name xsize ysize zsize "); |
218 |
|
fprintf(stderr, "[-i] [-b bevel | -r round]\n"); |
219 |
< |
exit(1); |
144 |
< |
} |
145 |
< |
|
146 |
< |
|
147 |
< |
side(a, b, c, d) /* generate a rectangular face */ |
148 |
< |
int a, b, c, d; |
149 |
< |
{ |
150 |
< |
printf("\n%s polygon %s.%c%c%c%c\n", cmtype, cname, |
151 |
< |
let[a], let[b], let[c], let[d]); |
152 |
< |
printf("0\n0\n12\n"); |
153 |
< |
if (reverse) { |
154 |
< |
vertex(d); |
155 |
< |
vertex(c); |
156 |
< |
vertex(b); |
157 |
< |
vertex(a); |
158 |
< |
} else { |
159 |
< |
vertex(a); |
160 |
< |
vertex(b); |
161 |
< |
vertex(c); |
162 |
< |
vertex(d); |
163 |
< |
} |
164 |
< |
} |
165 |
< |
|
166 |
< |
|
167 |
< |
corner(a, b, c) /* generate a triangular face */ |
168 |
< |
int a, b, c; |
169 |
< |
{ |
170 |
< |
printf("\n%s polygon %s.%c%c%c\n", cmtype, cname, |
171 |
< |
let[a], let[b], let[c]); |
172 |
< |
printf("0\n0\n9\n"); |
173 |
< |
if (reverse) { |
174 |
< |
vertex(c); |
175 |
< |
vertex(b); |
176 |
< |
vertex(a); |
177 |
< |
} else { |
178 |
< |
vertex(a); |
179 |
< |
vertex(b); |
180 |
< |
vertex(c); |
181 |
< |
} |
182 |
< |
} |
183 |
< |
|
184 |
< |
|
185 |
< |
cylinder(v0, v1) /* generate a cylinder */ |
186 |
< |
int v0, v1; |
187 |
< |
{ |
188 |
< |
printf("\n%s cylinder %s.%c%c\n", cmtype, cname, v0+'0', v1+'0'); |
189 |
< |
printf("0\n0\n7\n"); |
190 |
< |
vertex(v0); |
191 |
< |
vertex(v1); |
192 |
< |
printf("\t%18.12g\n", bevel); |
193 |
< |
} |
194 |
< |
|
195 |
< |
|
196 |
< |
sphere(v0) /* generate a sphere */ |
197 |
< |
int v0; |
198 |
< |
{ |
199 |
< |
printf("\n%s sphere %s.%c\n", cmtype, cname, v0+'0'); |
200 |
< |
printf("0\n0\n4\n"); |
201 |
< |
vertex(v0); |
202 |
< |
printf("\t%18.12g\n", bevel); |
203 |
< |
} |
204 |
< |
|
205 |
< |
|
206 |
< |
vertex(v) |
207 |
< |
register int v; |
208 |
< |
{ |
209 |
< |
register int i; |
210 |
< |
|
211 |
< |
for (i = 0; i < 3; i++) { |
212 |
< |
if (v & 010) |
213 |
< |
printf("\t%18.12g", v & 01 ? size[i]-bevel : bevel); |
214 |
< |
else |
215 |
< |
printf("\t%18.12g", v & 01 ? size[i] : 0.0); |
216 |
< |
v >>= 1; |
217 |
< |
} |
218 |
< |
printf("\n"); |
219 |
< |
} |
220 |
< |
|
221 |
< |
|
222 |
< |
printhead(ac, av) /* print command header */ |
223 |
< |
register int ac; |
224 |
< |
register char **av; |
225 |
< |
{ |
226 |
< |
putchar('#'); |
227 |
< |
while (ac--) { |
228 |
< |
putchar(' '); |
229 |
< |
fputs(*av++, stdout); |
230 |
< |
} |
231 |
< |
putchar('\n'); |
219 |
> |
return(1); |
220 |
|
} |