ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/cv/mgf2rad.c
Revision: 2.22
Committed: Thu Jun 6 11:49:53 1996 UTC (27 years, 9 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.21: +3 -1 lines
Log Message:
bug fix in r_ies() associated with IES file pathnames

File Contents

# User Rev Content
1 greg 2.21 /* Copyright (c) 1996 Regents of the University of California */
2 greg 2.1
3     #ifndef lint
4     static char SCCSid[] = "$SunId$ LBL";
5     #endif
6    
7     /*
8     * Convert MGF (Materials and Geometry Format) to Radiance
9     */
10    
11     #include <stdio.h>
12     #include <math.h>
13     #include <string.h>
14     #include "mgflib/parser.h"
15     #include "color.h"
16     #include "tmesh.h"
17    
18     #define putv(v) printf("%18.12g %18.12g %18.12g\n",(v)[0],(v)[1],(v)[2])
19    
20 greg 2.9 #define invert (xf_context != NULL && xf_context->rev)
21    
22 greg 2.2 double glowdist = FHUGE; /* glow test distance */
23 greg 2.1
24 greg 2.8 double emult = 1.; /* emitter multiplier */
25 greg 2.1
26 greg 2.11 FILE *matfp = stdout; /* material output file */
27    
28 greg 2.1 int r_comment(), r_cone(), r_cyl(), r_face(), r_ies(), r_ring(), r_sph();
29     char *material(), *object(), *addarg();
30    
31    
32     main(argc, argv) /* convert files to stdout */
33     int argc;
34     char *argv[];
35     {
36 greg 2.20 int i;
37 greg 2.19 /* print out parser version */
38     printf("## Translated from MGF Version %d.%d\n", MG_VMAJOR, MG_VMINOR);
39 greg 2.1 /* initialize dispatch table */
40 greg 2.16 mg_ehand[MG_E_COMMENT] = r_comment; /* we pass comments */
41     mg_ehand[MG_E_COLOR] = c_hcolor; /* they get color */
42     mg_ehand[MG_E_CONE] = r_cone; /* we do cones */
43     mg_ehand[MG_E_CMIX] = c_hcolor; /* they mix colors */
44     mg_ehand[MG_E_CSPEC] = c_hcolor; /* they get spectra */
45     mg_ehand[MG_E_CXY] = c_hcolor; /* they get chromaticities */
46     mg_ehand[MG_E_CCT] = c_hcolor; /* they get color temp's */
47     mg_ehand[MG_E_CYL] = r_cyl; /* we do cylinders */
48     mg_ehand[MG_E_ED] = c_hmaterial; /* they get emission */
49     mg_ehand[MG_E_FACE] = r_face; /* we do faces */
50     mg_ehand[MG_E_IES] = r_ies; /* we do IES files */
51     mg_ehand[MG_E_IR] = c_hmaterial; /* they get refractive index */
52     mg_ehand[MG_E_MATERIAL] = c_hmaterial; /* they get materials */
53     mg_ehand[MG_E_NORMAL] = c_hvertex; /* they get normals */
54     mg_ehand[MG_E_OBJECT] = obj_handler; /* they track object names */
55     mg_ehand[MG_E_POINT] = c_hvertex; /* they get points */
56     mg_ehand[MG_E_RD] = c_hmaterial; /* they get diffuse refl. */
57     mg_ehand[MG_E_RING] = r_ring; /* we do rings */
58     mg_ehand[MG_E_RS] = c_hmaterial; /* they get specular refl. */
59     mg_ehand[MG_E_SIDES] = c_hmaterial; /* they get # sides */
60     mg_ehand[MG_E_SPH] = r_sph; /* we do spheres */
61     mg_ehand[MG_E_TD] = c_hmaterial; /* they get diffuse trans. */
62     mg_ehand[MG_E_TS] = c_hmaterial; /* they get specular trans. */
63     mg_ehand[MG_E_VERTEX] = c_hvertex; /* they get vertices */
64     mg_ehand[MG_E_XF] = xf_handler; /* they track transforms */
65 greg 2.1 mg_init(); /* initialize the parser */
66 greg 2.16 /* get our options & print header */
67 greg 2.1 printf("## %s", argv[0]);
68     for (i = 1; i < argc && argv[i][0] == '-'; i++) {
69     printf(" %s", argv[i]);
70     switch (argv[i][1]) {
71     case 'g': /* glow distance (meters) */
72 greg 2.10 if (argv[i][2] || badarg(argc-i-1, argv+i+1, "f"))
73 greg 2.1 goto userr;
74     glowdist = atof(argv[++i]);
75     printf(" %s", argv[i]);
76     break;
77     case 'e': /* emitter multiplier */
78 greg 2.10 if (argv[i][2] || badarg(argc-i-1, argv+i+1, "f"))
79 greg 2.1 goto userr;
80     emult = atof(argv[++i]);
81     printf(" %s", argv[i]);
82     break;
83 greg 2.11 case 'm': /* materials file */
84     matfp = fopen(argv[++i], "a");
85     if (matfp == NULL) {
86     fprintf(stderr, "%s: cannot append\n", argv[i]);
87     exit(1);
88     }
89     printf(" %s", argv[i]);
90     break;
91 greg 2.1 default:
92     goto userr;
93     }
94     }
95     putchar('\n');
96     if (i == argc) { /* convert stdin */
97 greg 2.20 if (mg_load(NULL) != MG_OK)
98 greg 2.1 exit(1);
99 greg 2.18 if (mg_nunknown)
100     printf("## %s: %u unknown entities\n",
101     argv[0], mg_nunknown);
102 greg 2.1 } else /* convert each file */
103     for ( ; i < argc; i++) {
104     printf("## %s %s ##############################\n",
105     argv[0], argv[i]);
106 greg 2.20 if (mg_load(argv[i]) != MG_OK)
107 greg 2.1 exit(1);
108 greg 2.18 if (mg_nunknown) {
109     printf("## %s %s: %u unknown entities\n",
110     argv[0], argv[i], mg_nunknown);
111     mg_nunknown = 0;
112     }
113 greg 2.1 }
114     exit(0);
115     userr:
116 greg 2.11 fprintf(stderr, "Usage: %s [-g dist][-e mult][-m matf] [file.mgf] ..\n",
117 greg 2.1 argv[0]);
118     exit(1);
119     }
120    
121    
122     int
123     r_comment(ac, av) /* repeat a comment verbatim */
124     register int ac;
125     register char **av;
126     {
127 greg 2.7 putchar('#'); /* use Radiance comment character */
128 greg 2.16 while (--ac) { /* pass through verbatim */
129 greg 2.1 putchar(' ');
130     fputs(*++av, stdout);
131     }
132     putchar('\n');
133     return(MG_OK);
134     }
135    
136    
137     int
138     r_cone(ac, av) /* put out a cone */
139     int ac;
140     char **av;
141     {
142     static int ncones;
143     char *mat;
144     double r1, r2;
145     C_VERTEX *cv1, *cv2;
146     FVECT p1, p2;
147     int inv;
148 greg 2.16 /* check argument count and type */
149 greg 2.1 if (ac != 5)
150     return(MG_EARGC);
151     if (!isflt(av[2]) || !isflt(av[4]))
152     return(MG_ETYPE);
153 greg 2.16 /* get the endpoint vertices */
154 greg 2.1 if ((cv1 = c_getvert(av[1])) == NULL ||
155     (cv2 = c_getvert(av[3])) == NULL)
156     return(MG_EUNDEF);
157 greg 2.16 xf_xfmpoint(p1, cv1->p); /* transform endpoints */
158 greg 2.1 xf_xfmpoint(p2, cv2->p);
159 greg 2.16 r1 = xf_scale(atof(av[2])); /* scale radii */
160 greg 2.1 r2 = xf_scale(atof(av[4]));
161 greg 2.16 inv = r1 < 0.; /* check for inverted cone */
162     if (r1 == 0.) { /* check for illegal radii */
163 greg 2.1 if (r2 == 0.)
164     return(MG_EILL);
165     inv = r2 < 0.;
166     } else if (r2 != 0. && inv ^ r2 < 0.)
167     return(MG_EILL);
168     if (inv) {
169     r1 = -r1;
170     r2 = -r2;
171     }
172 greg 2.16 if ((mat = material()) == NULL) /* get material */
173 greg 2.1 return(MG_EBADMAT);
174 greg 2.16 /* spit the sucker out */
175 greg 2.1 printf("\n%s %s %sc%d\n", mat, inv ? "cup" : "cone",
176     object(), ++ncones);
177     printf("0\n0\n8\n");
178     putv(p1);
179     putv(p2);
180     printf("%18.12g %18.12g\n", r1, r2);
181     return(MG_OK);
182     }
183    
184    
185     int
186     r_cyl(ac, av) /* put out a cylinder */
187     int ac;
188     char **av;
189     {
190     static int ncyls;
191     char *mat;
192     double rad;
193     C_VERTEX *cv1, *cv2;
194     FVECT p1, p2;
195     int inv;
196 greg 2.16 /* check argument count and type */
197 greg 2.1 if (ac != 4)
198     return(MG_EARGC);
199     if (!isflt(av[2]))
200     return(MG_ETYPE);
201 greg 2.16 /* get the endpoint vertices */
202 greg 2.1 if ((cv1 = c_getvert(av[1])) == NULL ||
203     (cv2 = c_getvert(av[3])) == NULL)
204     return(MG_EUNDEF);
205 greg 2.16 xf_xfmpoint(p1, cv1->p); /* transform endpoints */
206 greg 2.1 xf_xfmpoint(p2, cv2->p);
207 greg 2.16 rad = xf_scale(atof(av[2])); /* scale radius */
208     if ((inv = rad < 0.)) /* check for inverted cylinder */
209 greg 2.1 rad = -rad;
210 greg 2.16 if ((mat = material()) == NULL) /* get material */
211 greg 2.1 return(MG_EBADMAT);
212 greg 2.16 /* spit out the primitive */
213 greg 2.1 printf("\n%s %s %scy%d\n", mat, inv ? "tube" : "cylinder",
214     object(), ++ncyls);
215     printf("0\n0\n7\n");
216     putv(p1);
217     putv(p2);
218     printf("%18.12g\n", rad);
219     return(MG_OK);
220     }
221    
222    
223     int
224     r_sph(ac, av) /* put out a sphere */
225     int ac;
226     char **av;
227     {
228     static int nsphs;
229     char *mat;
230     double rad;
231     C_VERTEX *cv;
232     FVECT cent;
233     int inv;
234 greg 2.16 /* check argument count and type */
235 greg 2.1 if (ac != 3)
236     return(MG_EARGC);
237     if (!isflt(av[2]))
238     return(MG_ETYPE);
239 greg 2.16 if ((cv = c_getvert(av[1])) == NULL) /* get center vertex */
240 greg 2.1 return(MG_EUNDEF);
241 greg 2.16 xf_xfmpoint(cent, cv->p); /* transform center */
242     rad = xf_scale(atof(av[2])); /* scale radius */
243     if ((inv = rad < 0.)) /* check for inversion */
244 greg 2.1 rad = -rad;
245 greg 2.16 if ((mat = material()) == NULL) /* get material */
246 greg 2.1 return(MG_EBADMAT);
247 greg 2.16 /* spit out primitive */
248 greg 2.1 printf("\n%s %s %ss%d\n", mat, inv ? "bubble" : "sphere",
249     object(), ++nsphs);
250     printf("0\n0\n4 %18.12g %18.12g %18.12g %18.12g\n",
251     cent[0], cent[1], cent[2], rad);
252     return(MG_OK);
253     }
254    
255    
256     int
257     r_ring(ac, av) /* put out a ring */
258     int ac;
259     char **av;
260     {
261     static int nrings;
262     char *mat;
263     double r1, r2;
264     C_VERTEX *cv;
265     FVECT cent, norm;
266 greg 2.16 /* check argument count and type */
267 greg 2.1 if (ac != 4)
268     return(MG_EARGC);
269     if (!isflt(av[2]) || !isflt(av[3]))
270     return(MG_ETYPE);
271 greg 2.16 if ((cv = c_getvert(av[1])) == NULL) /* get center vertex */
272 greg 2.1 return(MG_EUNDEF);
273 greg 2.16 if (is0vect(cv->n)) /* make sure we have normal */
274 greg 2.1 return(MG_EILL);
275 greg 2.16 xf_xfmpoint(cent, cv->p); /* transform center */
276     xf_rotvect(norm, cv->n); /* rotate normal */
277     r1 = xf_scale(atof(av[2])); /* scale radii */
278 greg 2.1 r2 = xf_scale(atof(av[3]));
279     if (r1 < 0. | r2 <= r1)
280     return(MG_EILL);
281 greg 2.16 if ((mat = material()) == NULL) /* get material */
282 greg 2.1 return(MG_EBADMAT);
283 greg 2.16 /* spit out primitive */
284 greg 2.1 printf("\n%s ring %sr%d\n", mat, object(), ++nrings);
285     printf("0\n0\n8\n");
286     putv(cent);
287     putv(norm);
288     printf("%18.12g %18.12g\n", r1, r2);
289     return(MG_OK);
290     }
291    
292    
293     int
294     r_face(ac, av) /* convert a face */
295     int ac;
296     char **av;
297     {
298     static int nfaces;
299     char *mat;
300     register int i;
301     register C_VERTEX *cv;
302     FVECT v;
303     int rv;
304 greg 2.16 /* check argument count and type */
305 greg 2.1 if (ac < 4)
306     return(MG_EARGC);
307 greg 2.16 if ((mat = material()) == NULL) /* get material */
308 greg 2.1 return(MG_EBADMAT);
309 greg 2.16 if (ac <= 5) { /* check for smoothing */
310 greg 2.1 for (i = 1; i < ac; i++) {
311     if ((cv = c_getvert(av[i])) == NULL)
312     return(MG_EUNDEF);
313     if (is0vect(cv->n))
314     break;
315     }
316     if (i == ac) { /* break into triangles */
317     do_tri(mat, av[1], av[2], av[3]);
318     if (ac == 5)
319     do_tri(mat, av[3], av[4], av[1]);
320     return(MG_OK);
321     }
322     }
323 greg 2.16 /* spit out unsmoothed primitive */
324 greg 2.1 printf("\n%s polygon %sf%d\n", mat, object(), ++nfaces);
325     printf("0\n0\n%d\n", 3*(ac-1));
326 greg 2.16 for (i = 1; i < ac; i++) { /* get, transform, print each vertex */
327 greg 2.9 if ((cv = c_getvert(av[invert ? ac-i : i])) == NULL)
328 greg 2.1 return(MG_EUNDEF);
329     xf_xfmpoint(v, cv->p);
330     putv(v);
331     }
332     return(MG_OK);
333     }
334    
335    
336 greg 2.15 int
337 greg 2.1 r_ies(ac, av) /* convert an IES luminaire file */
338     int ac;
339     char **av;
340     {
341     int xa0 = 2;
342 greg 2.15 char combuf[128];
343 greg 2.1 char fname[48];
344     char *oname;
345     register char *op;
346     register int i;
347 greg 2.16 /* check argument count */
348 greg 2.1 if (ac < 2)
349     return(MG_EARGC);
350 greg 2.16 /* construct output file name */
351 greg 2.22 if ((op = strrchr(av[1], '/')) != NULL)
352     op++;
353     else
354 greg 2.1 op = av[1];
355     (void)strcpy(fname, op);
356     if ((op = strrchr(fname, '.')) == NULL)
357     op = fname + strlen(fname);
358     (void)strcpy(op, ".rad");
359 greg 2.16 /* see if we need to run ies2rad */
360 greg 2.17 if (access(fname, 0) == -1) {
361 greg 2.16 (void)strcpy(combuf, "ies2rad");/* build ies2rad command */
362     op = combuf + 7; /* get -m option (first) */
363     if (ac-xa0 >= 2 && !strcmp(av[xa0], "-m")) {
364     if (!isflt(av[xa0+1]))
365     return(MG_ETYPE);
366     op = addarg(addarg(op, "-m"), av[xa0+1]);
367     xa0 += 2;
368     }
369     *op++ = ' '; /* build IES filename */
370     i = 0;
371     if (mg_file != NULL &&
372     (oname = strrchr(mg_file->fname,'/')) != NULL) {
373     i = oname - mg_file->fname + 1;
374     (void)strcpy(op, mg_file->fname);
375     }
376     (void)strcpy(op+i, av[1]);
377     if (access(op, 0) == -1) /* check for file existence */
378     return(MG_ENOFILE);
379     system(combuf); /* run ies2rad */
380     if (access(fname, 0) == -1) /* check success */
381     return(MG_EINCL);
382     }
383     printf("\n!xform"); /* put out xform command */
384 greg 2.1 oname = object();
385 greg 2.4 if (*oname) {
386     printf(" -n ");
387     for (op = oname; op[1]; op++) /* remove trailing separator */
388     putchar(*op);
389     }
390 greg 2.1 for (i = xa0; i < ac; i++)
391     printf(" %s", av[i]);
392     if (ac > xa0 && xf_argc > 0)
393     printf(" -i 1");
394     for (i = 0; i < xf_argc; i++)
395     printf(" %s", xf_argv[i]);
396     printf(" %s\n", fname);
397     return(MG_OK);
398     }
399    
400    
401     do_tri(mat, vn1, vn2, vn3) /* put out smoothed triangle */
402     char *mat, *vn1, *vn2, *vn3;
403     {
404     static int ntris;
405     BARYCCM bvecs;
406     FLOAT bcoor[3][3];
407     C_VERTEX *cv1, *cv2, *cv3;
408     FVECT v1, v2, v3;
409     FVECT n1, n2, n3;
410     register int i;
411     /* the following is repeat code, so assume it's OK */
412     cv2 = c_getvert(vn2);
413 greg 2.9 if (invert) {
414     cv3 = c_getvert(vn1);
415     cv1 = c_getvert(vn3);
416     } else {
417     cv1 = c_getvert(vn1);
418     cv3 = c_getvert(vn3);
419     }
420 greg 2.1 xf_xfmpoint(v1, cv1->p);
421     xf_xfmpoint(v2, cv2->p);
422     xf_xfmpoint(v3, cv3->p);
423 greg 2.16 /* compute barycentric coords. */
424 greg 2.2 if (comp_baryc(&bvecs, v1, v2, v3) < 0)
425     return; /* degenerate triangle! */
426 greg 2.16 printf("\n%s texfunc T-nor\n", mat); /* put out texture */
427 greg 2.2 printf("4 dx dy dz %s\n0\n", TCALNAME);
428     xf_rotvect(n1, cv1->n);
429     xf_rotvect(n2, cv2->n);
430     xf_rotvect(n3, cv3->n);
431     for (i = 0; i < 3; i++) {
432     bcoor[i][0] = n1[i];
433     bcoor[i][1] = n2[i];
434     bcoor[i][2] = n3[i];
435 greg 2.1 }
436 greg 2.2 put_baryc(&bvecs, bcoor, 3);
437 greg 2.16 /* put out triangle */
438 greg 2.2 printf("\nT-nor polygon %st%d\n", object(), ++ntris);
439 greg 2.1 printf("0\n0\n9\n");
440     putv(v1);
441     putv(v2);
442     putv(v3);
443     }
444    
445    
446     char *
447     material() /* get (and print) current material */
448     {
449     char *mname = "mat";
450     COLOR radrgb, c2;
451     double d;
452     register int i;
453    
454 greg 2.5 if (c_cmname != NULL)
455     mname = c_cmname;
456 greg 2.1 if (!c_cmaterial->clock)
457     return(mname); /* already current */
458     /* else update output */
459     c_cmaterial->clock = 0;
460     if (c_cmaterial->ed > .1) { /* emitter */
461     cvtcolor(radrgb, &c_cmaterial->ed_c,
462 greg 2.12 emult*c_cmaterial->ed/(PI*WHTEFFICACY));
463 greg 2.2 if (glowdist < FHUGE) { /* do a glow */
464 greg 2.11 fprintf(matfp, "\nvoid glow %s\n0\n0\n", mname);
465     fprintf(matfp, "4 %f %f %f %f\n", colval(radrgb,RED),
466 greg 2.1 colval(radrgb,GRN),
467     colval(radrgb,BLU), glowdist);
468     } else {
469 greg 2.11 fprintf(matfp, "\nvoid light %s\n0\n0\n", mname);
470     fprintf(matfp, "3 %f %f %f\n", colval(radrgb,RED),
471 greg 2.1 colval(radrgb,GRN),
472     colval(radrgb,BLU));
473     }
474     return(mname);
475     }
476     d = c_cmaterial->rd + c_cmaterial->td +
477     c_cmaterial->rs + c_cmaterial->ts;
478 greg 2.7 if (d < 0. | d > 1.)
479 greg 2.1 return(NULL);
480 greg 2.14 /* check for glass/dielectric */
481     if (c_cmaterial->nr > 1.1 &&
482     c_cmaterial->ts > .25 && c_cmaterial->rs <= .125 &&
483     c_cmaterial->td <= .01 && c_cmaterial->rd <= .01 &&
484     c_cmaterial->rs_a <= .01 && c_cmaterial->ts_a <= .01) {
485     cvtcolor(radrgb, &c_cmaterial->ts_c,
486     c_cmaterial->ts + c_cmaterial->rs);
487     if (c_cmaterial->sided) { /* dielectric */
488     colval(radrgb,RED) = pow(colval(radrgb,RED),
489     1./C_1SIDEDTHICK);
490     colval(radrgb,GRN) = pow(colval(radrgb,GRN),
491     1./C_1SIDEDTHICK);
492     colval(radrgb,BLU) = pow(colval(radrgb,BLU),
493     1./C_1SIDEDTHICK);
494     fprintf(matfp, "\nvoid dielectric %s\n0\n0\n", mname);
495     fprintf(matfp, "5 %g %g %g %f 0\n", colval(radrgb,RED),
496     colval(radrgb,GRN), colval(radrgb,BLU),
497     c_cmaterial->nr);
498     return(mname);
499     }
500     /* glass */
501     fprintf(matfp, "\nvoid glass %s\n0\n0\n", mname);
502     fprintf(matfp, "4 %f %f %f %f\n", colval(radrgb,RED),
503     colval(radrgb,GRN), colval(radrgb,BLU),
504     c_cmaterial->nr);
505     return(mname);
506     }
507 greg 2.3 /* check for trans */
508     if (c_cmaterial->td > .01 || c_cmaterial->ts > .01) {
509 greg 2.1 double ts, a5, a6;
510    
511 greg 2.6 if (c_cmaterial->sided) {
512     ts = sqrt(c_cmaterial->ts); /* approximate */
513     a5 = .5;
514 greg 2.7 } else {
515     ts = c_cmaterial->ts;
516 greg 2.6 a5 = 1.;
517 greg 2.7 }
518 greg 2.1 /* average colors */
519     d = c_cmaterial->rd + c_cmaterial->td + ts;
520     cvtcolor(radrgb, &c_cmaterial->rd_c, c_cmaterial->rd/d);
521     cvtcolor(c2, &c_cmaterial->td_c, c_cmaterial->td/d);
522     addcolor(radrgb, c2);
523     cvtcolor(c2, &c_cmaterial->ts_c, ts/d);
524     addcolor(radrgb, c2);
525     if (c_cmaterial->rs + ts > .0001)
526     a5 = (c_cmaterial->rs*c_cmaterial->rs_a +
527 greg 2.6 ts*a5*c_cmaterial->ts_a) /
528 greg 2.1 (c_cmaterial->rs + ts);
529     a6 = (c_cmaterial->td + ts) /
530     (c_cmaterial->rd + c_cmaterial->td + ts);
531 greg 2.7 if (a6 < .999)
532 greg 2.1 d = c_cmaterial->rd/(1. - c_cmaterial->rs)/(1. - a6);
533 greg 2.7 else
534     d = c_cmaterial->td + ts;
535     scalecolor(radrgb, d);
536 greg 2.11 fprintf(matfp, "\nvoid trans %s\n0\n0\n", mname);
537     fprintf(matfp, "7 %f %f %f\n", colval(radrgb,RED),
538 greg 2.1 colval(radrgb,GRN), colval(radrgb,BLU));
539 greg 2.11 fprintf(matfp, "\t%f %f %f %f\n", c_cmaterial->rs, a5, a6,
540 greg 2.1 ts/(ts + c_cmaterial->td));
541     return(mname);
542     }
543 greg 2.3 /* check for plastic */
544 greg 2.21 if (c_cmaterial->rs < .1) {
545 greg 2.7 cvtcolor(radrgb, &c_cmaterial->rd_c,
546 greg 2.1 c_cmaterial->rd/(1.-c_cmaterial->rs));
547 greg 2.11 fprintf(matfp, "\nvoid plastic %s\n0\n0\n", mname);
548     fprintf(matfp, "5 %f %f %f %f %f\n", colval(radrgb,RED),
549 greg 2.1 colval(radrgb,GRN), colval(radrgb,BLU),
550     c_cmaterial->rs, c_cmaterial->rs_a);
551     return(mname);
552     }
553     /* else it's metal */
554 greg 2.7 /* average colors */
555     cvtcolor(radrgb, &c_cmaterial->rd_c, c_cmaterial->rd);
556     cvtcolor(c2, &c_cmaterial->rs_c, c_cmaterial->rs);
557 greg 2.1 addcolor(radrgb, c2);
558 greg 2.11 fprintf(matfp, "\nvoid metal %s\n0\n0\n", mname);
559     fprintf(matfp, "5 %f %f %f %f %f\n", colval(radrgb,RED),
560 greg 2.1 colval(radrgb,GRN), colval(radrgb,BLU),
561 greg 2.7 c_cmaterial->rs/(c_cmaterial->rd + c_cmaterial->rs),
562     c_cmaterial->rs_a);
563 greg 2.1 return(mname);
564     }
565    
566    
567 greg 2.16 cvtcolor(radrgb, ciec, intensity) /* convert a CIE XYZ color to RGB */
568 greg 2.1 COLOR radrgb;
569     register C_COLOR *ciec;
570     double intensity;
571     {
572     static COLOR ciexyz;
573    
574 greg 2.4 c_ccvt(ciec, C_CSXY); /* get xy representation */
575 greg 2.1 ciexyz[1] = intensity;
576     ciexyz[0] = ciec->cx/ciec->cy*ciexyz[1];
577     ciexyz[2] = ciexyz[1]*(1./ciec->cy - 1.) - ciexyz[0];
578     cie_rgb(radrgb, ciexyz);
579     }
580    
581    
582     char *
583     object() /* return current object name */
584     {
585     static char objbuf[64];
586     register int i;
587     register char *cp;
588     int len;
589 greg 2.16 /* tracked by obj_handler */
590 greg 2.1 i = obj_nnames - sizeof(objbuf)/16;
591     if (i < 0)
592     i = 0;
593     for (cp = objbuf; i < obj_nnames &&
594     cp + (len=strlen(obj_name[i])) < objbuf+sizeof(objbuf)-1;
595     i++, *cp++ = '.') {
596     strcpy(cp, obj_name[i]);
597     cp += len;
598     }
599     *cp = '\0';
600     return(objbuf);
601     }
602    
603    
604     char *
605     addarg(op, arg) /* add argument and advance pointer */
606     register char *op, *arg;
607     {
608     *op = ' ';
609     while (*++op = *arg++)
610     ;
611     return(op);
612     }