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

Comparing ray/src/rt/rtrace.c (file contents):
Revision 2.45 by greg, Fri Jun 10 16:49:42 2005 UTC vs.
Revision 2.84 by greg, Wed Aug 14 22:33:02 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 = -10; /* 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);
58	<	static putf_t puta, putd, putf;
57	>	typedef void putf_t(RREAL *v, int n);
58	>	static putf_t puta, putd, putf, putrgbe;
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, oputtilde;
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		unsigned long vcount = (hresolu > 1) ? (unsigned long)hresolu*vresolu
119	<	: vresolu;
120	<	long nextflush = hresolu;
119	>	: (unsigned long)vresolu;
120	>	long nextflush = (vresolu > 0) & (hresolu > 1) ? 0 : hresolu;
121	>	int something2flush = 0;
122		FILE *fp;
123		double d;
124		FVECT orig, direc;
#	Line 165 \| Line 133 \| *rtrace( / trace rays from file /*
133		SET_FILE_BINARY(fp);
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	+	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		}
155	+	if (nproc > 1) { /* start multiprocessing */
156	+	ray_popen(nproc);
157	+	ray_fifo_out = printvals;
158	+	}
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 &&
#	Line 187 \| Line 168 \| *rtrace( / trace rays from file /*
168
169		d = normalize(direc);
170		if (d == 0.0) { /* zero ==> flush */
171	<	bogusray();
172	<	if (--nextflush <= 0 \|\| !vcount) {
171	>	if ((--nextflush <= 0) \| !vcount && something2flush) {
172	>	if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
173	>	error(USER, "child(ren) died");
174	>	bogusray();
175		fflush(stdout);
176	<	nextflush = hresolu;
177	<	}
178	<	} else {
179	<	samplendx++;
180	<	/* compute and print */
181	<	if (imm_irrad)
182	<	irrad(orig, direc);
200	<	else
201	<	rad(orig, direc, lim_dist ? d : 0.0);
176	>	something2flush = 0;
177	>	nextflush = (vresolu > 0) & (hresolu > 1) ? 0 :
178	>	hresolu;
179	>	} else
180	>	bogusray();
181	>	} else { /* compute and print */
182	>	rtcompute(orig, direc, lim_dist ? d : 0.0);
183		/* flush if time */
184		if (!--nextflush) {
185	+	if (ray_pnprocs > 1 && ray_fifo_flush() < 0)
186	+	error(USER, "child(ren) died");
187		fflush(stdout);
188		nextflush = hresolu;
189	<	}
189	>	} else
190	>	something2flush = 1;
191		}
192		if (ferror(stdout))
193		error(SYSTEM, "write error");
194		if (vcount && !--vcount) /* check for end */
195		break;
196		}
197	<	fflush(stdout);
197	>	if (ray_pnprocs > 1) { /* clean up children */
198	>	if (ray_fifo_flush() < 0)
199	>	error(USER, "unable to complete processing");
200	>	ray_pclose(0);
201	>	}
202	>	if (fflush(stdout) < 0)
203	>	error(SYSTEM, "write error");
204		if (vcount)
205		error(USER, "unexpected EOF on input");
206		if (fname != NULL)
#	Line 230 \| Line 220 \| *trace_sources(void) / trace rays to light sources,**
220
221		static void
222		setoutput( /* set up output tables */
223	<	register char *vs
223	>	char *vs
224		)
225		{
226	<	register oputf_t **table = ray_out;
226	>	oputf_t **table = ray_out;
227
228		castonly = 1;
229		while (*vs)
#	Line 255 \| Line 245 \| *setoutput( / set up output tables /*
245		case 'd': /* direction */
246		*table++ = oputd;
247		break;
248	+	case 'r': /* reflected contrib. */
249	+	*table++ = oputr;
250	+	castonly = 0;
251	+	break;
252	+	case 'R': /* reflected distance */
253	+	*table++ = oputR;
254	+	castonly = 0;
255	+	break;
256	+	case 'x': /* xmit contrib. */
257	+	*table++ = oputx;
258	+	castonly = 0;
259	+	break;
260	+	case 'X': /* xmit distance */
261	+	*table++ = oputX;
262	+	castonly = 0;
263	+	break;
264		case 'v': /* value */
265		*table++ = oputv;
266		castonly = 0;
267		break;
268	+	case 'V': /* contribution */
269	+	*table++ = oputV;
270	+	if (ambounce > 0 && (ambacc > FTINY \|\| ambssamp > 0))
271	+	error(WARNING,
272	+	"-otV accuracy depends on -aa 0 -as 0");
273	+	break;
274		case 'l': /* effective distance */
275		*table++ = oputl;
276		castonly = 0;
#	Line 287 \| Line 299 \| *setoutput( / set up output tables /*
299		break;
300		case 'W': /* coefficient */
301		*table++ = oputW;
302	<	if (ambounce > 0 && (ambacc > FTINY \|\| ambssamp > 0))
302	>	castonly = 0;
303	>	if (ambounce > 0 && (ambacc > FTINY) \| (ambssamp > 0))
304		error(WARNING,
305		"-otW accuracy depends on -aa 0 -as 0");
306		break;
#	Line 302 \| Line 315 \| *setoutput( / set up output tables /*
315		break;
316		}
317		*table = NULL;
318	+	/* compatibility */
319	+	for (table = ray_out; *table != NULL; table++) {
320	+	if ((table == oputV) \| (table == oputW))
321	+	error(WARNING, "-oVW options require trace mode");
322	+	if ((do_irrad \| imm_irrad) &&
323	+	(table == oputr) \| (table == oputR) \|
324	+	(table == oputx) \| (table == oputX))
325	+	error(WARNING, "-orRxX options incompatible with -I+ and -i+");
326	+	}
327		}
328
329
330		static void
331		bogusray(void) /* print out empty record */
332		{
311	–	thisray.rorg[0] = thisray.rorg[1] = thisray.rorg[2] =
312	–	thisray.rdir[0] = thisray.rdir[1] = thisray.rdir[2] = 0.0;
313	–	thisray.rmax = 0.0;
333		rayorigin(&thisray, PRIMARY, NULL, NULL);
334		printvals(&thisray);
335		}
336
337
338		static void
339	<	rad( /* compute and print ray value(s) */
340	<	FVECT org,
322	<	FVECT dir,
323	<	double dmax
339	>	raycast( /* compute first ray intersection only */
340	>	RAY *r
341		)
342		{
343	<	VCOPY(thisray.rorg, org);
344	<	VCOPY(thisray.rdir, dir);
345	<	thisray.rmax = dmax;
346	<	rayorigin(&thisray, PRIMARY, NULL, NULL);
347	<	if (castonly) {
348	<	if (!localhit(&thisray, &thescene)) {
349	<	if (thisray.ro == &Aftplane) { /* clipped */
333	<	thisray.ro = NULL;
334	<	thisray.rot = FHUGE;
335	<	} else
336	<	sourcehit(&thisray);
337	<	}
338	<	} else
339	<	rayvalue(&thisray);
340	<	printvals(&thisray);
343	>	if (!localhit(r, &thescene)) {
344	>	if (r->ro == &Aftplane) { /* clipped */
345	>	r->ro = NULL;
346	>	r->rot = FHUGE;
347	>	} else
348	>	sourcehit(r);
349	>	}
350		}
351
352
353		static void
354	<	irrad( /* compute immediate irradiance value */
355	<	FVECT org,
347	<	FVECT dir
354	>	rayirrad( /* compute irradiance rather than radiance */
355	>	RAY *r
356		)
357		{
358	<	register int i;
358	>	void (old_revf)(RAY ) = r->revf;
359	>	/* pretend we hit surface */
360	>	r->rxt = r->rot = 1e-5;
361	>	VSUM(r->rop, r->rorg, r->rdir, r->rot);
362	>	r->ron[0] = -r->rdir[0];
363	>	r->ron[1] = -r->rdir[1];
364	>	r->ron[2] = -r->rdir[2];
365	>	r->rod = 1.0;
366	>	/* compute result */
367	>	r->revf = raytrace;
368	>	(*ofun[Lamb.otype].funp)(&Lamb, r);
369	>	r->revf = old_revf;
370	>	}
371
372	<	for (i = 0; i < 3; i++) {
373	<	thisray.rorg[i] = org[i] + dir[i];
374	<	thisray.rdir[i] = -dir[i];
375	<	}
376	<	thisray.rmax = 0.0;
372	>
373	>	static void
374	>	rtcompute( /* compute and print ray value(s) */
375	>	FVECT org,
376	>	FVECT dir,
377	>	double dmax
378	>	)
379	>	{
380	>	/* set up ray */
381		rayorigin(&thisray, PRIMARY, NULL, NULL);
382	<	/* pretend we hit surface */
383	<	thisray.rot = 1.0-1e-4;
384	<	thisray.rod = 1.0;
385	<	VCOPY(thisray.ron, dir);
386	<	for (i = 0; i < 3; i++) /* fudge factor */
387	<	thisray.rop[i] = org[i] + 1e-4*dir[i];
388	<	/* compute and print */
389	<	(*ofun[Lamb.otype].funp)(&Lamb, &thisray);
382	>	if (imm_irrad) {
383	>	VSUM(thisray.rorg, org, dir, 1.1e-4);
384	>	thisray.rdir[0] = -dir[0];
385	>	thisray.rdir[1] = -dir[1];
386	>	thisray.rdir[2] = -dir[2];
387	>	thisray.rmax = 0.0;
388	>	thisray.revf = rayirrad;
389	>	} else {
390	>	VCOPY(thisray.rorg, org);
391	>	VCOPY(thisray.rdir, dir);
392	>	thisray.rmax = dmax;
393	>	if (castonly)
394	>	thisray.revf = raycast;
395	>	}
396	>	if (ray_pnprocs > 1) { /* multiprocessing FIFO? */
397	>	if (ray_fifo_in(&thisray) < 0)
398	>	error(USER, "lost children");
399	>	return;
400	>	}
401	>	samplendx++; /* else do it ourselves */
402	>	rayvalue(&thisray);
403		printvals(&thisray);
404		}
405
406
407	<	static void
407	>	static int
408		printvals( /* print requested ray values */
409		RAY *r
410		)
411		{
412	<	register oputf_t **tp;
412	>	oputf_t **tp;
413
414		if (ray_out[0] == NULL)
415	<	return;
415	>	return(0);
416		for (tp = ray_out; *tp != NULL; tp++)
417		(**tp)(r);
418		if (outform == 'a')
419		putchar('\n');
420	+	return(1);
421		}
422
423
424		static int
425		getvec( /* get a vector from fp */
426	<	register FVECT vec,
426	>	FVECT vec,
427		int fmt,
428		FILE *fp
429		)
#	Line 393 \| Line 431 \| *getvec( / get a vector from fp /*
431		static float vf[3];
432		static double vd[3];
433		char buf[32];
434	<	register int i;
434	>	int i;
435
436		switch (fmt) {
437		case 'a': /* ascii */
#	Line 405 \| Line 443 \| *getvec( / get a vector from fp /*
443		}
444		break;
445		case 'f': /* binary float */
446	<	if (fread((char *)vf, sizeof(float), 3, fp) != 3)
446	>	if (getbinary(vf, sizeof(float), 3, fp) != 3)
447		return(-1);
448	<	vec[0] = vf[0]; vec[1] = vf[1]; vec[2] = vf[2];
448	>	VCOPY(vec, vf);
449		break;
450		case 'd': /* binary double */
451	<	if (fread((char *)vd, sizeof(double), 3, fp) != 3)
451	>	if (getbinary(vd, sizeof(double), 3, fp) != 3)
452		return(-1);
453	<	vec[0] = vd[0]; vec[1] = vd[1]; vec[2] = vd[2];
453	>	VCOPY(vec, vd);
454		break;
455		default:
456		error(CONSISTENCY, "botched input format");
#	Line 421 \| Line 459 \| *getvec( / get a vector from fp /*
459		}
460
461
462	<	static void
462	>	void
463		tranotify( /* record new modifier */
464		OBJECT obj
465		)
466		{
467		static int hitlimit = 0;
468	<	register OBJREC *o = objptr(obj);
469	<	register char **tralp;
468	>	OBJREC *o = objptr(obj);
469	>	char **tralp;
470
471		if (obj == OVOID) { /* starting over */
472		traset[0] = 0;
#	Line 455 \| Line 493 \| *ourtrace( / print ray values /*
493		RAY *r
494		)
495		{
496	<	register oputf_t **tp;
496	>	oputf_t **tp;
497
498		if (every_out[0] == NULL)
499		return;
#	Line 489 \| Line 527 \| *oputo( / print origin /*
527		RAY *r
528		)
529		{
530	<	(*putreal)(r->rorg[0]);
493	<	(*putreal)(r->rorg[1]);
494	<	(*putreal)(r->rorg[2]);
530	>	(*putreal)(r->rorg, 3);
531		}
532
533
#	Line 500 \| Line 536 \| *oputd( / print direction /*
536		RAY *r
537		)
538		{
539	<	(*putreal)(r->rdir[0]);
504	<	(*putreal)(r->rdir[1]);
505	<	(*putreal)(r->rdir[2]);
539	>	(*putreal)(r->rdir, 3);
540		}
541
542
543		static void
544	+	oputr( /* print mirrored contribution */
545	+	RAY *r
546	+	)
547	+	{
548	+	RREAL cval[3];
549	+
550	+	cval[0] = colval(r->mcol,RED);
551	+	cval[1] = colval(r->mcol,GRN);
552	+	cval[2] = colval(r->mcol,BLU);
553	+	(*putreal)(cval, 3);
554	+	}
555	+
556	+
557	+
558	+	static void
559	+	oputR( /* print mirrored distance */
560	+	RAY *r
561	+	)
562	+	{
563	+	(*putreal)(&r->rmt, 1);
564	+	}
565	+
566	+
567	+	static void
568	+	oputx( /* print unmirrored contribution */
569	+	RAY *r
570	+	)
571	+	{
572	+	RREAL cval[3];
573	+
574	+	cval[0] = colval(r->rcol,RED) - colval(r->mcol,RED);
575	+	cval[1] = colval(r->rcol,GRN) - colval(r->mcol,GRN);
576	+	cval[2] = colval(r->rcol,BLU) - colval(r->mcol,BLU);
577	+	(*putreal)(cval, 3);
578	+	}
579	+
580	+
581	+	static void
582	+	oputX( /* print unmirrored distance */
583	+	RAY *r
584	+	)
585	+	{
586	+	(*putreal)(&r->rxt, 1);
587	+	}
588	+
589	+
590	+	static void
591		oputv( /* print value */
592		RAY *r
593		)
594		{
595	<	if (outform == 'c') {
596	<	COLR cout;
597	<	setcolr(cout, colval(r->rcol,RED),
598	<	colval(r->rcol,GRN),
599	<	colval(r->rcol,BLU));
600	<	fwrite((char *)cout, sizeof(cout), 1, stdout);
520	<	return;
521	<	}
522	<	(*putreal)(colval(r->rcol,RED));
523	<	(*putreal)(colval(r->rcol,GRN));
524	<	(*putreal)(colval(r->rcol,BLU));
595	>	RREAL cval[3];
596	>
597	>	cval[0] = colval(r->rcol,RED);
598	>	cval[1] = colval(r->rcol,GRN);
599	>	cval[2] = colval(r->rcol,BLU);
600	>	(*putreal)(cval, 3);
601		}
602
603
604		static void
605	+	oputV( /* print value contribution */
606	+	RAY *r
607	+	)
608	+	{
609	+	RREAL contr[3];
610	+
611	+	raycontrib(contr, r, PRIMARY);
612	+	multcolor(contr, r->rcol);
613	+	(*putreal)(contr, 3);
614	+	}
615	+
616	+
617	+	static void
618		oputl( /* print effective distance */
619		RAY *r
620		)
621		{
622	<	(*putreal)(r->rt);
622	>	RREAL d = raydistance(r);
623	>
624	>	(*putreal)(&d, 1);
625		}
626
627
#	Line 539 \| Line 630 \| *oputL( / print single ray length /*
630		RAY *r
631		)
632		{
633	<	(*putreal)(r->rot);
633	>	(*putreal)(&r->rot, 1);
634		}
635
636
#	Line 548 \| Line 639 \| *oputc( / print local coordinates /*
639		RAY *r
640		)
641		{
642	<	(*putreal)(r->uv[0]);
552	<	(*putreal)(r->uv[1]);
642	>	(*putreal)(r->uv, 2);
643		}
644
645
646	+	static RREAL vdummy[3] = {0.0, 0.0, 0.0};
647	+
648	+
649		static void
650		oputp( /* print point */
651		RAY *r
652		)
653		{
654	<	if (r->rot < FHUGE) {
655	<	(*putreal)(r->rop[0]);
656	<	(*putreal)(r->rop[1]);
657	<	(*putreal)(r->rop[2]);
565	<	} else {
566	<	(*putreal)(0.0);
567	<	(*putreal)(0.0);
568	<	(*putreal)(0.0);
569	<	}
654	>	if (r->rot < FHUGE)
655	>	(*putreal)(r->rop, 3);
656	>	else
657	>	(*putreal)(vdummy, 3);
658		}
659
660
#	Line 576 \| Line 664 \| *oputN( / print unperturbed normal /*
664		)
665		{
666		if (r->rot < FHUGE) {
667	<	(*putreal)(r->ron[0]);
668	<	(*putreal)(r->ron[1]);
669	<	(*putreal)(r->ron[2]);
670	<	} else {
671	<	(*putreal)(0.0);
672	<	(*putreal)(0.0);
673	<	(*putreal)(0.0);
674	<	}
667	>	if (r->rflips & 1) { /* undo any flippin' flips */
668	>	FVECT unrm;
669	>	unrm[0] = -r->ron[0];
670	>	unrm[1] = -r->ron[1];
671	>	unrm[2] = -r->ron[2];
672	>	(*putreal)(unrm, 3);
673	>	} else
674	>	(*putreal)(r->ron, 3);
675	>	} else
676	>	(*putreal)(vdummy, 3);
677		}
678
679
#	Line 595 \| Line 685 \| *oputn( / print perturbed normal /*
685		FVECT pnorm;
686
687		if (r->rot >= FHUGE) {
688	<	(*putreal)(0.0);
599	<	(*putreal)(0.0);
600	<	(*putreal)(0.0);
688	>	(*putreal)(vdummy, 3);
689		return;
690		}
691		raynormal(pnorm, r);
692	<	(*putreal)(pnorm[0]);
605	<	(*putreal)(pnorm[1]);
606	<	(*putreal)(pnorm[2]);
692	>	(*putreal)(pnorm, 3);
693		}
694
695
#	Line 625 \| Line 711 \| *oputw( / print weight /*
711		RAY *r
712		)
713		{
714	<	(*putreal)(r->rweight);
714	>	RREAL rwt = r->rweight;
715	>
716	>	(*putreal)(&rwt, 1);
717		}
718
719
720		static void
721	<	oputW( /* print contribution */
721	>	oputW( /* print coefficient */
722		RAY *r
723		)
724		{
725	<	COLOR contr;
725	>	RREAL contr[3];
726	>	/* shadow ray not on source? */
727	>	if (r->rsrc >= 0 && source[r->rsrc].so != r->ro)
728	>	setcolor(contr, 0.0, 0.0, 0.0);
729	>	else
730	>	raycontrib(contr, r, PRIMARY);
731
732	<	raycontrib(contr, r, PRIMARY);
640	<	(*putreal)(colval(contr,RED));
641	<	(*putreal)(colval(contr,GRN));
642	<	(*putreal)(colval(contr,BLU));
732	>	(*putreal)(contr, 3);
733		}
734
735
#	Line 687 \| Line 777 \| *oputtilde( / output tilde (spacer) /*
777
778
779		static void
780	<	puta( /* print ascii value */
781	<	double v
780	>	puta( /* print ascii value(s) */
781	>	RREAL *v, int n
782		)
783		{
784	<	printf("%e\t", v);
784	>	if (n == 3) {
785	>	printf("%e\t%e\t%e\t", v[0], v[1], v[2]);
786	>	return;
787	>	}
788	>	while (n--)
789	>	printf("%e\t", *v++);
790		}
791
792
793		static void
794	<	putd(v) /* print binary double */
700	<	double v;
794	>	putd(RREAL v, int n) / output binary double(s) */
795		{
796	<	fwrite((char *)&v, sizeof(v), 1, stdout);
796	>	#ifdef SMLFLT
797	>	double da[3];
798	>	int i;
799	>
800	>	if (n > 3)
801	>	error(INTERNAL, "code error in putd()");
802	>	for (i = n; i--; )
803	>	da[i] = v[i];
804	>	putbinary(da, sizeof(double), n, stdout);
805	>	#else
806	>	putbinary(v, sizeof(RREAL), n, stdout);
807	>	#endif
808		}
809
810
811		static void
812	<	putf(v) /* print binary float */
708	<	double v;
812	>	putf(RREAL v, int n) / output binary float(s) */
813		{
814	<	float f = v;
814	>	#ifndef SMLFLT
815	>	float fa[3];
816	>	int i;
817
818	<	fwrite((char *)&f, sizeof(f), 1, stdout);
818	>	if (n > 3)
819	>	error(INTERNAL, "code error in putf()");
820	>	for (i = n; i--; )
821	>	fa[i] = v[i];
822	>	putbinary(fa, sizeof(float), n, stdout);
823	>	#else
824	>	putbinary(v, sizeof(RREAL), n, stdout);
825	>	#endif
826	>	}
827	>
828	>
829	>	static void
830	>	putrgbe(RREAL v, int n) / output RGBE color */
831	>	{
832	>	COLR cout;
833	>
834	>	if (n != 3)
835	>	error(INTERNAL, "putrgbe() not called with 3 components");
836	>	setcolr(cout, v[0], v[1], v[2]);
837	>	putbinary(cout, sizeof(cout), 1, stdout);
838		}

Diff Legend

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

Comparing ray/src/rt/rtrace.c (file contents): Revision 2.45 by greg, Fri Jun 10 16:49:42 2005 UTC vs. Revision 2.84 by greg, Wed Aug 14 22:33:02 2019 UTC

Diff Legend

Comparing ray/src/rt/rtrace.c (file contents):
Revision 2.45 by greg, Fri Jun 10 16:49:42 2005 UTC vs.
Revision 2.84 by greg, Wed Aug 14 22:33:02 2019 UTC