ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/cv/mgf2rad.c

Comparing ray/src/cv/mgf2rad.c (file contents):
Revision 2.26 by schorsch, Thu Jun 26 00:58:09 2003 UTC vs.
Revision 2.33 by greg, Thu Jan 4 01:55:42 2024 UTC

#	Line 9 | Line 9 | static const char      RCSid[] = "$Id$";
9		#include <stdlib.h>
10		#include <math.h>
11		#include <string.h>
12	<	#include "mgflib/parser.h"
12	>
13	>	#include "platform.h"
14	>	#include "mgf_parser.h"
15		#include "color.h"
16		#include "tmesh.h"
17	+	#include "lookup.h"
18
19		#define putv(v)         printf("%18.12g %18.12g %18.12g\n",(v)[0],(v)[1],(v)[2])
20
#	Line 23 | Line 26 | double  emult = 1.;                    /* emitter multiplier */
26
27		FILE    *matfp;                         /* material output file */
28
26	–	int     r_comment(), r_cone(), r_cyl(), r_face(), r_ies(), r_ring(), r_sph();
27	–	char    *material(), *object(), *addarg();
29
30	+	extern int r_comment(int ac, char **av);
31	+	extern int r_color(int ac, char **av);
32	+	extern int r_cone(int ac, char **av);
33	+	extern int r_cyl(int ac, char **av);
34	+	extern int r_sph(int ac, char **av);
35	+	extern int r_ring(int ac, char **av);
36	+	extern int r_face(int ac, char **av);
37	+	extern int r_ies(int ac, char **av);
38	+	extern void putsided(char *mname);
39	+	extern char * material(void);
40	+	extern char * object(void);
41	+	extern char * addarg(char *op, char *arg);
42	+	extern void do_tri(char *mat, C_VERTEX *cv1, C_VERTEX *cv2, C_VERTEX *cv3, int iv);
43	+	extern void cvtcolor(COLOR radrgb, C_COLOR *ciec, double intensity);
44	+	extern char * specolor(COLOR radrgb, C_COLOR *ciec, double intensity);
45
46	<	main(argc, argv)                /* convert files to stdout */
47	<	int     argc;
48	<	char    *argv[];
46	>
47	>	int
48	>	main(
49	>	int     argc,
50	>	char    *argv[]
51	>	)
52		{
53		int     i;
54
#	Line 41 | Line 60 | char   *argv[];
60		mg_ehand[MG_E_COLOR] = c_hcolor;        /* they get color */
61		mg_ehand[MG_E_CONE] = r_cone;           /* we do cones */
62		mg_ehand[MG_E_CMIX] = c_hcolor;         /* they mix colors */
44	–	mg_ehand[MG_E_CSPEC] = c_hcolor;        /* they get spectra */
63		mg_ehand[MG_E_CXY] = c_hcolor;          /* they get chromaticities */
64	<	mg_ehand[MG_E_CCT] = c_hcolor;          /* they get color temp's */
64	>	mg_ehand[MG_E_CSPEC] = r_color;         /* we get spectra */
65	>	mg_ehand[MG_E_CCT] = r_color;           /* we get color temp's */
66		mg_ehand[MG_E_CYL] = r_cyl;             /* we do cylinders */
67		mg_ehand[MG_E_ED] = c_hmaterial;        /* they get emission */
68		mg_ehand[MG_E_FACE] = r_face;           /* we do faces */
#	Line 120 | Line 139 | userr:
139
140
141		int
142	<	r_comment(ac, av)               /* repeat a comment verbatim */
143	<	register int    ac;
144	<	register char   **av;
142	>	r_comment(              /* repeat a comment verbatim */
143	>	int     ac,
144	>	char    **av
145	>	)
146		{
147		putchar('#');           /* use Radiance comment character */
148		while (--ac) {                  /* pass through verbatim */
#	Line 135 | Line 155 | register char  **av;
155
156
157		int
158	<	r_cone(ac, av)                  /* put out a cone */
159	<	int     ac;
160	<	char    **av;
158	>	r_color(                /* call color handler & remember name */
159	>	int     ac,
160	>	char    **av
161	>	)
162		{
163	+	int     rval = c_hcolor(ac, av);
164	+
165	+	if (rval == MG_OK)
166	+	c_ccolor->client_data = c_ccname;
167	+
168	+	return(rval);
169	+	}
170	+
171	+
172	+	int
173	+	r_cone(                 /* put out a cone */
174	+	int     ac,
175	+	char    **av
176	+	)
177	+	{
178		static int      ncones;
179		char    *mat;
180		double  r1, r2;
#	Line 163 | Line 199 | char   **av;
199		if (r2 == 0.)
200		return(MG_EILL);
201		inv = r2 < 0.;
202	<	} else if (r2 != 0. && inv ^ r2 < 0.)
202	>	} else if (r2 != 0. && inv ^ (r2 < 0.))
203		return(MG_EILL);
204		if (inv) {
205		r1 = -r1;
#	Line 183 | Line 219 | char   **av;
219
220
221		int
222	<	r_cyl(ac, av)                   /* put out a cylinder */
223	<	int     ac;
224	<	char    **av;
222	>	r_cyl(                  /* put out a cylinder */
223	>	int     ac,
224	>	char    **av
225	>	)
226		{
227		static int      ncyls;
228		char    *mat;
#	Line 221 | Line 258 | char   **av;
258
259
260		int
261	<	r_sph(ac, av)                   /* put out a sphere */
262	<	int     ac;
263	<	char    **av;
261	>	r_sph(                  /* put out a sphere */
262	>	int     ac,
263	>	char    **av
264	>	)
265		{
266		static int      nsphs;
267		char    *mat;
#	Line 254 | Line 292 | char   **av;
292
293
294		int
295	<	r_ring(ac, av)                  /* put out a ring */
296	<	int     ac;
297	<	char    **av;
295	>	r_ring(                 /* put out a ring */
296	>	int     ac,
297	>	char    **av
298	>	)
299		{
300		static int      nrings;
301		char    *mat;
#	Line 276 | Line 315 | char   **av;
315		xf_rotvect(norm, cv->n);                /* rotate normal */
316		r1 = xf_scale(atof(av[2]));             /* scale radii */
317		r2 = xf_scale(atof(av[3]));
318	<	if (r1 < 0. | r2 <= r1)
318	>	if ((r1 < 0.) | (r2 <= r1))
319		return(MG_EILL);
320		if ((mat = material()) == NULL)         /* get material */
321		return(MG_EBADMAT);
#	Line 291 | Line 330 | char   **av;
330
331
332		int
333	<	r_face(ac, av)                  /* convert a face */
334	<	int     ac;
335	<	char    **av;
333	>	r_face(                 /* convert a face */
334	>	int     ac,
335	>	char    **av
336	>	)
337		{
338		static int      nfaces;
339		int             myi = invert;
340		char    *mat;
341	<	register int    i;
342	<	register C_VERTEX       *cv;
341	>	int     i;
342	>	C_VERTEX        *cv;
343		FVECT   v;
344	<	int     rv;
344	>
345		/* check argument count and type */
346		if (ac < 4)
347		return(MG_EARGC);
#	Line 350 | Line 390 | char   **av;
390
391
392		int
393	<	r_ies(ac, av)                           /* convert an IES luminaire file */
394	<	int     ac;
395	<	char    **av;
393	>	r_ies(                          /* convert an IES luminaire file */
394	>	int     ac,
395	>	char    **av
396	>	)
397		{
398		int     xa0 = 2;
399		char    combuf[128];
400		char    fname[48];
401		char    *oname;
402	<	register char   *op;
403	<	register int    i;
402	>	char    *op;
403	>	int     i;
404		/* check argument count */
405		if (ac < 2)
406		return(MG_EARGC);
#	Line 414 | Line 455 | char   **av;
455		}
456
457
458	<	do_tri(mat, cv1, cv2, cv3, iv)          /* put out smoothed triangle */
459	<	char    *mat;
460	<	C_VERTEX        *cv1, *cv2, *cv3;
461	<	int     iv;
458	>	void
459	>	do_tri(         /* put out smoothed triangle */
460	>	char    *mat,
461	>	C_VERTEX        *cv1,
462	>	C_VERTEX        *cv2,
463	>	C_VERTEX        *cv3,
464	>	int     iv
465	>	)
466		{
467		static int      ntris;
468		BARYCCM bvecs;
#	Line 425 | Line 470 | int    iv;
470		C_VERTEX        *cvt;
471		FVECT   v1, v2, v3;
472		FVECT   n1, n2, n3;
473	<	register int    i;
473	>	int     i;
474
475		if (iv) {                       /* swap vertex order if inverted */
476		cvt = cv1;
#	Line 448 | Line 493 | int    iv;
493		bcoor[i][1] = n2[i];
494		bcoor[i][2] = n3[i];
495		}
496	<	put_baryc(&bvecs, bcoor, 3);
496	>	fput_baryc(&bvecs, bcoor, 3, stdout);
497		/* put out triangle */
498		printf("\nT-nor polygon %st%d\n", object(), ++ntris);
499		printf("0\n0\n9\n");
#	Line 458 | Line 503 | int    iv;
503		}
504
505
506	+	void
507	+	putsided(char *mname)           /* print out mixfunc for sided material */
508	+	{
509	+	fprintf(matfp, "\nvoid mixfunc %s\n", mname);
510	+	fprintf(matfp, "4 %s void if(Rdot,1,0) .\n0\n0\n", mname);
511	+	}
512	+
513	+
514		char *
515	<	material()                      /* get (and print) current material */
515	>	material(void)                  /* get (and print) current material */
516		{
517		char    *mname = "mat";
518	+	char    *pname;
519		COLOR   radrgb, c2;
520		double  d;
467	–	register int    i;
521
522		if (c_cmname != NULL)
523		mname = c_cmname;
#	Line 473 | Line 526 | material()                     /* get (and print) current material */
526		/* else update output */
527		c_cmaterial->clock = 0;
528		if (c_cmaterial->ed > .1) {     /* emitter */
529	<	cvtcolor(radrgb, &c_cmaterial->ed_c,
529	>	pname = specolor(radrgb, &c_cmaterial->ed_c,
530		emult*c_cmaterial->ed/(PI*WHTEFFICACY));
531		if (glowdist < FHUGE) {         /* do a glow */
532	<	fprintf(matfp, "\nvoid glow %s\n0\n0\n", mname);
532	>	fprintf(matfp, "\n%s glow %s\n0\n0\n", pname, mname);
533		fprintf(matfp, "4 %f %f %f %f\n", colval(radrgb,RED),
534		colval(radrgb,GRN),
535		colval(radrgb,BLU), glowdist);
536		} else {
537	<	fprintf(matfp, "\nvoid light %s\n0\n0\n", mname);
537	>	fprintf(matfp, "\n%s light %s\n0\n0\n", pname, mname);
538		fprintf(matfp, "3 %f %f %f\n", colval(radrgb,RED),
539		colval(radrgb,GRN),
540		colval(radrgb,BLU));
#	Line 490 | Line 543 | material()                     /* get (and print) current material */
543		}
544		d = c_cmaterial->rd + c_cmaterial->td +
545		c_cmaterial->rs + c_cmaterial->ts;
546	<	if (d < 0. | d > 1.)
546	>	if ((d < 0.) | (d > 1.))
547		return(NULL);
548		/* check for glass/dielectric */
549		if (c_cmaterial->nr > 1.1 &&
#	Line 518 | Line 571 | material()                     /* get (and print) current material */
571		colval(radrgb,GRN), colval(radrgb,BLU),
572		c_cmaterial->nr);
573		return(mname);
574	<	}
574	>	}
575		/* check for trans */
576		if (c_cmaterial->td > .01 || c_cmaterial->ts > .01) {
577	<	double  ts, a5, a6;
525	<
526	<	if (c_cmaterial->sided) {
527	<	ts = sqrt(c_cmaterial->ts);     /* approximate */
528	<	a5 = .5;
529	<	} else {
530	<	ts = c_cmaterial->ts;
531	<	a5 = 1.;
532	<	}
577	>	double  a5, a6;
578		/* average colors */
579	<	d = c_cmaterial->rd + c_cmaterial->td + ts;
579	>	d = c_cmaterial->rd + c_cmaterial->td + c_cmaterial->ts;
580		cvtcolor(radrgb, &c_cmaterial->rd_c, c_cmaterial->rd/d);
581		cvtcolor(c2, &c_cmaterial->td_c, c_cmaterial->td/d);
582		addcolor(radrgb, c2);
583	<	cvtcolor(c2, &c_cmaterial->ts_c, ts/d);
583	>	cvtcolor(c2, &c_cmaterial->ts_c, c_cmaterial->ts/d);
584		addcolor(radrgb, c2);
585	<	if (c_cmaterial->rs + ts > .0001)
585	>	if (c_cmaterial->rs + c_cmaterial->ts > .0001)
586		a5 = (c_cmaterial->rs*c_cmaterial->rs_a +
587	<	ts*a5*c_cmaterial->ts_a) /
588	<	(c_cmaterial->rs + ts);
589	<	a6 = (c_cmaterial->td + ts) /
590	<	(c_cmaterial->rd + c_cmaterial->td + ts);
587	>	c_cmaterial->ts*c_cmaterial->ts_a) /
588	>	(c_cmaterial->rs + c_cmaterial->ts);
589	>	a6 = (c_cmaterial->td + c_cmaterial->ts) /
590	>	(c_cmaterial->rd + c_cmaterial->td + c_cmaterial->ts);
591		if (a6 < .999)
592		d = c_cmaterial->rd/(1. - c_cmaterial->rs)/(1. - a6);
593		else
594	<	d = c_cmaterial->td + ts;
594	>	d = c_cmaterial->td + c_cmaterial->ts;
595		scalecolor(radrgb, d);
596		fprintf(matfp, "\nvoid trans %s\n0\n0\n", mname);
597		fprintf(matfp, "7 %f %f %f\n", colval(radrgb,RED),
598		colval(radrgb,GRN), colval(radrgb,BLU));
599		fprintf(matfp, "\t%f %f %f %f\n", c_cmaterial->rs, a5, a6,
600	<	ts/(ts + c_cmaterial->td));
600	>	c_cmaterial->ts/(c_cmaterial->ts + c_cmaterial->td));
601	>	if (c_cmaterial->sided)
602	>	putsided(mname);
603		return(mname);
604		}
605		/* check for plastic */
606	<	if (c_cmaterial->rs < .1) {
607	<	cvtcolor(radrgb, &c_cmaterial->rd_c,
606	>	if (c_cmaterial->rs < .1 && (c_cmaterial->rs < .1*c_cmaterial->rd ||
607	>	c_isgrey(&c_cmaterial->rs_c))) {
608	>	pname = specolor(radrgb, &c_cmaterial->rd_c,
609		c_cmaterial->rd/(1.-c_cmaterial->rs));
610	<	fprintf(matfp, "\nvoid plastic %s\n0\n0\n", mname);
610	>	fprintf(matfp, "\n%s plastic %s\n0\n0\n", pname, mname);
611		fprintf(matfp, "5 %f %f %f %f %f\n", colval(radrgb,RED),
612		colval(radrgb,GRN), colval(radrgb,BLU),
613		c_cmaterial->rs, c_cmaterial->rs_a);
614	+	if (c_cmaterial->sided)
615	+	putsided(mname);
616		return(mname);
617		}
618		/* else it's metal */
619	<	/* average colors */
620	<	cvtcolor(radrgb, &c_cmaterial->rd_c, c_cmaterial->rd);
621	<	cvtcolor(c2, &c_cmaterial->rs_c, c_cmaterial->rs);
622	<	addcolor(radrgb, c2);
623	<	fprintf(matfp, "\nvoid metal %s\n0\n0\n", mname);
619	>	/* compute color */
620	>	if (c_equiv(&c_cmaterial->rd_c, &c_cmaterial->rs_c)) {
621	>	pname = specolor(radrgb, &c_cmaterial->rs_c, c_cmaterial->rs+c_cmaterial->rd);
622	>	} else if (c_cmaterial->rd <= .05f) {
623	>	pname = specolor(radrgb, &c_cmaterial->rs_c, c_cmaterial->rs);
624	>	cvtcolor(c2, &c_cmaterial->rd_c, c_cmaterial->rd);
625	>	addcolor(radrgb, c2);
626	>	} else {
627	>	pname = "void";
628	>	cvtcolor(radrgb, &c_cmaterial->rd_c, c_cmaterial->rd);
629	>	cvtcolor(c2, &c_cmaterial->rs_c, c_cmaterial->rs);
630	>	addcolor(radrgb, c2);
631	>	}
632	>	fprintf(matfp, "\n%s metal %s\n0\n0\n", pname, mname);
633		fprintf(matfp, "5 %f %f %f %f %f\n", colval(radrgb,RED),
634		colval(radrgb,GRN), colval(radrgb,BLU),
635		c_cmaterial->rs/(c_cmaterial->rd + c_cmaterial->rs),
636		c_cmaterial->rs_a);
637	+	if (c_cmaterial->sided)
638	+	putsided(mname);
639		return(mname);
640		}
641
642
643	<	cvtcolor(radrgb, ciec, intensity)       /* convert a CIE XYZ color to RGB */
644	<	COLOR   radrgb;
645	<	register C_COLOR        *ciec;
646	<	double  intensity;
643	>	void
644	>	cvtcolor(       /* convert a CIE XYZ color to RGB */
645	>	COLOR   radrgb,
646	>	C_COLOR *ciec,
647	>	double  intensity
648	>	)
649		{
650	<	static COLOR    ciexyz;
650	>	COLOR   ciexyz;
651
652		c_ccvt(ciec, C_CSXY);           /* get xy representation */
653		ciexyz[1] = intensity;
#	Line 594 | Line 657 | double intensity;
657		}
658
659
660	+	static int      /* new spectrum definition? */
661	+	newspecdef(C_COLOR *spc)
662	+	{
663	+	static LUTAB    spc_tab = LU_SINIT(NULL,free);
664	+	LUENT   *lp = lu_find(&spc_tab, (const char *)spc->client_data);
665	+
666	+	if (lp == NULL)                 /* should never happen */
667	+	return(1);
668	+	if (lp->data == NULL) {         /* new entry */
669	+	lp->key = (char *)spc->client_data;
670	+	lp->data = (char *)malloc(sizeof(C_COLOR));
671	+	} else if (c_equiv(spc, (C_COLOR *)lp->data))
672	+	return(0);              /* unchanged */
673	+
674	+	if (lp->data != NULL)           /* else remember if we can */
675	+	*(C_COLOR *)lp->data = *spc;
676	+	return(1);                      /* good as new */
677	+	}
678	+
679	+
680		char *
681	<	object()                        /* return current object name */
681	>	specolor(       /* check if color has spectra and output accordingly */
682	>	COLOR   radrgb,
683	>	C_COLOR *clr,
684	>	double  intensity
685	>	)
686		{
687	+	static char     spname[128];
688	+	double  mult;
689	+	int     i;
690	+
691	+	if (!(clr->flags & C_CDSPEC)) {         /* not defined spectrally? */
692	+	cvtcolor(radrgb, clr, intensity);
693	+	return("void");
694	+	}
695	+	setcolor(radrgb, intensity, intensity, intensity);
696	+	if (clr->client_data != NULL) {         /* get name if available */
697	+	strcpy(spname, (char *)clr->client_data);
698	+	strcat(spname, "*");            /* make sure it's special */
699	+	if (!newspecdef(clr))           /* output already? */
700	+	return(spname);
701	+	} else
702	+	strcpy(spname, "spec*");
703	+	c_ccvt(clr, C_CSEFF);                   /* else output spectrum prim */
704	+	fprintf(matfp, "\nvoid spectrum %s\n0\n0\n", spname);
705	+	fprintf(matfp, "%d %d %d", C_CNSS+2, C_CMINWL, C_CMAXWL);
706	+	mult = (C_CNSS*c_dfcolor.eff)/(clr->ssum*clr->eff);
707	+	for (i = 0; i < C_CNSS; i++) {
708	+	if (!((i+1)%6)) fputc('\n', matfp);
709	+	fprintf(matfp, "\t%.5f", clr->ssamp[i]*mult);
710	+	}
711	+	fputc('\n', matfp);
712	+	return(spname);
713	+	}
714	+
715	+
716	+	char *
717	+	object(void)                    /* return current object name */
718	+	{
719		static char     objbuf[64];
720	<	register int    i;
721	<	register char   *cp;
720	>	int     i;
721	>	char    *cp;
722		int     len;
723		/* tracked by obj_handler */
724		i = obj_nnames - sizeof(objbuf)/16;
#	Line 617 | Line 736 | object()                       /* return current object name */
736
737
738		char *
739	<	addarg(op, arg)                         /* add argument and advance pointer */
740	<	register char   *op, *arg;
739	>	addarg(                         /* add argument and advance pointer */
740	>	char *op,
741	>	char *arg
742	>	)
743		{
744		*op = ' ';
745	<	while (*++op = *arg++)
745	>	while ( (*++op = *arg++) )
746		;
747		return(op);
748		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)