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.91 by greg, Sun Apr 5 15:47:02 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 */
132	–	setoutput(outvals);
147		if (imm_irrad)
148		castonly = 0;
149	<	else if (castonly)
149	>	else if (castonly || every_out[0] != NULL)
150		nproc = 1;              /* don't bother multiprocessing */
151	+	if ((nextflush > 0) & (nproc > nextflush)) {
152	+	error(WARNING, "reducing number of processes to match flush interval");
153	+	nproc = nextflush;
154	+	}
155		switch (outform) {
156		case 'a': putreal = puta; break;
157		case 'f': putreal = putf; break;
158		case 'd': putreal = putd; break;
159		case 'c':
160	<	if (strcmp(outvals, "v"))
161	<	error(USER, "color format with value output only");
162	<	break;
160	>	if (outvals[1] || !strchr("vrx", outvals[0]))
161	>	error(USER, "color format only with -ov, -or, -ox");
162	>	putreal = putrgbe; break;
163		default:
164		error(CONSISTENCY, "botched output format");
165		}
#	Line 152 | Line 170 | rtrace(                                /* trace rays from file */
170		if (hresolu > 0) {
171		if (vresolu > 0)
172		fprtresolu(hresolu, vresolu, stdout);
173	<	fflush(stdout);
173	>	else
174	>	fflush(stdout);
175		}
176	<	/* process file */
177	<	while (getvec(orig, inform, fp) == 0 &&
178	<	getvec(direc, inform, fp) == 0) {
179	<
180	<	d = normalize(direc);
181	<	if (d == 0.0) {                         /* zero ==> flush */
163	<	if (--nextflush <= 0 || !vcount) {
164	<	if (nproc > 1 && ray_fifo_flush() < 0)
165	<	error(USER, "lost children");
176	>	/* process input rays */
177	>	while ((d = nextray(orig, direc)) >= 0.0) {
178	>	if (d == 0.0) {                         /* flush request? */
179	>	if (something2flush) {
180	>	if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
181	>	error(USER, "child(ren) died");
182		bogusray();
183		fflush(stdout);
184	<	nextflush = (vresolu > 0) & (hresolu > 1) ? 0 :
185	<	hresolu;
184	>	nextflush = (!vresolu | (hresolu <= 1)) * hresolu;
185	>	something2flush = 0;
186		} else
187		bogusray();
188		} else {                                /* compute and print */
189		rtcompute(orig, direc, lim_dist ? d : 0.0);
190	<	/* flush if time */
191	<	if (!--nextflush) {
192	<	if (nproc > 1 && ray_fifo_flush() < 0)
177	<	error(USER, "lost children");
190	>	if (!--nextflush) {             /* flush if time */
191	>	if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
192	>	error(USER, "child(ren) died");
193		fflush(stdout);
194		nextflush = hresolu;
195	<	}
195	>	} else
196	>	something2flush = 1;
197		}
198		if (ferror(stdout))
199		error(SYSTEM, "write error");
200		if (vcount && !--vcount)                /* check for end */
201		break;
202		}
203	<	if (nproc > 1) {                                /* clean up children */
203	>	if (ray_pnprocs > 1) {                          /* clean up children */
204		if (ray_fifo_flush() < 0)
205		error(USER, "unable to complete processing");
206		ray_pclose(0);
207		}
208	+	if (vcount)
209	+	error(WARNING, "unexpected EOF on input");
210		if (fflush(stdout) < 0)
211		error(SYSTEM, "write error");
212	<	if (vcount)
213	<	error(USER, "unexpected EOF on input");
214	<	if (fname != NULL)
215	<	fclose(fp);
212	>	if (fname != NULL) {
213	>	fclose(inpfp);
214	>	inpfp = NULL;
215	>	}
216	>	nextray(NULL, NULL);
217		}
218
219
#	Line 208 | Line 227 | trace_sources(void)                    /* trace rays to light sources,
227		}
228
229
230	<	static void
231	<	setoutput(                              /* set up output tables */
213	<	char  *vs
214	<	)
230	>	int
231	>	setrtoutput(void)                       /* set up output tables, return #comp */
232		{
233	+	char  *vs = outvals;
234		oputf_t **table = ray_out;
235	+	int  ncomp = 0;
236
237	+	if (!*vs)
238	+	error(USER, "empty output specification");
239	+
240		castonly = 1;
241	<	while (*vs)
242	<	switch (*vs++) {
241	>	do
242	>	switch (*vs) {
243		case 'T':                               /* trace sources */
244	<	if (!*vs) break;
244	>	if (!vs[1]) break;
245		trace_sources();
246		/* fall through */
247		case 't':                               /* trace */
248	<	if (!*vs) break;
248	>	if (!vs[1]) break;
249		*table = NULL;
250		table = every_out;
251		trace = ourtrace;
#	Line 231 | Line 253 | setoutput(                             /* set up output tables */
253		break;
254		case 'o':                               /* origin */
255		*table++ = oputo;
256	+	ncomp += 3;
257		break;
258		case 'd':                               /* direction */
259		*table++ = oputd;
260	+	ncomp += 3;
261		break;
262	+	case 'r':                               /* reflected contrib. */
263	+	*table++ = oputr;
264	+	ncomp += 3;
265	+	castonly = 0;
266	+	break;
267	+	case 'R':                               /* reflected distance */
268	+	*table++ = oputR;
269	+	ncomp++;
270	+	castonly = 0;
271	+	break;
272	+	case 'x':                               /* xmit contrib. */
273	+	*table++ = oputx;
274	+	ncomp += 3;
275	+	castonly = 0;
276	+	break;
277	+	case 'X':                               /* xmit distance */
278	+	*table++ = oputX;
279	+	ncomp++;
280	+	castonly = 0;
281	+	break;
282		case 'v':                               /* value */
283		*table++ = oputv;
284	+	ncomp += 3;
285		castonly = 0;
286		break;
287		case 'V':                               /* contribution */
288		*table++ = oputV;
289	+	ncomp += 3;
290		if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0))
291		error(WARNING,
292		"-otV accuracy depends on -aa 0 -as 0");
293		break;
294		case 'l':                               /* effective distance */
295		*table++ = oputl;
296	+	ncomp++;
297		castonly = 0;
298		break;
299		case 'c':                               /* local coordinates */
300		*table++ = oputc;
301	+	ncomp += 2;
302		break;
303		case 'L':                               /* single ray length */
304		*table++ = oputL;
305	+	ncomp++;
306		break;
307		case 'p':                               /* point */
308		*table++ = oputp;
309	+	ncomp += 3;
310		break;
311		case 'n':                               /* perturbed normal */
312		*table++ = oputn;
313	+	ncomp += 3;
314		castonly = 0;
315		break;
316		case 'N':                               /* unperturbed normal */
317		*table++ = oputN;
318	+	ncomp += 3;
319		break;
320		case 's':                               /* surface */
321		*table++ = oputs;
322	+	ncomp++;
323		break;
324		case 'w':                               /* weight */
325		*table++ = oputw;
326	+	ncomp++;
327		break;
328		case 'W':                               /* coefficient */
329		*table++ = oputW;
330	<	if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0))
330	>	ncomp += 3;
331	>	castonly = 0;
332	>	if (ambounce > 0 && (ambacc > FTINY) | (ambssamp > 0))
333		error(WARNING,
334		"-otW accuracy depends on -aa 0 -as 0");
335		break;
336		case 'm':                               /* modifier */
337		*table++ = oputm;
338	+	ncomp++;
339		break;
340		case 'M':                               /* material */
341		*table++ = oputM;
342	+	ncomp++;
343		break;
344		case '~':                               /* tilde */
345		*table++ = oputtilde;
346		break;
347	+	default:
348	+	sprintf(errmsg, "unrecognized output option '%c'", *vs);
349	+	error(USER, errmsg);
350		}
351	+	while (*++vs);
352	+
353		*table = NULL;
354	+	if (*every_out != NULL)
355	+	ncomp = 0;
356	+	/* compatibility */
357	+	for (table = ray_out; *table != NULL; table++) {
358	+	if ((*table == oputV) | (*table == oputW))
359	+	error(WARNING, "-oVW options require trace mode");
360	+	if ((do_irrad | imm_irrad) &&
361	+	(*table == oputr) | (*table == oputR) |
362	+	(*table == oputx) | (*table == oputX))
363	+	error(WARNING, "-orRxX options incompatible with -I+ and -i+");
364	+	}
365	+	return(ncomp);
366		}
367
368
369		static void
370		bogusray(void)                  /* print out empty record */
371		{
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;
372		rayorigin(&thisray, PRIMARY, NULL, NULL);
373		printvals(&thisray);
374		}
#	Line 323 | Line 395 | rayirrad(                      /* compute irradiance rather than radiance
395		)
396		{
397		void    (*old_revf)(RAY *) = r->revf;
398	<
399	<	r->rot = 1e-5;                  /* pretend we hit surface */
398	>	/* pretend we hit surface */
399	>	r->rxt = r->rot = 1e-5;
400		VSUM(r->rop, r->rorg, r->rdir, r->rot);
401		r->ron[0] = -r->rdir[0];
402		r->ron[1] = -r->rdir[1];
#	Line 389 | Line 461 | printvals(                     /* print requested ray values */
461
462
463		static int
464	<	getvec(         /* get a vector from fp */
464	>	getvec(                 /* get a vector from fp */
465		FVECT  vec,
466		int  fmt,
467		FILE  *fp
#	Line 410 | Line 482 | getvec(                /* get a vector from fp */
482		}
483		break;
484		case 'f':                                       /* binary float */
485	<	if (fread((char *)vf, sizeof(float), 3, fp) != 3)
485	>	if (getbinary(vf, sizeof(float), 3, fp) != 3)
486		return(-1);
487		VCOPY(vec, vf);
488		break;
489		case 'd':                                       /* binary double */
490	<	if (fread((char *)vd, sizeof(double), 3, fp) != 3)
490	>	if (getbinary(vd, sizeof(double), 3, fp) != 3)
491		return(-1);
492		VCOPY(vec, vd);
493		break;
#	Line 426 | Line 498 | getvec(                /* get a vector from fp */
498		}
499
500
501	+	static int
502	+	iszerovec(const FVECT vec)
503	+	{
504	+	return (vec[0] == 0.0) & (vec[1] == 0.0) & (vec[2] == 0.0);
505	+	}
506	+
507	+
508	+	static double
509	+	nextray(                /* return next ray in work group (-1.0 if EOF) */
510	+	FVECT org,
511	+	FVECT dir
512	+	)
513	+	{
514	+	const size_t    qlength = !vresolu * hresolu;
515	+
516	+	if ((org == NULL) | (dir == NULL)) {
517	+	if (inp_queue != NULL)  /* asking to free queue */
518	+	free(inp_queue);
519	+	inp_queue = NULL;
520	+	inp_qpos = inp_qend = 0;
521	+	return(-1.);
522	+	}
523	+	if (!inp_qend) {                /* initialize FIFO queue */
524	+	int     rsiz = 6*20;    /* conservative ascii ray size */
525	+	if (inform == 'f') rsiz = 6*sizeof(float);
526	+	else if (inform == 'd') rsiz = 6*sizeof(double);
527	+	if ((inpfp == stdin) & (qlength*rsiz > 512))    /* pipe limit */
528	+	inp_queue = (FVECT *)malloc(sizeof(FVECT)*2*qlength);
529	+	inp_qend = -(inp_queue == NULL);        /* flag for no queue */
530	+	}
531	+	if (inp_qend < 0) {             /* not queuing? */
532	+	if (getvec(org, inform, inpfp) < 0 ||
533	+	getvec(dir, inform, inpfp) < 0)
534	+	return(-1.);
535	+	return normalize(dir);
536	+	}
537	+	if (inp_qpos >= inp_qend) {     /* need to refill input queue? */
538	+	for (inp_qend = 0; inp_qend < qlength; inp_qend++) {
539	+	if (getvec(inp_queue[2*inp_qend], inform, inpfp) < 0
540	+	|| getvec(inp_queue[2*inp_qend+1],
541	+	inform, inpfp) < 0)
542	+	break;          /* hit EOF */
543	+	if (iszerovec(inp_queue[2*inp_qend+1])) {
544	+	++inp_qend;     /* flush request */
545	+	break;
546	+	}
547	+	}
548	+	inp_qpos = 0;
549	+	}
550	+	if (inp_qpos >= inp_qend)       /* unexpected EOF? */
551	+	return(-1.);
552	+	VCOPY(org, inp_queue[2*inp_qpos]);
553	+	VCOPY(dir, inp_queue[2*inp_qpos+1]);
554	+	++inp_qpos;
555	+	return normalize(dir);
556	+	}
557	+
558	+
559		void
560		tranotify(                      /* record new modifier */
561		OBJECT  obj
#	Line 508 | Line 638 | oputd(                         /* print direction */
638
639
640		static void
641	+	oputr(                          /* print mirrored contribution */
642	+	RAY  *r
643	+	)
644	+	{
645	+	RREAL   cval[3];
646	+
647	+	cval[0] = colval(r->mcol,RED);
648	+	cval[1] = colval(r->mcol,GRN);
649	+	cval[2] = colval(r->mcol,BLU);
650	+	(*putreal)(cval, 3);
651	+	}
652	+
653	+
654	+
655	+	static void
656	+	oputR(                          /* print mirrored distance */
657	+	RAY  *r
658	+	)
659	+	{
660	+	(*putreal)(&r->rmt, 1);
661	+	}
662	+
663	+
664	+	static void
665	+	oputx(                          /* print unmirrored contribution */
666	+	RAY  *r
667	+	)
668	+	{
669	+	RREAL   cval[3];
670	+
671	+	cval[0] = colval(r->rcol,RED) - colval(r->mcol,RED);
672	+	cval[1] = colval(r->rcol,GRN) - colval(r->mcol,GRN);
673	+	cval[2] = colval(r->rcol,BLU) - colval(r->mcol,BLU);
674	+	(*putreal)(cval, 3);
675	+	}
676	+
677	+
678	+	static void
679	+	oputX(                          /* print unmirrored distance */
680	+	RAY  *r
681	+	)
682	+	{
683	+	(*putreal)(&r->rxt, 1);
684	+	}
685	+
686	+
687	+	static void
688		oputv(                          /* print value */
689		RAY  *r
690		)
691		{
692		RREAL   cval[3];
693
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	–	}
694		cval[0] = colval(r->rcol,RED);
695		cval[1] = colval(r->rcol,GRN);
696		cval[2] = colval(r->rcol,BLU);
#	Line 547 | Line 716 | oputl(                         /* print effective distance */
716		RAY  *r
717		)
718		{
719	<	(*putreal)(&r->rt, 1);
719	>	RREAL   d = raydistance(r);
720	>
721	>	(*putreal)(&d, 1);
722		}
723
724
#	Line 577 | Line 748 | oputp(                         /* print point */
748		RAY  *r
749		)
750		{
751	<	if (r->rot < FHUGE)
751	>	if (r->rot < FHUGE*.99)
752		(*putreal)(r->rop, 3);
753		else
754		(*putreal)(vdummy, 3);
#	Line 589 | Line 760 | oputN(                         /* print unperturbed normal */
760		RAY  *r
761		)
762		{
763	<	if (r->rot < FHUGE)
764	<	(*putreal)(r->ron, 3);
765	<	else
763	>	if (r->rot < FHUGE*.99) {
764	>	if (r->rflips & 1) {    /* undo any flippin' flips */
765	>	FVECT   unrm;
766	>	unrm[0] = -r->ron[0];
767	>	unrm[1] = -r->ron[1];
768	>	unrm[2] = -r->ron[2];
769	>	(*putreal)(unrm, 3);
770	>	} else
771	>	(*putreal)(r->ron, 3);
772	>	} else
773		(*putreal)(vdummy, 3);
774		}
775
#	Line 603 | Line 781 | oputn(                         /* print perturbed normal */
781		{
782		FVECT  pnorm;
783
784	<	if (r->rot >= FHUGE) {
784	>	if (r->rot >= FHUGE*.99) {
785		(*putreal)(vdummy, 3);
786		return;
787		}
#	Line 710 | Line 888 | puta(                          /* print ascii value(s) */
888
889
890		static void
891	<	putd(RREAL *v, int n)           /* print binary double(s) */
891	>	putd(RREAL *v, int n)           /* output binary double(s) */
892		{
893	<	if (sizeof(RREAL) != sizeof(double))
893	>	#ifdef  SMLFLT
894	>	double  da[3];
895	>	int     i;
896	>
897	>	if (n > 3)
898		error(INTERNAL, "code error in putd()");
899	<	fwrite(v, sizeof(RREAL), n, stdout);
899	>	for (i = n; i--; )
900	>	da[i] = v[i];
901	>	putbinary(da, sizeof(double), n, stdout);
902	>	#else
903	>	putbinary(v, sizeof(RREAL), n, stdout);
904	>	#endif
905		}
906
907
908		static void
909	<	putf(RREAL *v, int n)           /* print binary float(s) */
909	>	putf(RREAL *v, int n)           /* output binary float(s) */
910		{
911	+	#ifndef SMLFLT
912		float   fa[3];
913		int     i;
914
#	Line 728 | Line 916 | putf(RREAL *v, int n)          /* print binary float(s) */
916		error(INTERNAL, "code error in putf()");
917		for (i = n; i--; )
918		fa[i] = v[i];
919	<	fwrite(fa, sizeof(float), n, stdout);
919	>	putbinary(fa, sizeof(float), n, stdout);
920	>	#else
921	>	putbinary(v, sizeof(RREAL), n, stdout);
922	>	#endif
923	>	}
924	>
925	>
926	>	static void
927	>	putrgbe(RREAL *v, int n)        /* output RGBE color */
928	>	{
929	>	COLR  cout;
930	>
931	>	if (n != 3)
932	>	error(INTERNAL, "putrgbe() not called with 3 components");
933	>	setcolr(cout, v[0], v[1], v[2]);
934	>	putbinary(cout, sizeof(cout), 1, stdout);
935		}

Diff Legend

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