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.73 by greg, Tue Nov 13 19:58:33 2018 UTC vs.
Revision 2.98 by greg, Tue Jun 16 17:58:11 2020 UTC

#	Line 45 | Line 45 | extern int  traincl;                   /* include == 1, exclude == 0 *
45		extern int  hresolu;                    /* horizontal resolution */
46		extern int  vresolu;                    /* vertical resolution */
47
48	<	static int  castonly = 0;
48	>	int  castonly = 0;                      /* only doing ray-casting? */
49
50		#ifndef  MAXTSET
51		#define  MAXTSET        8191            /* maximum number in trace set */
#	Line 54 | 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		oputr, oputR, oputx, oputX, oputn, oputN, oputs,
69		oputw, oputW, oputm, oputM, oputtilde;
70
65	–	static void setoutput(char *vs);
71		extern void tranotify(OBJECT obj);
72	+	static int is_fifo(FILE *fp);
73		static void bogusray(void);
74		static void raycast(RAY *r);
75		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
#	Line 109 | Line 117 | formstr(                               /* return format identifier */
117		}
118
119
120	<	extern void
120	>	void
121		rtrace(                         /* trace rays from file */
122		char  *fname,
123		int  nproc
#	Line 117 | 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);
135	<	if (imm_irrad)
136	<	castonly = 0;
137	<	else if (castonly)
147	>	if (castonly || every_out[0] != NULL)
148		nproc = 1;              /* don't bother multiprocessing */
149	+	if ((nextflush > 0) & (nproc > nextflush)) {
150	+	error(WARNING, "reducing number of processes to match flush interval");
151	+	nproc = nextflush;
152	+	}
153		switch (outform) {
154		case 'a': putreal = puta; break;
155		case 'f': putreal = putf; break;
156		case 'd': putreal = putd; break;
157		case 'c':
158	<	if (strcmp(outvals, "v"))
159	<	error(USER, "color format with value output only");
160	<	break;
158	>	if (outvals[1] || !strchr("vrx", outvals[0]))
159	>	error(USER, "color format only with -ov, -or, -ox");
160	>	putreal = putrgbe; break;
161		default:
162		error(CONSISTENCY, "botched output format");
163		}
#	Line 154 | Line 168 | rtrace(                                /* trace rays from file */
168		if (hresolu > 0) {
169		if (vresolu > 0)
170		fprtresolu(hresolu, vresolu, stdout);
171	<	fflush(stdout);
171	>	else
172	>	fflush(stdout);
173		}
174	<	/* process file */
175	<	while (getvec(orig, inform, fp) == 0 &&
176	<	getvec(direc, inform, fp) == 0) {
177	<
178	<	d = normalize(direc);
164	<	if (d == 0.0) {                         /* zero ==> flush */
165	<	if (--nextflush <= 0 || !vcount) {
166	<	if (nproc > 1 && ray_fifo_flush() < 0)
174	>	/* process input rays */
175	>	while ((d = nextray(orig, direc)) >= 0.0) {
176	>	if (d == 0.0) {                         /* flush request? */
177	>	if (something2flush) {
178	>	if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
179		error(USER, "child(ren) died");
180		bogusray();
181		fflush(stdout);
182	<	nextflush = (vresolu > 0) & (hresolu > 1) ? 0 :
183	<	hresolu;
182	>	nextflush = (!vresolu | (hresolu <= 1)) * hresolu;
183	>	something2flush = 0;
184		} else
185		bogusray();
186		} else {                                /* compute and print */
187		rtcompute(orig, direc, lim_dist ? d : 0.0);
188	<	/* flush if time */
189	<	if (!--nextflush) {
178	<	if (nproc > 1 && ray_fifo_flush() < 0)
188	>	if (!--nextflush) {             /* flush if time */
189	>	if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
190		error(USER, "child(ren) died");
191		fflush(stdout);
192		nextflush = hresolu;
193	<	}
193	>	} else
194	>	something2flush = 1;
195		}
196		if (ferror(stdout))
197		error(SYSTEM, "write error");
198		if (vcount && !--vcount)                /* check for end */
199		break;
200		}
201	<	if (nproc > 1) {                                /* clean up children */
201	>	if (ray_pnprocs > 1) {                          /* clean up children */
202		if (ray_fifo_flush() < 0)
203		error(USER, "unable to complete processing");
204		ray_pclose(0);
205		}
206	+	if (vcount)
207	+	error(WARNING, "unexpected EOF on input");
208		if (fflush(stdout) < 0)
209		error(SYSTEM, "write error");
210	<	if (vcount)
211	<	error(USER, "unexpected EOF on input");
212	<	if (fname != NULL)
213	<	fclose(fp);
210	>	if (fname != NULL) {
211	>	fclose(inpfp);
212	>	inpfp = NULL;
213	>	}
214	>	nextray(NULL, NULL);
215		}
216
217
#	Line 210 | Line 225 | trace_sources(void)                    /* trace rays to light sources,
225		}
226
227
228	<	static void
229	<	setoutput(                              /* set up output tables */
215	<	char  *vs
216	<	)
228	>	int
229	>	setrtoutput(void)                       /* set up output tables, return #comp */
230		{
231	+	char  *vs = outvals;
232		oputf_t **table = ray_out;
233	+	int  ncomp = 0;
234
235	<	castonly = 1;
236	<	while (*vs)
237	<	switch (*vs++) {
235	>	if (!*vs)
236	>	error(USER, "empty output specification");
237	>
238	>	castonly = 1;                   /* sets castonly as side-effect */
239	>	do
240	>	switch (*vs) {
241		case 'T':                               /* trace sources */
242	<	if (!*vs) break;
242	>	if (!vs[1]) break;
243		trace_sources();
244		/* fall through */
245		case 't':                               /* trace */
246	<	if (!*vs) break;
246	>	if (!vs[1]) break;
247		*table = NULL;
248		table = every_out;
249		trace = ourtrace;
#	Line 233 | Line 251 | setoutput(                             /* set up output tables */
251		break;
252		case 'o':                               /* origin */
253		*table++ = oputo;
254	+	ncomp += 3;
255		break;
256		case 'd':                               /* direction */
257		*table++ = oputd;
258	+	ncomp += 3;
259		break;
260		case 'r':                               /* reflected contrib. */
261		*table++ = oputr;
262	+	ncomp += 3;
263		castonly = 0;
264		break;
265		case 'R':                               /* reflected distance */
266		*table++ = oputR;
267	+	ncomp++;
268		castonly = 0;
269		break;
270		case 'x':                               /* xmit contrib. */
271		*table++ = oputx;
272	+	ncomp += 3;
273		castonly = 0;
274		break;
275		case 'X':                               /* xmit distance */
276		*table++ = oputX;
277	+	ncomp++;
278		castonly = 0;
279		break;
280		case 'v':                               /* value */
281		*table++ = oputv;
282	+	ncomp += 3;
283		castonly = 0;
284		break;
285		case 'V':                               /* contribution */
286		*table++ = oputV;
287	+	ncomp += 3;
288		castonly = 0;
289		if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0))
290		error(WARNING,
#	Line 266 | Line 292 | setoutput(                             /* set up output tables */
292		break;
293		case 'l':                               /* effective distance */
294		*table++ = oputl;
295	+	ncomp++;
296		castonly = 0;
297		break;
298		case 'c':                               /* local coordinates */
299		*table++ = oputc;
300	+	ncomp += 2;
301		break;
302		case 'L':                               /* single ray length */
303		*table++ = oputL;
304	+	ncomp++;
305		break;
306		case 'p':                               /* point */
307		*table++ = oputp;
308	+	ncomp += 3;
309		break;
310		case 'n':                               /* perturbed normal */
311		*table++ = oputn;
312	+	ncomp += 3;
313		castonly = 0;
314		break;
315		case 'N':                               /* unperturbed normal */
316		*table++ = oputN;
317	+	ncomp += 3;
318		break;
319		case 's':                               /* surface */
320		*table++ = oputs;
321	+	ncomp++;
322		break;
323		case 'w':                               /* weight */
324		*table++ = oputw;
325	+	ncomp++;
326		break;
327		case 'W':                               /* coefficient */
328		*table++ = oputW;
329	+	ncomp += 3;
330		castonly = 0;
331	<	if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0))
331	>	if (ambounce > 0 && (ambacc > FTINY) | (ambssamp > 0))
332		error(WARNING,
333		"-otW accuracy depends on -aa 0 -as 0");
334		break;
335		case 'm':                               /* modifier */
336		*table++ = oputm;
337	+	ncomp++;
338		break;
339		case 'M':                               /* material */
340		*table++ = oputM;
341	+	ncomp++;
342		break;
343		case '~':                               /* tilde */
344		*table++ = oputtilde;
345		break;
346	+	default:
347	+	sprintf(errmsg, "unrecognized output option '%c'", *vs);
348	+	error(USER, errmsg);
349		}
350	+	while (*++vs);
351	+
352		*table = NULL;
353	+	if (*every_out != NULL)
354	+	ncomp = 0;
355	+	/* compatibility */
356	+	if ((do_irrad | imm_irrad) && castonly)
357	+	error(USER, "-I+ and -i+ options require some value output");
358	+	for (table = ray_out; *table != NULL; table++) {
359	+	if ((*table == oputV) | (*table == oputW))
360	+	error(WARNING, "-oVW options require trace mode");
361	+	if ((do_irrad | imm_irrad) &&
362	+	(*table == oputr) | (*table == oputR) |
363	+	(*table == oputx) | (*table == oputX))
364	+	error(WARNING, "-orRxX options incompatible with -I+ and -i+");
365	+	}
366	+	return(ncomp);
367		}
368
369
370		static void
371		bogusray(void)                  /* print out empty record */
372		{
317	–	thisray.rorg[0] = thisray.rorg[1] = thisray.rorg[2] =
318	–	thisray.rdir[0] = thisray.rdir[1] = thisray.rdir[2] = 0.0;
319	–	thisray.rmax = 0.0;
373		rayorigin(&thisray, PRIMARY, NULL, NULL);
374		printvals(&thisray);
375		}
#	Line 343 | Line 396 | rayirrad(                      /* compute irradiance rather than radiance
396		)
397		{
398		void    (*old_revf)(RAY *) = r->revf;
399	<
400	<	r->rot = 1e-5;                  /* pretend we hit surface */
399	>	/* pretend we hit surface */
400	>	r->rxt = r->rot = 1e-5;
401		VSUM(r->rop, r->rorg, r->rdir, r->rot);
402		r->ron[0] = -r->rdir[0];
403		r->ron[1] = -r->rdir[1];
#	Line 409 | Line 462 | printvals(                     /* print requested ray values */
462
463
464		static int
465	<	getvec(         /* get a vector from fp */
465	>	is_fifo(                /* check if file pointer connected to pipe */
466	>	FILE *fp
467	>	)
468	>	{
469	>	#ifdef S_ISFIFO
470	>	struct stat  sbuf;
471	>
472	>	if (fstat(fileno(fp), &sbuf) < 0)
473	>	error(SYSTEM, "fstat() failed on input stream");
474	>	return(S_ISFIFO(sbuf.st_mode));
475	>	#else
476	>	return (fp == stdin);           /* just a guess, really */
477	>	#endif
478	>	}
479	>
480	>
481	>	static int
482	>	getvec(                 /* get a vector from fp */
483		FVECT  vec,
484		int  fmt,
485		FILE  *fp
#	Line 446 | Line 516 | getvec(                /* get a vector from fp */
516		}
517
518
519	+	static int
520	+	iszerovec(const FVECT vec)
521	+	{
522	+	return (vec[0] == 0.0) & (vec[1] == 0.0) & (vec[2] == 0.0);
523	+	}
524	+
525	+
526	+	static double
527	+	nextray(                /* return next ray in work group (-1.0 if EOF) */
528	+	FVECT org,
529	+	FVECT dir
530	+	)
531	+	{
532	+	const size_t    qlength = !vresolu * hresolu;
533	+
534	+	if ((org == NULL) | (dir == NULL)) {
535	+	if (inp_queue != NULL)  /* asking to free queue */
536	+	free(inp_queue);
537	+	inp_queue = NULL;
538	+	inp_qpos = inp_qend = 0;
539	+	return(-1.);
540	+	}
541	+	if (!inp_qend) {                /* initialize FIFO queue */
542	+	int     rsiz = 6*20;    /* conservative ascii ray size */
543	+	if (inform == 'f') rsiz = 6*sizeof(float);
544	+	else if (inform == 'd') rsiz = 6*sizeof(double);
545	+	/* check against pipe limit */
546	+	if (qlength*rsiz > 512 && is_fifo(inpfp))
547	+	inp_queue = (FVECT *)malloc(sizeof(FVECT)*2*qlength);
548	+	inp_qend = -(inp_queue == NULL);        /* flag for no queue */
549	+	}
550	+	if (inp_qend < 0) {             /* not queuing? */
551	+	if (getvec(org, inform, inpfp) < 0 ||
552	+	getvec(dir, inform, inpfp) < 0)
553	+	return(-1.);
554	+	return normalize(dir);
555	+	}
556	+	if (inp_qpos >= inp_qend) {     /* need to refill input queue? */
557	+	for (inp_qend = 0; inp_qend < qlength; inp_qend++) {
558	+	if (getvec(inp_queue[2*inp_qend], inform, inpfp) < 0
559	+	|| getvec(inp_queue[2*inp_qend+1],
560	+	inform, inpfp) < 0)
561	+	break;          /* hit EOF */
562	+	if (iszerovec(inp_queue[2*inp_qend+1])) {
563	+	++inp_qend;     /* flush request */
564	+	break;
565	+	}
566	+	}
567	+	inp_qpos = 0;
568	+	}
569	+	if (inp_qpos >= inp_qend)       /* unexpected EOF? */
570	+	return(-1.);
571	+	VCOPY(org, inp_queue[2*inp_qpos]);
572	+	VCOPY(dir, inp_queue[2*inp_qpos+1]);
573	+	++inp_qpos;
574	+	return normalize(dir);
575	+	}
576	+
577	+
578		void
579		tranotify(                      /* record new modifier */
580		OBJECT  obj
#	Line 581 | Line 710 | oputv(                         /* print value */
710		{
711		RREAL   cval[3];
712
584	–	if (outform == 'c') {
585	–	COLR  cout;
586	–	setcolr(cout,   colval(r->rcol,RED),
587	–	colval(r->rcol,GRN),
588	–	colval(r->rcol,BLU));
589	–	putbinary(cout, sizeof(cout), 1, stdout);
590	–	return;
591	–	}
713		cval[0] = colval(r->rcol,RED);
714		cval[1] = colval(r->rcol,GRN);
715		cval[2] = colval(r->rcol,BLU);
#	Line 646 | Line 767 | oputp(                         /* print point */
767		RAY  *r
768		)
769		{
770	<	if (r->rot < FHUGE)
770	>	if (r->rot < FHUGE*.99)
771		(*putreal)(r->rop, 3);
772		else
773		(*putreal)(vdummy, 3);
#	Line 658 | Line 779 | oputN(                         /* print unperturbed normal */
779		RAY  *r
780		)
781		{
782	<	if (r->rot < FHUGE)
783	<	(*putreal)(r->ron, 3);
784	<	else
782	>	if (r->rot < FHUGE*.99) {
783	>	if (r->rflips & 1) {    /* undo any flippin' flips */
784	>	FVECT   unrm;
785	>	unrm[0] = -r->ron[0];
786	>	unrm[1] = -r->ron[1];
787	>	unrm[2] = -r->ron[2];
788	>	(*putreal)(unrm, 3);
789	>	} else
790	>	(*putreal)(r->ron, 3);
791	>	} else
792		(*putreal)(vdummy, 3);
793		}
794
#	Line 672 | Line 800 | oputn(                         /* print perturbed normal */
800		{
801		FVECT  pnorm;
802
803	<	if (r->rot >= FHUGE) {
803	>	if (r->rot >= FHUGE*.99) {
804		(*putreal)(vdummy, 3);
805		return;
806		}
#	Line 779 | Line 907 | puta(                          /* print ascii value(s) */
907
908
909		static void
910	<	putd(RREAL *v, int n)           /* print binary double(s) */
910	>	putd(RREAL *v, int n)           /* output binary double(s) */
911		{
912		#ifdef  SMLFLT
913		double  da[3];
#	Line 797 | Line 925 | putd(RREAL *v, int n)          /* print binary double(s) */
925
926
927		static void
928	<	putf(RREAL *v, int n)           /* print binary float(s) */
928	>	putf(RREAL *v, int n)           /* output binary float(s) */
929		{
930		#ifndef SMLFLT
931		float   fa[3];
#	Line 811 | Line 939 | putf(RREAL *v, int n)          /* print binary float(s) */
939		#else
940		putbinary(v, sizeof(RREAL), n, stdout);
941		#endif
942	+	}
943	+
944	+
945	+	static void
946	+	putrgbe(RREAL *v, int n)        /* output RGBE color */
947	+	{
948	+	COLR  cout;
949	+
950	+	if (n != 3)
951	+	error(INTERNAL, "putrgbe() not called with 3 components");
952	+	setcolr(cout, v[0], v[1], v[2]);
953	+	putbinary(cout, sizeof(cout), 1, stdout);
954		}

Diff Legend

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