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.86 by greg, Tue Mar 3 19:39:32 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 54 | Line 55 | OBJECT traset[MAXTSET+1]={0};          /* trace include/exclud
55		static RAY  thisray;                    /* for our convenience */
56
57		typedef void putf_t(RREAL *v, int n);
58	<	static putf_t puta, putd, putf;
58	>	static putf_t puta, putd, putf, putrgbe;
59
60		typedef void oputf_t(RAY *r);
61		static oputf_t  oputo, oputd, oputv, oputV, oputl, oputL, oputc, oputp,
62	<	oputn, oputN, oputs, oputw, oputW, oputm, oputM, oputtilde;
62	>	oputr, oputR, oputx, oputX, oputn, oputN, oputs,
63	>	oputw, oputW, oputm, oputM, oputtilde;
64
65		static void setoutput(char *vs);
66		extern void tranotify(OBJECT obj);
#	Line 71 | Line 73 | static int getvec(FVECT vec, int fmt, FILE *fp);
73		static void tabin(RAY *r);
74		static void ourtrace(RAY *r);
75
76	<	static oputf_t *ray_out[16], *every_out[16];
76	>	static oputf_t *ray_out[32], *every_out[32];
77		static putf_t *putreal;
78
79
#	Line 115 | Line 117 | rtrace(                                /* trace rays from file */
117		{
118		unsigned long  vcount = (hresolu > 1) ? (unsigned long)hresolu*vresolu
119		: (unsigned long)vresolu;
120	<	long  nextflush = (vresolu > 0) & (hresolu > 1) ? 0 : hresolu;
120	>	long  nextflush = (!vresolu | (hresolu <= 1)) * hresolu;
121	>	int  something2flush = 0;
122		FILE  *fp;
123		double  d;
124		FVECT  orig, direc;
#	Line 134 | Line 137 | rtrace(                                /* trace rays from file */
137		castonly = 0;
138		else if (castonly)
139		nproc = 1;              /* don't bother multiprocessing */
140	+	if ((nextflush > 0) & (nproc > nextflush)) {
141	+	error(WARNING, "reducing number of processes to match flush interval");
142	+	nproc = nextflush;
143	+	}
144		switch (outform) {
145		case 'a': putreal = puta; break;
146		case 'f': putreal = putf; break;
147		case 'd': putreal = putd; break;
148		case 'c':
149	<	if (strcmp(outvals, "v"))
150	<	error(USER, "color format with value output only");
151	<	break;
149	>	if (outvals[0] && (outvals[1] || !strchr("vrx", outvals[0])))
150	>	error(USER, "color format only with -ov, -or, -ox");
151	>	putreal = putrgbe; break;
152		default:
153		error(CONSISTENCY, "botched output format");
154		}
#	Line 152 | Line 159 | rtrace(                                /* trace rays from file */
159		if (hresolu > 0) {
160		if (vresolu > 0)
161		fprtresolu(hresolu, vresolu, stdout);
162	<	fflush(stdout);
162	>	else
163	>	fflush(stdout);
164		}
165		/* process file */
166		while (getvec(orig, inform, fp) == 0 &&
167		getvec(direc, inform, fp) == 0) {
168
169		d = normalize(direc);
170	<	if (d == 0.0) {                         /* zero ==> flush */
171	<	if (--nextflush <= 0 || !vcount) {
172	<	if (nproc > 1 && ray_fifo_flush() < 0)
173	<	error(USER, "lost children");
174	<	bogusray();
170	>	if (d == 0.0) {                         /* bogus ray */
171	>	bogusray();
172	>	/* flush request? */
173	>	if (something2flush) {
174	>	if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
175	>	error(USER, "child(ren) died");
176		fflush(stdout);
177	<	nextflush = (vresolu > 0) & (hresolu > 1) ? 0 :
178	<	hresolu;
179	<	} else
171	<	bogusray();
177	>	nextflush = (!vresolu | (hresolu <= 1)) * hresolu;
178	>	something2flush = 0;
179	>	}
180		} else {                                /* compute and print */
181		rtcompute(orig, direc, lim_dist ? d : 0.0);
182		/* flush if time */
183		if (!--nextflush) {
184	<	if (nproc > 1 && ray_fifo_flush() < 0)
185	<	error(USER, "lost children");
184	>	if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
185	>	error(USER, "child(ren) died");
186		fflush(stdout);
187		nextflush = hresolu;
188	<	}
188	>	} else
189	>	something2flush = 1;
190		}
191		if (ferror(stdout))
192		error(SYSTEM, "write error");
193		if (vcount && !--vcount)                /* check for end */
194		break;
195		}
196	<	if (nproc > 1) {                                /* clean up children */
196	>	if (ray_pnprocs > 1) {                          /* clean up children */
197		if (ray_fifo_flush() < 0)
198		error(USER, "unable to complete processing");
199		ray_pclose(0);
#	Line 235 | Line 244 | setoutput(                             /* set up output tables */
244		case 'd':                               /* direction */
245		*table++ = oputd;
246		break;
247	+	case 'r':                               /* reflected contrib. */
248	+	*table++ = oputr;
249	+	castonly = 0;
250	+	break;
251	+	case 'R':                               /* reflected distance */
252	+	*table++ = oputR;
253	+	castonly = 0;
254	+	break;
255	+	case 'x':                               /* xmit contrib. */
256	+	*table++ = oputx;
257	+	castonly = 0;
258	+	break;
259	+	case 'X':                               /* xmit distance */
260	+	*table++ = oputX;
261	+	castonly = 0;
262	+	break;
263		case 'v':                               /* value */
264		*table++ = oputv;
265		castonly = 0;
#	Line 273 | Line 298 | setoutput(                             /* set up output tables */
298		break;
299		case 'W':                               /* coefficient */
300		*table++ = oputW;
301	<	if (ambounce > 0 && (ambacc > FTINY || ambssamp > 0))
301	>	castonly = 0;
302	>	if (ambounce > 0 && (ambacc > FTINY) | (ambssamp > 0))
303		error(WARNING,
304		"-otW accuracy depends on -aa 0 -as 0");
305		break;
#	Line 288 | Line 314 | setoutput(                             /* set up output tables */
314		break;
315		}
316		*table = NULL;
317	+	/* compatibility */
318	+	for (table = ray_out; *table != NULL; table++) {
319	+	if ((*table == oputV) | (*table == oputW))
320	+	error(WARNING, "-oVW options require trace mode");
321	+	if ((do_irrad | imm_irrad) &&
322	+	(*table == oputr) | (*table == oputR) |
323	+	(*table == oputx) | (*table == oputX))
324	+	error(WARNING, "-orRxX options incompatible with -I+ and -i+");
325	+	}
326		}
327
328
329		static void
330		bogusray(void)                  /* print out empty record */
331		{
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;
332		rayorigin(&thisray, PRIMARY, NULL, NULL);
333		printvals(&thisray);
334		}
#	Line 323 | Line 355 | rayirrad(                      /* compute irradiance rather than radiance
355		)
356		{
357		void    (*old_revf)(RAY *) = r->revf;
358	<
359	<	r->rot = 1e-5;                  /* pretend we hit surface */
358	>	/* pretend we hit surface */
359	>	r->rxt = r->rot = 1e-5;
360		VSUM(r->rop, r->rorg, r->rdir, r->rot);
361		r->ron[0] = -r->rdir[0];
362		r->ron[1] = -r->rdir[1];
#	Line 410 | Line 442 | getvec(                /* get a vector from fp */
442		}
443		break;
444		case 'f':                                       /* binary float */
445	<	if (fread((char *)vf, sizeof(float), 3, fp) != 3)
445	>	if (getbinary(vf, sizeof(float), 3, fp) != 3)
446		return(-1);
447		VCOPY(vec, vf);
448		break;
449		case 'd':                                       /* binary double */
450	<	if (fread((char *)vd, sizeof(double), 3, fp) != 3)
450	>	if (getbinary(vd, sizeof(double), 3, fp) != 3)
451		return(-1);
452		VCOPY(vec, vd);
453		break;
#	Line 508 | Line 540 | oputd(                         /* print direction */
540
541
542		static void
543	+	oputr(                          /* print mirrored contribution */
544	+	RAY  *r
545	+	)
546	+	{
547	+	RREAL   cval[3];
548	+
549	+	cval[0] = colval(r->mcol,RED);
550	+	cval[1] = colval(r->mcol,GRN);
551	+	cval[2] = colval(r->mcol,BLU);
552	+	(*putreal)(cval, 3);
553	+	}
554	+
555	+
556	+
557	+	static void
558	+	oputR(                          /* print mirrored distance */
559	+	RAY  *r
560	+	)
561	+	{
562	+	(*putreal)(&r->rmt, 1);
563	+	}
564	+
565	+
566	+	static void
567	+	oputx(                          /* print unmirrored contribution */
568	+	RAY  *r
569	+	)
570	+	{
571	+	RREAL   cval[3];
572	+
573	+	cval[0] = colval(r->rcol,RED) - colval(r->mcol,RED);
574	+	cval[1] = colval(r->rcol,GRN) - colval(r->mcol,GRN);
575	+	cval[2] = colval(r->rcol,BLU) - colval(r->mcol,BLU);
576	+	(*putreal)(cval, 3);
577	+	}
578	+
579	+
580	+	static void
581	+	oputX(                          /* print unmirrored distance */
582	+	RAY  *r
583	+	)
584	+	{
585	+	(*putreal)(&r->rxt, 1);
586	+	}
587	+
588	+
589	+	static void
590		oputv(                          /* print value */
591		RAY  *r
592		)
593		{
594		RREAL   cval[3];
595
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	–	}
596		cval[0] = colval(r->rcol,RED);
597		cval[1] = colval(r->rcol,GRN);
598		cval[2] = colval(r->rcol,BLU);
#	Line 547 | Line 618 | oputl(                         /* print effective distance */
618		RAY  *r
619		)
620		{
621	<	(*putreal)(&r->rt, 1);
621	>	RREAL   d = raydistance(r);
622	>
623	>	(*putreal)(&d, 1);
624		}
625
626
#	Line 589 | Line 662 | oputN(                         /* print unperturbed normal */
662		RAY  *r
663		)
664		{
665	<	if (r->rot < FHUGE)
666	<	(*putreal)(r->ron, 3);
667	<	else
665	>	if (r->rot < FHUGE) {
666	>	if (r->rflips & 1) {    /* undo any flippin' flips */
667	>	FVECT   unrm;
668	>	unrm[0] = -r->ron[0];
669	>	unrm[1] = -r->ron[1];
670	>	unrm[2] = -r->ron[2];
671	>	(*putreal)(unrm, 3);
672	>	} else
673	>	(*putreal)(r->ron, 3);
674	>	} else
675		(*putreal)(vdummy, 3);
676		}
677
#	Line 710 | Line 790 | puta(                          /* print ascii value(s) */
790
791
792		static void
793	<	putd(RREAL *v, int n)           /* print binary double(s) */
793	>	putd(RREAL *v, int n)           /* output binary double(s) */
794		{
795	<	if (sizeof(RREAL) != sizeof(double))
795	>	#ifdef  SMLFLT
796	>	double  da[3];
797	>	int     i;
798	>
799	>	if (n > 3)
800		error(INTERNAL, "code error in putd()");
801	<	fwrite(v, sizeof(RREAL), n, stdout);
801	>	for (i = n; i--; )
802	>	da[i] = v[i];
803	>	putbinary(da, sizeof(double), n, stdout);
804	>	#else
805	>	putbinary(v, sizeof(RREAL), n, stdout);
806	>	#endif
807		}
808
809
810		static void
811	<	putf(RREAL *v, int n)           /* print binary float(s) */
811	>	putf(RREAL *v, int n)           /* output binary float(s) */
812		{
813	+	#ifndef SMLFLT
814		float   fa[3];
815		int     i;
816
#	Line 728 | Line 818 | putf(RREAL *v, int n)          /* print binary float(s) */
818		error(INTERNAL, "code error in putf()");
819		for (i = n; i--; )
820		fa[i] = v[i];
821	<	fwrite(fa, sizeof(float), n, stdout);
821	>	putbinary(fa, sizeof(float), n, stdout);
822	>	#else
823	>	putbinary(v, sizeof(RREAL), n, stdout);
824	>	#endif
825	>	}
826	>
827	>
828	>	static void
829	>	putrgbe(RREAL *v, int n)        /* output RGBE color */
830	>	{
831	>	COLR  cout;
832	>
833	>	if (n != 3)
834	>	error(INTERNAL, "putrgbe() not called with 3 components");
835	>	setcolr(cout, v[0], v[1], v[2]);
836	>	putbinary(cout, sizeof(cout), 1, stdout);
837		}

Diff Legend

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