ViewVC Help

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

root/Development/ray/src/rt/rtrace.c

Comparing ray/src/rt/rtrace.c (file contents):
Revision 2.67 by greg, Wed Jun 27 15:32:58 2012 UTC vs.
Revision 2.90 by greg, Sat Apr 4 15:38:52 2020 UTC

#	Line 28 | Line 28 | static const char      RCSid[] = "$Id$";
28		#include  "ambient.h"
29		#include  "source.h"
30		#include  "otypes.h"
31	+	#include  "otspecial.h"
32		#include  "resolu.h"
33		#include  "random.h"
34
#	Line 53 | Line 54 | OBJECT traset[MAXTSET+1]={0};          /* trace include/exclud
54
55		static RAY  thisray;                    /* for our convenience */
56
57	+	static FILE  *inpfp = NULL;             /* input stream pointer */
58	+
59	+	static FVECT    *inp_queue = NULL;      /* ray input queue if flushing */
60	+	static int      inp_qpos = 0;           /* next ray to return */
61	+	static int      inp_qend = 0;           /* number of rays in this work group */
62	+
63		typedef void putf_t(RREAL *v, int n);
64	<	static putf_t puta, putd, putf;
64	>	static putf_t puta, putd, putf, putrgbe;
65
66		typedef void oputf_t(RAY *r);
67		static oputf_t  oputo, oputd, oputv, oputV, oputl, oputL, oputc, oputp,
68	<	oputn, oputN, oputs, oputw, oputW, oputm, oputM, oputtilde;
68	>	oputr, oputR, oputx, oputX, oputn, oputN, oputs,
69	>	oputw, oputW, oputm, oputM, oputtilde;
70
71		static void setoutput(char *vs);
72		extern void tranotify(OBJECT obj);
#	Line 68 | Line 76 | static void rayirrad(RAY *r);
76		static void rtcompute(FVECT org, FVECT dir, double dmax);
77		static int printvals(RAY *r);
78		static int getvec(FVECT vec, int fmt, FILE *fp);
79	+	static int iszerovec(const FVECT vec);
80	+	static double nextray(FVECT org, FVECT dir);
81		static void tabin(RAY *r);
82		static void ourtrace(RAY *r);
83
84	<	static oputf_t *ray_out[16], *every_out[16];
84	>	static oputf_t *ray_out[32], *every_out[32];
85		static putf_t *putreal;
86
87
#	Line 115 | Line 125 | rtrace(                                /* trace rays from file */
125		{
126		unsigned long  vcount = (hresolu > 1) ? (unsigned long)hresolu*vresolu
127		: (unsigned long)vresolu;
128	<	long  nextflush = (vresolu > 0) & (hresolu > 1) ? 0 : hresolu;
128	>	long  nextflush = (!vresolu | (hresolu <= 1)) * hresolu;
129	>	int  something2flush = 0;
130		FILE  *fp;
131		double  d;
132		FVECT  orig, direc;
133		/* set up input */
134		if (fname == NULL)
135	<	fp = stdin;
136	<	else if ((fp = fopen(fname, "r")) == NULL) {
135	>	inpfp = stdin;
136	>	else if ((inpfp = fopen(fname, "r")) == NULL) {
137		sprintf(errmsg, "cannot open input file \"%s\"", fname);
138		error(SYSTEM, errmsg);
139		}
140	+	#ifdef getc_unlocked
141	+	flockfile(inpfp);               /* avoid lock/unlock overhead */
142	+	flockfile(stdout);
143	+	#endif
144		if (inform != 'a')
145	<	SET_FILE_BINARY(fp);
145	>	SET_FILE_BINARY(inpfp);
146		/* set up output */
147		setoutput(outvals);
148		if (imm_irrad)
149		castonly = 0;
150	<	else if (castonly)
150	>	else if (castonly || every_out[0] != NULL)
151		nproc = 1;              /* don't bother multiprocessing */
152	+	if ((nextflush > 0) & (nproc > nextflush)) {
153	+	error(WARNING, "reducing number of processes to match flush interval");
154	+	nproc = nextflush;
155	+	}
156		switch (outform) {
157		case 'a': putreal = puta; break;
158		case 'f': putreal = putf; break;
159		case 'd': putreal = putd; break;
160		case 'c':
161	<	if (strcmp(outvals, "v"))
162	<	error(USER, "color format with value output only");
163	<	break;
161	>	if (outvals[0] && (outvals[1] || !strchr("vrx", outvals[0])))
162	>	error(USER, "color format only with -ov, -or, -ox");
163	>	putreal = putrgbe; break;
164		default:
165		error(CONSISTENCY, "botched output format");
166		}
#	Line 152 | Line 171 | rtrace(                                /* trace rays from file */
171		if (hresolu > 0) {
172		if (vresolu > 0)
173		fprtresolu(hresolu, vresolu, stdout);
174	<	fflush(stdout);
174	>	else
175	>	fflush(stdout);
176		}
177	<	/* process file */
178	<	while (getvec(orig, inform, fp) == 0 &&
179	<	getvec(direc, inform, fp) == 0) {
180	<
181	<	d = normalize(direc);
182	<	if (d == 0.0) {                         /* zero ==> flush */
163	<	if (--nextflush <= 0 || !vcount) {
164	<	if (nproc > 1 && ray_fifo_flush() < 0)
165	<	error(USER, "lost children");
177	>	/* process input rays */
178	>	while ((d = nextray(orig, direc)) >= 0.0) {
179	>	if (d == 0.0) {                         /* flush request? */
180	>	if (something2flush) {
181	>	if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
182	>	error(USER, "child(ren) died");
183		bogusray();
184		fflush(stdout);
185	<	nextflush = (vresolu > 0) & (hresolu > 1) ? 0 :
186	<	hresolu;
185	>	nextflush = (!vresolu | (hresolu <= 1)) * hresolu;
186	>	something2flush = 0;
187		} else
188		bogusray();
189		} else {                                /* compute and print */
190		rtcompute(orig, direc, lim_dist ? d : 0.0);
191	<	/* flush if time */
192	<	if (!--nextflush) {
193	<	if (nproc > 1 && ray_fifo_flush() < 0)
177	<	error(USER, "lost children");
191	>	if (!--nextflush) {             /* flush if time */
192	>	if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
193	>	error(USER, "child(ren) died");
194		fflush(stdout);
195		nextflush = hresolu;
196	<	}
196	>	} else
197	>	something2flush = 1;
198		}
199		if (ferror(stdout))
200		error(SYSTEM, "write error");
201		if (vcount && !--vcount)                /* check for end */
202		break;
203		}
204	<	if (nproc > 1) {                                /* clean up children */
204	>	if (ray_pnprocs > 1) {                          /* clean up children */
205		if (ray_fifo_flush() < 0)
206		error(USER, "unable to complete processing");
207		ray_pclose(0);
208		}
209	+	if (vcount)
210	+	error(WARNING, "unexpected EOF on input");
211		if (fflush(stdout) < 0)
212		error(SYSTEM, "write error");
213	<	if (vcount)
214	<	error(USER, "unexpected EOF on input");
215	<	if (fname != NULL)
216	<	fclose(fp);
213	>	if (fname != NULL) {
214	>	fclose(inpfp);
215	>	inpfp = NULL;
216	>	}
217	>	nextray(NULL, NULL);
218		}
219
220
#	Line 235 | Line 255 | setoutput(                             /* set up output tables */
255		case 'd':                               /* direction */
256		*table++ = oputd;
257		break;
258	+	case 'r':                               /* reflected contrib. */
259	+	*table++ = oputr;
260	+	castonly = 0;
261	+	break;
262	+	case 'R':                               /* reflected distance */
263	+	*table++ = oputR;
264	+	castonly = 0;
265	+	break;
266	+	case 'x':                               /* xmit contrib. */
267	+	*table++ = oputx;
268	+	castonly = 0;
269	+	break;
270	+	case 'X':                               /* xmit distance */
271	+	*table++ = oputX;
272	+	castonly = 0;
273	+	break;
274		case 'v':                               /* value */
275		*table++ = oputv;
276		castonly = 0;
#	Line 273 | Line 309 | setoutput(                             /* set up output tables */
309		break;
310		case 'W':                               /* coefficient */
311		*table++ = oputW;
312	<	if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0))
312	>	castonly = 0;
313	>	if (ambounce > 0 && (ambacc > FTINY) | (ambssamp > 0))
314		error(WARNING,
315		"-otW accuracy depends on -aa 0 -as 0");
316		break;
#	Line 288 | Line 325 | setoutput(                             /* set up output tables */
325		break;
326		}
327		*table = NULL;
328	+	/* compatibility */
329	+	for (table = ray_out; *table != NULL; table++) {
330	+	if ((*table == oputV) | (*table == oputW))
331	+	error(WARNING, "-oVW options require trace mode");
332	+	if ((do_irrad | imm_irrad) &&
333	+	(*table == oputr) | (*table == oputR) |
334	+	(*table == oputx) | (*table == oputX))
335	+	error(WARNING, "-orRxX options incompatible with -I+ and -i+");
336	+	}
337		}
338
339
340		static void
341		bogusray(void)                  /* print out empty record */
342		{
297	–	thisray.rorg[0] = thisray.rorg[1] = thisray.rorg[2] =
298	–	thisray.rdir[0] = thisray.rdir[1] = thisray.rdir[2] = 0.0;
299	–	thisray.rmax = 0.0;
343		rayorigin(&thisray, PRIMARY, NULL, NULL);
344		printvals(&thisray);
345		}
#	Line 323 | Line 366 | rayirrad(                      /* compute irradiance rather than radiance
366		)
367		{
368		void    (*old_revf)(RAY *) = r->revf;
369	<
370	<	r->rot = 1e-5;                  /* pretend we hit surface */
369	>	/* pretend we hit surface */
370	>	r->rxt = r->rot = 1e-5;
371		VSUM(r->rop, r->rorg, r->rdir, r->rot);
372		r->ron[0] = -r->rdir[0];
373		r->ron[1] = -r->rdir[1];
#	Line 389 | Line 432 | printvals(                     /* print requested ray values */
432
433
434		static int
435	<	getvec(         /* get a vector from fp */
435	>	getvec(                 /* get a vector from fp */
436		FVECT  vec,
437		int  fmt,
438		FILE  *fp
#	Line 410 | Line 453 | getvec(                /* get a vector from fp */
453		}
454		break;
455		case 'f':                                       /* binary float */
456	<	if (fread((char *)vf, sizeof(float), 3, fp) != 3)
456	>	if (getbinary(vf, sizeof(float), 3, fp) != 3)
457		return(-1);
458		VCOPY(vec, vf);
459		break;
460		case 'd':                                       /* binary double */
461	<	if (fread((char *)vd, sizeof(double), 3, fp) != 3)
461	>	if (getbinary(vd, sizeof(double), 3, fp) != 3)
462		return(-1);
463		VCOPY(vec, vd);
464		break;
#	Line 426 | Line 469 | getvec(                /* get a vector from fp */
469		}
470
471
472	+	static int
473	+	iszerovec(const FVECT vec)
474	+	{
475	+	return (vec[0] == 0.0) & (vec[1] == 0.0) & (vec[2] == 0.0);
476	+	}
477	+
478	+
479	+	static double
480	+	nextray(                /* return next ray in work group (-1.0 if EOF) */
481	+	FVECT org,
482	+	FVECT dir
483	+	)
484	+	{
485	+	const size_t    qlength = !vresolu * hresolu;
486	+
487	+	if ((org == NULL) | (dir == NULL)) {
488	+	if (inp_queue != NULL)  /* asking to free queue */
489	+	free(inp_queue);
490	+	inp_queue = NULL;
491	+	inp_qpos = inp_qend = 0;
492	+	return(-1.);
493	+	}
494	+	if (!inp_qend) {                /* initialize FIFO queue */
495	+	int     rsiz = 6*20;    /* conservative ascii ray size */
496	+	if (inform == 'f') rsiz = 6*sizeof(float);
497	+	else if (inform == 'd') rsiz = 6*sizeof(double);
498	+	if ((inpfp == stdin) & (qlength*rsiz > 512))    /* pipe limit */
499	+	inp_queue = (FVECT *)malloc(sizeof(FVECT)*2*qlength);
500	+	inp_qend = -(inp_queue == NULL);        /* flag for no queue */
501	+	}
502	+	if (inp_qend < 0) {             /* not queuing? */
503	+	if (getvec(org, inform, inpfp) < 0 ||
504	+	getvec(dir, inform, inpfp) < 0)
505	+	return(-1.);
506	+	return normalize(dir);
507	+	}
508	+	if (inp_qpos >= inp_qend) {     /* need to refill input queue? */
509	+	for (inp_qend = 0; inp_qend < qlength; inp_qend++) {
510	+	if (getvec(inp_queue[2*inp_qend], inform, inpfp) < 0
511	+	|| getvec(inp_queue[2*inp_qend+1],
512	+	inform, inpfp) < 0)
513	+	break;          /* hit EOF */
514	+	if (iszerovec(inp_queue[2*inp_qend+1])) {
515	+	++inp_qend;     /* flush request */
516	+	break;
517	+	}
518	+	}
519	+	inp_qpos = 0;
520	+	}
521	+	if (inp_qpos >= inp_qend)       /* unexpected EOF? */
522	+	return(-1.);
523	+	VCOPY(org, inp_queue[2*inp_qpos]);
524	+	VCOPY(dir, inp_queue[2*inp_qpos+1]);
525	+	++inp_qpos;
526	+	return normalize(dir);
527	+	}
528	+
529	+
530		void
531		tranotify(                      /* record new modifier */
532		OBJECT  obj
#	Line 508 | Line 609 | oputd(                         /* print direction */
609
610
611		static void
612	+	oputr(                          /* print mirrored contribution */
613	+	RAY  *r
614	+	)
615	+	{
616	+	RREAL   cval[3];
617	+
618	+	cval[0] = colval(r->mcol,RED);
619	+	cval[1] = colval(r->mcol,GRN);
620	+	cval[2] = colval(r->mcol,BLU);
621	+	(*putreal)(cval, 3);
622	+	}
623	+
624	+
625	+
626	+	static void
627	+	oputR(                          /* print mirrored distance */
628	+	RAY  *r
629	+	)
630	+	{
631	+	(*putreal)(&r->rmt, 1);
632	+	}
633	+
634	+
635	+	static void
636	+	oputx(                          /* print unmirrored contribution */
637	+	RAY  *r
638	+	)
639	+	{
640	+	RREAL   cval[3];
641	+
642	+	cval[0] = colval(r->rcol,RED) - colval(r->mcol,RED);
643	+	cval[1] = colval(r->rcol,GRN) - colval(r->mcol,GRN);
644	+	cval[2] = colval(r->rcol,BLU) - colval(r->mcol,BLU);
645	+	(*putreal)(cval, 3);
646	+	}
647	+
648	+
649	+	static void
650	+	oputX(                          /* print unmirrored distance */
651	+	RAY  *r
652	+	)
653	+	{
654	+	(*putreal)(&r->rxt, 1);
655	+	}
656	+
657	+
658	+	static void
659		oputv(                          /* print value */
660		RAY  *r
661		)
662		{
663		RREAL   cval[3];
664
517	–	if (outform == 'c') {
518	–	COLR  cout;
519	–	setcolr(cout,   colval(r->rcol,RED),
520	–	colval(r->rcol,GRN),
521	–	colval(r->rcol,BLU));
522	–	fwrite(cout, sizeof(cout), 1, stdout);
523	–	return;
524	–	}
665		cval[0] = colval(r->rcol,RED);
666		cval[1] = colval(r->rcol,GRN);
667		cval[2] = colval(r->rcol,BLU);
#	Line 547 | Line 687 | oputl(                         /* print effective distance */
687		RAY  *r
688		)
689		{
690	<	(*putreal)(&r->rt, 1);
690	>	RREAL   d = raydistance(r);
691	>
692	>	(*putreal)(&d, 1);
693		}
694
695
#	Line 577 | Line 719 | oputp(                         /* print point */
719		RAY  *r
720		)
721		{
722	<	if (r->rot < FHUGE)
722	>	if (r->rot < FHUGE*.99)
723		(*putreal)(r->rop, 3);
724		else
725		(*putreal)(vdummy, 3);
#	Line 589 | Line 731 | oputN(                         /* print unperturbed normal */
731		RAY  *r
732		)
733		{
734	<	if (r->rot < FHUGE)
735	<	(*putreal)(r->ron, 3);
736	<	else
734	>	if (r->rot < FHUGE*.99) {
735	>	if (r->rflips & 1) {    /* undo any flippin' flips */
736	>	FVECT   unrm;
737	>	unrm[0] = -r->ron[0];
738	>	unrm[1] = -r->ron[1];
739	>	unrm[2] = -r->ron[2];
740	>	(*putreal)(unrm, 3);
741	>	} else
742	>	(*putreal)(r->ron, 3);
743	>	} else
744		(*putreal)(vdummy, 3);
745		}
746
#	Line 603 | Line 752 | oputn(                         /* print perturbed normal */
752		{
753		FVECT  pnorm;
754
755	<	if (r->rot >= FHUGE) {
755	>	if (r->rot >= FHUGE*.99) {
756		(*putreal)(vdummy, 3);
757		return;
758		}
#	Line 710 | Line 859 | puta(                          /* print ascii value(s) */
859
860
861		static void
862	<	putd(RREAL *v, int n)           /* print binary double(s) */
862	>	putd(RREAL *v, int n)           /* output binary double(s) */
863		{
864	<	if (sizeof(RREAL) != sizeof(double))
864	>	#ifdef  SMLFLT
865	>	double  da[3];
866	>	int     i;
867	>
868	>	if (n > 3)
869		error(INTERNAL, "code error in putd()");
870	<	fwrite(v, sizeof(RREAL), n, stdout);
870	>	for (i = n; i--; )
871	>	da[i] = v[i];
872	>	putbinary(da, sizeof(double), n, stdout);
873	>	#else
874	>	putbinary(v, sizeof(RREAL), n, stdout);
875	>	#endif
876		}
877
878
879		static void
880	<	putf(RREAL *v, int n)           /* print binary float(s) */
880	>	putf(RREAL *v, int n)           /* output binary float(s) */
881		{
882	+	#ifndef SMLFLT
883		float   fa[3];
884		int     i;
885
#	Line 728 | Line 887 | putf(RREAL *v, int n)          /* print binary float(s) */
887		error(INTERNAL, "code error in putf()");
888		for (i = n; i--; )
889		fa[i] = v[i];
890	<	fwrite(fa, sizeof(float), n, stdout);
890	>	putbinary(fa, sizeof(float), n, stdout);
891	>	#else
892	>	putbinary(v, sizeof(RREAL), n, stdout);
893	>	#endif
894	>	}
895	>
896	>
897	>	static void
898	>	putrgbe(RREAL *v, int n)        /* output RGBE color */
899	>	{
900	>	COLR  cout;
901	>
902	>	if (n != 3)
903	>	error(INTERNAL, "putrgbe() not called with 3 components");
904	>	setcolr(cout, v[0], v[1], v[2]);
905	>	putbinary(cout, sizeof(cout), 1, stdout);
906		}

Diff Legend

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