[ViewVC] Diff of: radiance/ray/src/rt/rtrace.c

Comparing ray/src/rt/rtrace.c (file contents):
Revision 2.41 by greg, Wed May 25 04:44:26 2005 UTC vs.
Revision 2.78 by greg, Sat May 4 23:10:32 2019 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
35	<	CUBE thescene; /* our scene */
36	<	OBJECT nsceneobjs; /* number of objects in our scene */
35	>	extern int inform; /* input format */
36	>	extern int outform; /* output format */
37	>	extern char outvals; / output values */
38
39	<	int dimlist[MAXDIM]; /* sampling dimensions */
40	<	int ndims = 0; /* number of sampling dimensions */
38	<	int samplendx = 0; /* index for this sample */
39	>	extern int imm_irrad; /* compute immediate irradiance? */
40	>	extern int lim_dist; /* limit distance? */
41
42	<	int imm_irrad = 0; /* compute immediate irradiance? */
43	<	int lim_dist = 0; /* limit distance? */
42	>	extern char tralist[]; / list of modifers to trace (or no) */
43	>	extern int traincl; /* include == 1, exclude == 0 */
44
45	<	int inform = 'a'; /* input format */
46	<	int outform = 'a'; /* output format */
45	<	char outvals = "v"; / output specification */
45	>	extern int hresolu; /* horizontal resolution */
46	>	extern int vresolu; /* vertical resolution */
47
48	<	int do_irrad = 0; /* compute irradiance? */
48	>	static int castonly = 0;
49
50	<	void (trace)() = NULL; / trace call */
51	<
52	<	char tralist[128]; / list of modifers to trace (or no) */
52	<	int traincl = -1; /* include == 1, exclude == 0 */
53	<	#define MAXTSET 511 /* maximum number in trace set */
50	>	#ifndef MAXTSET
51	>	#define MAXTSET 8191 /* maximum number in trace set */
52	>	#endif
53		OBJECT traset[MAXTSET+1]={0}; /* trace include/exclude set */
54
56	–	int hresolu = 0; /* horizontal (scan) size */
57	–	int vresolu = 0; /* vertical resolution */
58	–
59	–	double dstrsrc = 0.0; /* square source distribution */
60	–	double shadthresh = .03; /* shadow threshold */
61	–	double shadcert = .75; /* shadow certainty */
62	–	int directrelay = 2; /* number of source relays */
63	–	int vspretest = 512; /* virtual source pretest density */
64	–	int directvis = 1; /* sources visible? */
65	–	double srcsizerat = .2; /* maximum ratio source size/dist. */
66	–
67	–	COLOR cextinction = BLKCOLOR; /* global extinction coefficient */
68	–	COLOR salbedo = BLKCOLOR; /* global scattering albedo */
69	–	double seccg = 0.; /* global scattering eccentricity */
70	–	double ssampdist = 0.; /* scatter sampling distance */
71	–
72	–	double specthresh = .15; /* specular sampling threshold */
73	–	double specjitter = 1.; /* specular sampling jitter */
74	–
75	–	int backvis = 1; /* back face visibility */
76	–
77	–	int maxdepth = 8; /* maximum recursion depth */
78	–	double minweight = 2e-3; /* minimum ray weight */
79	–
80	–	char ambfile = NULL; / ambient file name */
81	–	COLOR ambval = BLKCOLOR; /* ambient value */
82	–	int ambvwt = 0; /* initial weight for ambient value */
83	–	double ambacc = 0.15; /* ambient accuracy */
84	–	int ambres = 256; /* ambient resolution */
85	–	int ambdiv = 1024; /* ambient divisions */
86	–	int ambssamp = 512; /* ambient super-samples */
87	–	int ambounce = 0; /* ambient bounces */
88	–	char amblist[AMBLLEN]; / ambient include/exclude list */
89	–	int ambincl = -1; /* include == 1, exclude == 0 */
90	–
91	–	static int castonly = 0;
92	–
55		static RAY thisray; /* for our convenience */
56
57	<	typedef void putf_t(double v);
57	>	typedef void putf_t(RREAL *v, int n);
58		static putf_t puta, putd, putf;
59
60		typedef void oputf_t(RAY *r);
61	<	static oputf_t oputo, oputd, oputv, oputl, oputL, oputc, oputp,
62	<	oputn, oputN, oputs, oputw, oputW, oputm, oputM, oputdash;
61	>	static oputf_t oputo, oputd, oputv, oputV, oputl, oputL, oputc, oputp,
62	>	oputr, oputR, oputx, oputX, oputn, oputN, oputs,
63	>	oputw, oputW, oputm, oputM, oputtilde;
64
65		static void setoutput(char *vs);
66	<	static void tranotify(OBJECT obj);
66	>	extern void tranotify(OBJECT obj);
67		static void bogusray(void);
68	<	static void rad(FVECT org, FVECT dir, double dmax);
69	<	static void irrad(FVECT org, FVECT dir);
70	<	static void printvals(RAY *r);
71	<	static int getvec(FVECT vec, int fmt, FILE *fp);
72	<	static void tabin(RAY *r);
73	<	static void ourtrace(RAY *r);
68	>	static void raycast(RAY *r);
69	>	static void rayirrad(RAY *r);
70	>	static void rtcompute(FVECT org, FVECT dir, double dmax);
71	>	static int printvals(RAY *r);
72	>	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
115	–	void (*addobjnotify[])() = {ambnotify, tranotify, NULL};
79
117	–
80		void
81		quit( /* quit program */
82		int code
83		)
84		{
85	<	#ifndef NON_POSIX /* XXX we don't clean up elsewhere? */
86	<	headclean(); /* delete header file */
87	<	pfclean(); /* clean up persist files */
85	>	if (ray_pnprocs > 0) /* close children if any */
86	>	ray_pclose(0);
87	>	#ifndef NON_POSIX
88	>	else if (!ray_pnprocs) {
89	>	headclean(); /* delete header file */
90	>	pfclean(); /* clean up persist files */
91	>	}
92		#endif
93		exit(code);
94		}
95
96
97	<	extern char *
97	>	char *
98		formstr( /* return format identifier */
99		int f
100		)
#	Line 145 \| Line 111 \| *formstr( / return format identifier /*
111
112		extern void
113		rtrace( /* trace rays from file */
114	<	char *fname
114	>	char *fname,
115	>	int nproc
116		)
117		{
118	<	long vcount = hresolu>1 ? hresolu*vresolu : vresolu;
119	<	long nextflush = hresolu;
118	>	unsigned long vcount = (hresolu > 1) ? (unsigned long)hresolu*vresolu
119	>	: (unsigned long)vresolu;
120	>	long nextflush = (vresolu > 0) & (hresolu > 1) ? 0 : hresolu;
121	>	int bogusflushed = 0;
122		FILE *fp;
123		double d;
124		FVECT orig, direc;
#	Line 160 \| Line 129 \| *rtrace( / trace rays from file /*
129		sprintf(errmsg, "cannot open input file \"%s\"", fname);
130		error(SYSTEM, errmsg);
131		}
163	–	#ifdef _WIN32
132		if (inform != 'a')
133		SET_FILE_BINARY(fp);
166	–	#endif
134		/* set up output */
135		setoutput(outvals);
136	+	if (imm_irrad)
137	+	castonly = 0;
138	+	else if (castonly)
139	+	nproc = 1; /* don't bother multiprocessing */
140		switch (outform) {
141		case 'a': putreal = puta; break;
142		case 'f': putreal = putf; break;
#	Line 177 \| Line 148 \| *rtrace( / trace rays from file /*
148		default:
149		error(CONSISTENCY, "botched output format");
150		}
151	+	if (nproc > 1) { /* start multiprocessing */
152	+	ray_popen(nproc);
153	+	ray_fifo_out = printvals;
154	+	}
155		if (hresolu > 0) {
156		if (vresolu > 0)
157		fprtresolu(hresolu, vresolu, stdout);
158	<	fflush(stdout);
158	>	else
159	>	fflush(stdout);
160		}
161		/* process file */
162		while (getvec(orig, inform, fp) == 0 &&
#	Line 188 \| Line 164 \| *rtrace( / trace rays from file /*
164
165		d = normalize(direc);
166		if (d == 0.0) { /* zero ==> flush */
167	<	bogusray();
168	<	if (--nextflush <= 0 \|\| vcount <= 0) {
167	>	if ((--nextflush <= 0) \| !vcount && !bogusflushed) {
168	>	if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
169	>	error(USER, "child(ren) died");
170	>	bogusray();
171		fflush(stdout);
172	<	nextflush = hresolu;
173	<	}
174	<	} else {
175	<	samplendx++;
176	<	/* compute and print */
177	<	if (imm_irrad)
178	<	irrad(orig, direc);
201	<	else
202	<	rad(orig, direc, lim_dist ? d : 0.0);
172	>	bogusflushed = 1;
173	>	nextflush = (vresolu > 0) & (hresolu > 1) ? 0 :
174	>	hresolu;
175	>	} else
176	>	bogusray();
177	>	} else { /* compute and print */
178	>	rtcompute(orig, direc, lim_dist ? d : 0.0);
179		/* flush if time */
180	<	if (--nextflush == 0) {
180	>	if (!--nextflush) {
181	>	if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
182	>	error(USER, "child(ren) died");
183		fflush(stdout);
184		nextflush = hresolu;
185	<	}
185	>	} else
186	>	bogusflushed = 0;
187		}
188		if (ferror(stdout))
189		error(SYSTEM, "write error");
190	<	if (--vcount == 0) /* check for end */
190	>	if (vcount && !--vcount) /* check for end */
191		break;
192		}
193	<	fflush(stdout);
194	<	if (vcount > 0)
195	<	error(USER, "read error");
193	>	if (ray_pnprocs > 1) { /* clean up children */
194	>	if (ray_fifo_flush() < 0)
195	>	error(USER, "unable to complete processing");
196	>	ray_pclose(0);
197	>	}
198	>	if (fflush(stdout) < 0)
199	>	error(SYSTEM, "write error");
200	>	if (vcount)
201	>	error(USER, "unexpected EOF on input");
202		if (fname != NULL)
203		fclose(fp);
204		}
#	Line 231 \| Line 216 \| *trace_sources(void) / trace rays to light sources,**
216
217		static void
218		setoutput( /* set up output tables */
219	<	register char *vs
219	>	char *vs
220		)
221		{
222	<	register oputf_t **table = ray_out;
222	>	oputf_t **table = ray_out;
223
224		castonly = 1;
225		while (*vs)
226		switch (*vs++) {
227		case 'T': /* trace sources */
228	+	if (!*vs) break;
229		trace_sources();
230		/* fall through */
231		case 't': /* trace */
232	+	if (!*vs) break;
233		*table = NULL;
234		table = every_out;
235		trace = ourtrace;
#	Line 254 \| Line 241 \| *setoutput( / set up output tables /*
241		case 'd': /* direction */
242		*table++ = oputd;
243		break;
244	+	case 'r': /* reflected contrib. */
245	+	*table++ = oputr;
246	+	castonly = 0;
247	+	break;
248	+	case 'R': /* reflected distance */
249	+	*table++ = oputR;
250	+	castonly = 0;
251	+	break;
252	+	case 'x': /* xmit contrib. */
253	+	*table++ = oputx;
254	+	castonly = 0;
255	+	break;
256	+	case 'X': /* xmit distance */
257	+	*table++ = oputX;
258	+	castonly = 0;
259	+	break;
260		case 'v': /* value */
261		*table++ = oputv;
262		castonly = 0;
263		break;
264	+	case 'V': /* contribution */
265	+	*table++ = oputV;
266	+	castonly = 0;
267	+	if (ambounce > 0 && (ambacc > FTINY \|\| ambssamp > 0))
268	+	error(WARNING,
269	+	"-otV accuracy depends on -aa 0 -as 0");
270	+	break;
271		case 'l': /* effective distance */
272		*table++ = oputl;
273		castonly = 0;
#	Line 286 \| Line 296 \| *setoutput( / set up output tables /*
296		break;
297		case 'W': /* coefficient */
298		*table++ = oputW;
299	+	castonly = 0;
300		if (ambounce > 0 && (ambacc > FTINY \|\| ambssamp > 0))
301		error(WARNING,
302		"-otW accuracy depends on -aa 0 -as 0");
#	Line 296 \| Line 307 \| *setoutput( / set up output tables /*
307		case 'M': /* material */
308		*table++ = oputM;
309		break;
310	<	case '-': /* dash */
311	<	*table++ = oputdash;
310	>	case '~': /* tilde */
311	>	*table++ = oputtilde;
312		break;
313		}
314		*table = NULL;
#	Line 307 \| Line 318 \| *setoutput( / set up output tables /*
318		static void
319		bogusray(void) /* print out empty record */
320		{
310	–	thisray.rorg[0] = thisray.rorg[1] = thisray.rorg[2] =
311	–	thisray.rdir[0] = thisray.rdir[1] = thisray.rdir[2] = 0.0;
312	–	thisray.rmax = 0.0;
321		rayorigin(&thisray, PRIMARY, NULL, NULL);
322		printvals(&thisray);
323		}
324
325
326		static void
327	<	rad( /* compute and print ray value(s) */
328	<	FVECT org,
321	<	FVECT dir,
322	<	double dmax
327	>	raycast( /* compute first ray intersection only */
328	>	RAY *r
329		)
330		{
331	<	VCOPY(thisray.rorg, org);
332	<	VCOPY(thisray.rdir, dir);
333	<	thisray.rmax = dmax;
334	<	rayorigin(&thisray, PRIMARY, NULL, NULL);
335	<	if (castonly) {
336	<	if (!localhit(&thisray, &thescene)) {
337	<	if (thisray.ro == &Aftplane) { /* clipped */
332	<	thisray.ro = NULL;
333	<	thisray.rot = FHUGE;
334	<	} else
335	<	sourcehit(&thisray);
336	<	}
337	<	} else
338	<	rayvalue(&thisray);
339	<	printvals(&thisray);
331	>	if (!localhit(r, &thescene)) {
332	>	if (r->ro == &Aftplane) { /* clipped */
333	>	r->ro = NULL;
334	>	r->rot = FHUGE;
335	>	} else
336	>	sourcehit(r);
337	>	}
338		}
339
340
341		static void
342	<	irrad( /* compute immediate irradiance value */
343	<	FVECT org,
346	<	FVECT dir
342	>	rayirrad( /* compute irradiance rather than radiance */
343	>	RAY *r
344		)
345		{
346	<	register int i;
346	>	void (old_revf)(RAY ) = r->revf;
347	>	/* pretend we hit surface */
348	>	r->rxt = r->rot = 1e-5;
349	>	VSUM(r->rop, r->rorg, r->rdir, r->rot);
350	>	r->ron[0] = -r->rdir[0];
351	>	r->ron[1] = -r->rdir[1];
352	>	r->ron[2] = -r->rdir[2];
353	>	r->rod = 1.0;
354	>	/* compute result */
355	>	r->revf = raytrace;
356	>	(*ofun[Lamb.otype].funp)(&Lamb, r);
357	>	r->revf = old_revf;
358	>	}
359
360	<	for (i = 0; i < 3; i++) {
361	<	thisray.rorg[i] = org[i] + dir[i];
362	<	thisray.rdir[i] = -dir[i];
363	<	}
364	<	thisray.rmax = 0.0;
360	>
361	>	static void
362	>	rtcompute( /* compute and print ray value(s) */
363	>	FVECT org,
364	>	FVECT dir,
365	>	double dmax
366	>	)
367	>	{
368	>	/* set up ray */
369		rayorigin(&thisray, PRIMARY, NULL, NULL);
370	<	/* pretend we hit surface */
371	<	thisray.rot = 1.0-1e-4;
372	<	thisray.rod = 1.0;
373	<	VCOPY(thisray.ron, dir);
374	<	for (i = 0; i < 3; i++) /* fudge factor */
375	<	thisray.rop[i] = org[i] + 1e-4*dir[i];
376	<	/* compute and print */
377	<	(*ofun[Lamb.otype].funp)(&Lamb, &thisray);
370	>	if (imm_irrad) {
371	>	VSUM(thisray.rorg, org, dir, 1.1e-4);
372	>	thisray.rdir[0] = -dir[0];
373	>	thisray.rdir[1] = -dir[1];
374	>	thisray.rdir[2] = -dir[2];
375	>	thisray.rmax = 0.0;
376	>	thisray.revf = rayirrad;
377	>	} else {
378	>	VCOPY(thisray.rorg, org);
379	>	VCOPY(thisray.rdir, dir);
380	>	thisray.rmax = dmax;
381	>	if (castonly)
382	>	thisray.revf = raycast;
383	>	}
384	>	if (ray_pnprocs > 1) { /* multiprocessing FIFO? */
385	>	if (ray_fifo_in(&thisray) < 0)
386	>	error(USER, "lost children");
387	>	return;
388	>	}
389	>	samplendx++; /* else do it ourselves */
390	>	rayvalue(&thisray);
391		printvals(&thisray);
392		}
393
394
395	<	static void
395	>	static int
396		printvals( /* print requested ray values */
397		RAY *r
398		)
399		{
400	<	register oputf_t **tp;
400	>	oputf_t **tp;
401
402		if (ray_out[0] == NULL)
403	<	return;
403	>	return(0);
404		for (tp = ray_out; *tp != NULL; tp++)
405		(**tp)(r);
406		if (outform == 'a')
407		putchar('\n');
408	+	return(1);
409		}
410
411
412		static int
413		getvec( /* get a vector from fp */
414	<	register FVECT vec,
414	>	FVECT vec,
415		int fmt,
416		FILE *fp
417		)
#	Line 392 \| Line 419 \| *getvec( / get a vector from fp /*
419		static float vf[3];
420		static double vd[3];
421		char buf[32];
422	<	register int i;
422	>	int i;
423
424		switch (fmt) {
425		case 'a': /* ascii */
#	Line 404 \| Line 431 \| *getvec( / get a vector from fp /*
431		}
432		break;
433		case 'f': /* binary float */
434	<	if (fread((char *)vf, sizeof(float), 3, fp) != 3)
434	>	if (getbinary(vf, sizeof(float), 3, fp) != 3)
435		return(-1);
436	<	vec[0] = vf[0]; vec[1] = vf[1]; vec[2] = vf[2];
436	>	VCOPY(vec, vf);
437		break;
438		case 'd': /* binary double */
439	<	if (fread((char *)vd, sizeof(double), 3, fp) != 3)
439	>	if (getbinary(vd, sizeof(double), 3, fp) != 3)
440		return(-1);
441	<	vec[0] = vd[0]; vec[1] = vd[1]; vec[2] = vd[2];
441	>	VCOPY(vec, vd);
442		break;
443		default:
444		error(CONSISTENCY, "botched input format");
#	Line 420 \| Line 447 \| *getvec( / get a vector from fp /*
447		}
448
449
450	<	static void
450	>	void
451		tranotify( /* record new modifier */
452		OBJECT obj
453		)
454		{
455		static int hitlimit = 0;
456	<	register OBJREC *o = objptr(obj);
457	<	register char **tralp;
456	>	OBJREC *o = objptr(obj);
457	>	char **tralp;
458
459		if (obj == OVOID) { /* starting over */
460		traset[0] = 0;
#	Line 454 \| Line 481 \| *ourtrace( / print ray values /*
481		RAY *r
482		)
483		{
484	<	register oputf_t **tp;
484	>	oputf_t **tp;
485
486		if (every_out[0] == NULL)
487		return;
#	Line 488 \| Line 515 \| *oputo( / print origin /*
515		RAY *r
516		)
517		{
518	<	(*putreal)(r->rorg[0]);
492	<	(*putreal)(r->rorg[1]);
493	<	(*putreal)(r->rorg[2]);
518	>	(*putreal)(r->rorg, 3);
519		}
520
521
#	Line 499 \| Line 524 \| *oputd( / print direction /*
524		RAY *r
525		)
526		{
527	<	(*putreal)(r->rdir[0]);
503	<	(*putreal)(r->rdir[1]);
504	<	(*putreal)(r->rdir[2]);
527	>	(*putreal)(r->rdir, 3);
528		}
529
530
531		static void
532	+	oputr( /* print mirrored contribution */
533	+	RAY *r
534	+	)
535	+	{
536	+	RREAL cval[3];
537	+
538	+	cval[0] = colval(r->mcol,RED);
539	+	cval[1] = colval(r->mcol,GRN);
540	+	cval[2] = colval(r->mcol,BLU);
541	+	(*putreal)(cval, 3);
542	+	}
543	+
544	+
545	+
546	+	static void
547	+	oputR( /* print mirrored distance */
548	+	RAY *r
549	+	)
550	+	{
551	+	(*putreal)(&r->rmt, 1);
552	+	}
553	+
554	+
555	+	static void
556	+	oputx( /* print unmirrored contribution */
557	+	RAY *r
558	+	)
559	+	{
560	+	RREAL cval[3];
561	+
562	+	cval[0] = colval(r->rcol,RED) - colval(r->mcol,RED);
563	+	cval[1] = colval(r->rcol,GRN) - colval(r->mcol,GRN);
564	+	cval[2] = colval(r->rcol,BLU) - colval(r->mcol,BLU);
565	+	(*putreal)(cval, 3);
566	+	}
567	+
568	+
569	+	static void
570	+	oputX( /* print unmirrored distance */
571	+	RAY *r
572	+	)
573	+	{
574	+	(*putreal)(&r->rxt, 1);
575	+	}
576	+
577	+
578	+	static void
579		oputv( /* print value */
580		RAY *r
581		)
582		{
583	+	RREAL cval[3];
584	+
585		if (outform == 'c') {
586		COLR cout;
587		setcolr(cout, colval(r->rcol,RED),
588		colval(r->rcol,GRN),
589		colval(r->rcol,BLU));
590	<	fwrite((char *)cout, sizeof(cout), 1, stdout);
590	>	putbinary(cout, sizeof(cout), 1, stdout);
591		return;
592		}
593	<	(*putreal)(colval(r->rcol,RED));
594	<	(*putreal)(colval(r->rcol,GRN));
595	<	(*putreal)(colval(r->rcol,BLU));
593	>	cval[0] = colval(r->rcol,RED);
594	>	cval[1] = colval(r->rcol,GRN);
595	>	cval[2] = colval(r->rcol,BLU);
596	>	(*putreal)(cval, 3);
597		}
598
599
600		static void
601	+	oputV( /* print value contribution */
602	+	RAY *r
603	+	)
604	+	{
605	+	RREAL contr[3];
606	+
607	+	raycontrib(contr, r, PRIMARY);
608	+	multcolor(contr, r->rcol);
609	+	(*putreal)(contr, 3);
610	+	}
611	+
612	+
613	+	static void
614		oputl( /* print effective distance */
615		RAY *r
616		)
617		{
618	<	(*putreal)(r->rt);
618	>	RREAL d = raydistance(r);
619	>
620	>	(*putreal)(&d, 1);
621		}
622
623
#	Line 538 \| Line 626 \| *oputL( / print single ray length /*
626		RAY *r
627		)
628		{
629	<	(*putreal)(r->rot);
629	>	(*putreal)(&r->rot, 1);
630		}
631
632
#	Line 547 \| Line 635 \| *oputc( / print local coordinates /*
635		RAY *r
636		)
637		{
638	<	(*putreal)(r->uv[0]);
551	<	(*putreal)(r->uv[1]);
638	>	(*putreal)(r->uv, 2);
639		}
640
641
642	+	static RREAL vdummy[3] = {0.0, 0.0, 0.0};
643	+
644	+
645		static void
646		oputp( /* print point */
647		RAY *r
648		)
649		{
650	<	if (r->rot < FHUGE) {
651	<	(*putreal)(r->rop[0]);
652	<	(*putreal)(r->rop[1]);
653	<	(*putreal)(r->rop[2]);
564	<	} else {
565	<	(*putreal)(0.0);
566	<	(*putreal)(0.0);
567	<	(*putreal)(0.0);
568	<	}
650	>	if (r->rot < FHUGE)
651	>	(*putreal)(r->rop, 3);
652	>	else
653	>	(*putreal)(vdummy, 3);
654		}
655
656
#	Line 574 \| Line 659 \| *oputN( / print unperturbed normal /*
659		RAY *r
660		)
661		{
662	<	if (r->rot < FHUGE) {
663	<	(*putreal)(r->ron[0]);
664	<	(*putreal)(r->ron[1]);
665	<	(*putreal)(r->ron[2]);
581	<	} else {
582	<	(*putreal)(0.0);
583	<	(*putreal)(0.0);
584	<	(*putreal)(0.0);
585	<	}
662	>	if (r->rot < FHUGE)
663	>	(*putreal)(r->ron, 3);
664	>	else
665	>	(*putreal)(vdummy, 3);
666		}
667
668
#	Line 594 \| Line 674 \| *oputn( / print perturbed normal /*
674		FVECT pnorm;
675
676		if (r->rot >= FHUGE) {
677	<	(*putreal)(0.0);
598	<	(*putreal)(0.0);
599	<	(*putreal)(0.0);
677	>	(*putreal)(vdummy, 3);
678		return;
679		}
680		raynormal(pnorm, r);
681	<	(*putreal)(pnorm[0]);
604	<	(*putreal)(pnorm[1]);
605	<	(*putreal)(pnorm[2]);
681	>	(*putreal)(pnorm, 3);
682		}
683
684
#	Line 624 \| Line 700 \| *oputw( / print weight /*
700		RAY *r
701		)
702		{
703	<	(*putreal)(r->rweight);
703	>	RREAL rwt = r->rweight;
704	>
705	>	(*putreal)(&rwt, 1);
706		}
707
708
709		static void
710	<	oputW( /* print contribution */
710	>	oputW( /* print coefficient */
711		RAY *r
712		)
713		{
714	<	COLOR contr;
714	>	RREAL contr[3];
715	>	/* shadow ray not on source? */
716	>	if (r->rsrc >= 0 && source[r->rsrc].so != r->ro)
717	>	setcolor(contr, 0.0, 0.0, 0.0);
718	>	else
719	>	raycontrib(contr, r, PRIMARY);
720
721	<	raycontrib(contr, r, PRIMARY);
639	<	(*putreal)(colval(contr,RED));
640	<	(*putreal)(colval(contr,GRN));
641	<	(*putreal)(colval(contr,BLU));
721	>	(*putreal)(contr, 3);
722		}
723
724
#	Line 677 \| Line 757 \| *oputM( / print material /*
757
758
759		static void
760	<	oputdash( /* output dash (spacer) */
760	>	oputtilde( /* output tilde (spacer) */
761		RAY *r
762		)
763		{
764	<	putchar('-');
685	<	putchar('\t');
764	>	fputs("~\t", stdout);
765		}
766
767
768		static void
769	<	puta( /* print ascii value */
770	<	double v
769	>	puta( /* print ascii value(s) */
770	>	RREAL *v, int n
771		)
772		{
773	<	printf("%e\t", v);
773	>	if (n == 3) {
774	>	printf("%e\t%e\t%e\t", v[0], v[1], v[2]);
775	>	return;
776	>	}
777	>	while (n--)
778	>	printf("%e\t", *v++);
779		}
780
781
782		static void
783	<	putd(v) /* print binary double */
700	<	double v;
783	>	putd(RREAL v, int n) / print binary double(s) */
784		{
785	<	fwrite((char *)&v, sizeof(v), 1, stdout);
785	>	#ifdef SMLFLT
786	>	double da[3];
787	>	int i;
788	>
789	>	if (n > 3)
790	>	error(INTERNAL, "code error in putd()");
791	>	for (i = n; i--; )
792	>	da[i] = v[i];
793	>	putbinary(da, sizeof(double), n, stdout);
794	>	#else
795	>	putbinary(v, sizeof(RREAL), n, stdout);
796	>	#endif
797		}
798
799
800		static void
801	<	putf(v) /* print binary float */
708	<	double v;
801	>	putf(RREAL v, int n) / print binary float(s) */
802		{
803	<	float f = v;
803	>	#ifndef SMLFLT
804	>	float fa[3];
805	>	int i;
806
807	<	fwrite((char *)&f, sizeof(f), 1, stdout);
807	>	if (n > 3)
808	>	error(INTERNAL, "code error in putf()");
809	>	for (i = n; i--; )
810	>	fa[i] = v[i];
811	>	putbinary(fa, sizeof(float), n, stdout);
812	>	#else
813	>	putbinary(v, sizeof(RREAL), n, stdout);
814	>	#endif
815		}

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing ray/src/rt/rtrace.c (file contents): Revision 2.41 by greg, Wed May 25 04:44:26 2005 UTC vs. Revision 2.78 by greg, Sat May 4 23:10:32 2019 UTC

Diff Legend

Comparing ray/src/rt/rtrace.c (file contents):
Revision 2.41 by greg, Wed May 25 04:44:26 2005 UTC vs.
Revision 2.78 by greg, Sat May 4 23:10:32 2019 UTC