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

Comparing ray/src/rt/rtrace.c (file contents):
Revision 2.46 by greg, Fri Jun 10 20:44:00 2005 UTC vs.
Revision 2.81 by greg, Thu Jul 4 01:25:07 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
49	–	void (trace)() = NULL; / trace call */
50	–
51	–	char tralist[128]; / list of modifers to trace (or no) */
52	–	int traincl = -1; /* include == 1, exclude == 0 */
50		#ifndef MAXTSET
51	<	#define MAXTSET 1024 /* maximum number in trace set */
51	>	#define MAXTSET 8191 /* maximum number in trace set */
52		#endif
53		OBJECT traset[MAXTSET+1]={0}; /* trace include/exclude set */
54
58	–	int hresolu = 0; /* horizontal (scan) size */
59	–	int vresolu = 0; /* vertical resolution */
60	–
61	–	double dstrsrc = 0.0; /* square source distribution */
62	–	double shadthresh = .03; /* shadow threshold */
63	–	double shadcert = .75; /* shadow certainty */
64	–	int directrelay = 2; /* number of source relays */
65	–	int vspretest = 512; /* virtual source pretest density */
66	–	int directvis = 1; /* sources visible? */
67	–	double srcsizerat = .2; /* maximum ratio source size/dist. */
68	–
69	–	COLOR cextinction = BLKCOLOR; /* global extinction coefficient */
70	–	COLOR salbedo = BLKCOLOR; /* global scattering albedo */
71	–	double seccg = 0.; /* global scattering eccentricity */
72	–	double ssampdist = 0.; /* scatter sampling distance */
73	–
74	–	double specthresh = .15; /* specular sampling threshold */
75	–	double specjitter = 1.; /* specular sampling jitter */
76	–
77	–	int backvis = 1; /* back face visibility */
78	–
79	–	int maxdepth = -10; /* maximum recursion depth */
80	–	double minweight = 2e-3; /* minimum ray weight */
81	–
82	–	char ambfile = NULL; / ambient file name */
83	–	COLOR ambval = BLKCOLOR; /* ambient value */
84	–	int ambvwt = 0; /* initial weight for ambient value */
85	–	double ambacc = 0.15; /* ambient accuracy */
86	–	int ambres = 256; /* ambient resolution */
87	–	int ambdiv = 1024; /* ambient divisions */
88	–	int ambssamp = 512; /* ambient super-samples */
89	–	int ambounce = 0; /* ambient bounces */
90	–	char amblist[AMBLLEN]; / ambient include/exclude list */
91	–	int ambincl = -1; /* include == 1, exclude == 0 */
92	–
93	–	static int castonly = 0;
94	–
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
117	–	void (*addobjnotify[])() = {ambnotify, tranotify, NULL};
79
119	–
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 147 \| 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 167 \| 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 189 \| 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);
202	<	else
203	<	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 232 \| 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 257 \| 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	+	castonly = 0;
271	+	if (ambounce > 0 && (ambacc > FTINY \|\| ambssamp > 0))
272	+	error(WARNING,
273	+	"-otV accuracy depends on -aa 0 -as 0");
274	+	break;
275		case 'l': /* effective distance */
276		*table++ = oputl;
277		castonly = 0;
#	Line 289 \| Line 300 \| *setoutput( / set up output tables /*
300		break;
301		case 'W': /* coefficient */
302		*table++ = oputW;
303	<	if (ambounce > 0 && (ambacc > FTINY \|\| ambssamp > 0))
303	>	castonly = 0;
304	>	if (ambounce > 0 && (ambacc > FTINY) \| (ambssamp > 0))
305		error(WARNING,
306		"-otW accuracy depends on -aa 0 -as 0");
307		break;
#	Line 304 \| Line 316 \| *setoutput( / set up output tables /*
316		break;
317		}
318		*table = NULL;
319	+	/* compatibility */
320	+	for (table = ray_out; *table != NULL; table++) {
321	+	if ((table == oputV) \| (table == oputW))
322	+	error(WARNING, "-oVW options require trace mode");
323	+	if ((do_irrad \| imm_irrad) &&
324	+	(table == oputr) \| (table == oputR) \|
325	+	(table == oputx) \| (table == oputX))
326	+	error(WARNING, "-orRxX options incompatible with -I+ and -i+");
327	+	}
328		}
329
330
331		static void
332		bogusray(void) /* print out empty record */
333		{
313	–	thisray.rorg[0] = thisray.rorg[1] = thisray.rorg[2] =
314	–	thisray.rdir[0] = thisray.rdir[1] = thisray.rdir[2] = 0.0;
315	–	thisray.rmax = 0.0;
334		rayorigin(&thisray, PRIMARY, NULL, NULL);
335		printvals(&thisray);
336		}
337
338
339		static void
340	<	rad( /* compute and print ray value(s) */
341	<	FVECT org,
324	<	FVECT dir,
325	<	double dmax
340	>	raycast( /* compute first ray intersection only */
341	>	RAY *r
342		)
343		{
344	<	VCOPY(thisray.rorg, org);
345	<	VCOPY(thisray.rdir, dir);
346	<	thisray.rmax = dmax;
347	<	rayorigin(&thisray, PRIMARY, NULL, NULL);
348	<	if (castonly) {
349	<	if (!localhit(&thisray, &thescene)) {
350	<	if (thisray.ro == &Aftplane) { /* clipped */
335	<	thisray.ro = NULL;
336	<	thisray.rot = FHUGE;
337	<	} else
338	<	sourcehit(&thisray);
339	<	}
340	<	} else
341	<	rayvalue(&thisray);
342	<	printvals(&thisray);
344	>	if (!localhit(r, &thescene)) {
345	>	if (r->ro == &Aftplane) { /* clipped */
346	>	r->ro = NULL;
347	>	r->rot = FHUGE;
348	>	} else
349	>	sourcehit(r);
350	>	}
351		}
352
353
354		static void
355	<	irrad( /* compute immediate irradiance value */
356	<	FVECT org,
349	<	FVECT dir
355	>	rayirrad( /* compute irradiance rather than radiance */
356	>	RAY *r
357		)
358		{
359	<	register int i;
359	>	void (old_revf)(RAY ) = r->revf;
360	>	/* pretend we hit surface */
361	>	r->rxt = r->rot = 1e-5;
362	>	VSUM(r->rop, r->rorg, r->rdir, r->rot);
363	>	r->ron[0] = -r->rdir[0];
364	>	r->ron[1] = -r->rdir[1];
365	>	r->ron[2] = -r->rdir[2];
366	>	r->rod = 1.0;
367	>	/* compute result */
368	>	r->revf = raytrace;
369	>	(*ofun[Lamb.otype].funp)(&Lamb, r);
370	>	r->revf = old_revf;
371	>	}
372
373	<	for (i = 0; i < 3; i++) {
374	<	thisray.rorg[i] = org[i] + dir[i];
375	<	thisray.rdir[i] = -dir[i];
376	<	}
377	<	thisray.rmax = 0.0;
373	>
374	>	static void
375	>	rtcompute( /* compute and print ray value(s) */
376	>	FVECT org,
377	>	FVECT dir,
378	>	double dmax
379	>	)
380	>	{
381	>	/* set up ray */
382		rayorigin(&thisray, PRIMARY, NULL, NULL);
383	<	/* pretend we hit surface */
384	<	thisray.rot = 1.0-1e-4;
385	<	thisray.rod = 1.0;
386	<	VCOPY(thisray.ron, dir);
387	<	for (i = 0; i < 3; i++) /* fudge factor */
388	<	thisray.rop[i] = org[i] + 1e-4*dir[i];
389	<	/* compute and print */
390	<	(*ofun[Lamb.otype].funp)(&Lamb, &thisray);
383	>	if (imm_irrad) {
384	>	VSUM(thisray.rorg, org, dir, 1.1e-4);
385	>	thisray.rdir[0] = -dir[0];
386	>	thisray.rdir[1] = -dir[1];
387	>	thisray.rdir[2] = -dir[2];
388	>	thisray.rmax = 0.0;
389	>	thisray.revf = rayirrad;
390	>	} else {
391	>	VCOPY(thisray.rorg, org);
392	>	VCOPY(thisray.rdir, dir);
393	>	thisray.rmax = dmax;
394	>	if (castonly)
395	>	thisray.revf = raycast;
396	>	}
397	>	if (ray_pnprocs > 1) { /* multiprocessing FIFO? */
398	>	if (ray_fifo_in(&thisray) < 0)
399	>	error(USER, "lost children");
400	>	return;
401	>	}
402	>	samplendx++; /* else do it ourselves */
403	>	rayvalue(&thisray);
404		printvals(&thisray);
405		}
406
407
408	<	static void
408	>	static int
409		printvals( /* print requested ray values */
410		RAY *r
411		)
412		{
413	<	register oputf_t **tp;
413	>	oputf_t **tp;
414
415		if (ray_out[0] == NULL)
416	<	return;
416	>	return(0);
417		for (tp = ray_out; *tp != NULL; tp++)
418		(**tp)(r);
419		if (outform == 'a')
420		putchar('\n');
421	+	return(1);
422		}
423
424
425		static int
426		getvec( /* get a vector from fp */
427	<	register FVECT vec,
427	>	FVECT vec,
428		int fmt,
429		FILE *fp
430		)
#	Line 395 \| Line 432 \| *getvec( / get a vector from fp /*
432		static float vf[3];
433		static double vd[3];
434		char buf[32];
435	<	register int i;
435	>	int i;
436
437		switch (fmt) {
438		case 'a': /* ascii */
#	Line 407 \| Line 444 \| *getvec( / get a vector from fp /*
444		}
445		break;
446		case 'f': /* binary float */
447	<	if (fread((char *)vf, sizeof(float), 3, fp) != 3)
447	>	if (getbinary(vf, sizeof(float), 3, fp) != 3)
448		return(-1);
449	<	vec[0] = vf[0]; vec[1] = vf[1]; vec[2] = vf[2];
449	>	VCOPY(vec, vf);
450		break;
451		case 'd': /* binary double */
452	<	if (fread((char *)vd, sizeof(double), 3, fp) != 3)
452	>	if (getbinary(vd, sizeof(double), 3, fp) != 3)
453		return(-1);
454	<	vec[0] = vd[0]; vec[1] = vd[1]; vec[2] = vd[2];
454	>	VCOPY(vec, vd);
455		break;
456		default:
457		error(CONSISTENCY, "botched input format");
#	Line 423 \| Line 460 \| *getvec( / get a vector from fp /*
460		}
461
462
463	<	static void
463	>	void
464		tranotify( /* record new modifier */
465		OBJECT obj
466		)
467		{
468		static int hitlimit = 0;
469	<	register OBJREC *o = objptr(obj);
470	<	register char **tralp;
469	>	OBJREC *o = objptr(obj);
470	>	char **tralp;
471
472		if (obj == OVOID) { /* starting over */
473		traset[0] = 0;
#	Line 457 \| Line 494 \| *ourtrace( / print ray values /*
494		RAY *r
495		)
496		{
497	<	register oputf_t **tp;
497	>	oputf_t **tp;
498
499		if (every_out[0] == NULL)
500		return;
#	Line 491 \| Line 528 \| *oputo( / print origin /*
528		RAY *r
529		)
530		{
531	<	(*putreal)(r->rorg[0]);
495	<	(*putreal)(r->rorg[1]);
496	<	(*putreal)(r->rorg[2]);
531	>	(*putreal)(r->rorg, 3);
532		}
533
534
#	Line 502 \| Line 537 \| *oputd( / print direction /*
537		RAY *r
538		)
539		{
540	<	(*putreal)(r->rdir[0]);
506	<	(*putreal)(r->rdir[1]);
507	<	(*putreal)(r->rdir[2]);
540	>	(*putreal)(r->rdir, 3);
541		}
542
543
544		static void
545	+	oputr( /* print mirrored contribution */
546	+	RAY *r
547	+	)
548	+	{
549	+	RREAL cval[3];
550	+
551	+	cval[0] = colval(r->mcol,RED);
552	+	cval[1] = colval(r->mcol,GRN);
553	+	cval[2] = colval(r->mcol,BLU);
554	+	(*putreal)(cval, 3);
555	+	}
556	+
557	+
558	+
559	+	static void
560	+	oputR( /* print mirrored distance */
561	+	RAY *r
562	+	)
563	+	{
564	+	(*putreal)(&r->rmt, 1);
565	+	}
566	+
567	+
568	+	static void
569	+	oputx( /* print unmirrored contribution */
570	+	RAY *r
571	+	)
572	+	{
573	+	RREAL cval[3];
574	+
575	+	cval[0] = colval(r->rcol,RED) - colval(r->mcol,RED);
576	+	cval[1] = colval(r->rcol,GRN) - colval(r->mcol,GRN);
577	+	cval[2] = colval(r->rcol,BLU) - colval(r->mcol,BLU);
578	+	(*putreal)(cval, 3);
579	+	}
580	+
581	+
582	+	static void
583	+	oputX( /* print unmirrored distance */
584	+	RAY *r
585	+	)
586	+	{
587	+	(*putreal)(&r->rxt, 1);
588	+	}
589	+
590	+
591	+	static void
592		oputv( /* print value */
593		RAY *r
594		)
595		{
596	<	if (outform == 'c') {
597	<	COLR cout;
598	<	setcolr(cout, colval(r->rcol,RED),
599	<	colval(r->rcol,GRN),
600	<	colval(r->rcol,BLU));
601	<	fwrite((char *)cout, sizeof(cout), 1, stdout);
522	<	return;
523	<	}
524	<	(*putreal)(colval(r->rcol,RED));
525	<	(*putreal)(colval(r->rcol,GRN));
526	<	(*putreal)(colval(r->rcol,BLU));
596	>	RREAL cval[3];
597	>
598	>	cval[0] = colval(r->rcol,RED);
599	>	cval[1] = colval(r->rcol,GRN);
600	>	cval[2] = colval(r->rcol,BLU);
601	>	(*putreal)(cval, 3);
602		}
603
604
605		static void
606	+	oputV( /* print value contribution */
607	+	RAY *r
608	+	)
609	+	{
610	+	RREAL contr[3];
611	+
612	+	raycontrib(contr, r, PRIMARY);
613	+	multcolor(contr, r->rcol);
614	+	(*putreal)(contr, 3);
615	+	}
616	+
617	+
618	+	static void
619		oputl( /* print effective distance */
620		RAY *r
621		)
622		{
623	<	(*putreal)(r->rt);
623	>	RREAL d = raydistance(r);
624	>
625	>	(*putreal)(&d, 1);
626		}
627
628
#	Line 541 \| Line 631 \| *oputL( / print single ray length /*
631		RAY *r
632		)
633		{
634	<	(*putreal)(r->rot);
634	>	(*putreal)(&r->rot, 1);
635		}
636
637
#	Line 550 \| Line 640 \| *oputc( / print local coordinates /*
640		RAY *r
641		)
642		{
643	<	(*putreal)(r->uv[0]);
554	<	(*putreal)(r->uv[1]);
643	>	(*putreal)(r->uv, 2);
644		}
645
646
647	+	static RREAL vdummy[3] = {0.0, 0.0, 0.0};
648	+
649	+
650		static void
651		oputp( /* print point */
652		RAY *r
653		)
654		{
655	<	if (r->rot < FHUGE) {
656	<	(*putreal)(r->rop[0]);
657	<	(*putreal)(r->rop[1]);
658	<	(*putreal)(r->rop[2]);
567	<	} else {
568	<	(*putreal)(0.0);
569	<	(*putreal)(0.0);
570	<	(*putreal)(0.0);
571	<	}
655	>	if (r->rot < FHUGE)
656	>	(*putreal)(r->rop, 3);
657	>	else
658	>	(*putreal)(vdummy, 3);
659		}
660
661
#	Line 577 \| Line 664 \| *oputN( / print unperturbed normal /*
664		RAY *r
665		)
666		{
667	<	if (r->rot < FHUGE) {
668	<	(*putreal)(r->ron[0]);
669	<	(*putreal)(r->ron[1]);
670	<	(*putreal)(r->ron[2]);
584	<	} else {
585	<	(*putreal)(0.0);
586	<	(*putreal)(0.0);
587	<	(*putreal)(0.0);
588	<	}
667	>	if (r->rot < FHUGE)
668	>	(*putreal)(r->ron, 3);
669	>	else
670	>	(*putreal)(vdummy, 3);
671		}
672
673
#	Line 597 \| Line 679 \| *oputn( / print perturbed normal /*
679		FVECT pnorm;
680
681		if (r->rot >= FHUGE) {
682	<	(*putreal)(0.0);
601	<	(*putreal)(0.0);
602	<	(*putreal)(0.0);
682	>	(*putreal)(vdummy, 3);
683		return;
684		}
685		raynormal(pnorm, r);
686	<	(*putreal)(pnorm[0]);
607	<	(*putreal)(pnorm[1]);
608	<	(*putreal)(pnorm[2]);
686	>	(*putreal)(pnorm, 3);
687		}
688
689
#	Line 627 \| Line 705 \| *oputw( / print weight /*
705		RAY *r
706		)
707		{
708	<	(*putreal)(r->rweight);
708	>	RREAL rwt = r->rweight;
709	>
710	>	(*putreal)(&rwt, 1);
711		}
712
713
714		static void
715	<	oputW( /* print contribution */
715	>	oputW( /* print coefficient */
716		RAY *r
717		)
718		{
719	<	COLOR contr;
719	>	RREAL contr[3];
720	>	/* shadow ray not on source? */
721	>	if (r->rsrc >= 0 && source[r->rsrc].so != r->ro)
722	>	setcolor(contr, 0.0, 0.0, 0.0);
723	>	else
724	>	raycontrib(contr, r, PRIMARY);
725
726	<	raycontrib(contr, r, PRIMARY);
642	<	(*putreal)(colval(contr,RED));
643	<	(*putreal)(colval(contr,GRN));
644	<	(*putreal)(colval(contr,BLU));
726	>	(*putreal)(contr, 3);
727		}
728
729
#	Line 689 \| Line 771 \| *oputtilde( / output tilde (spacer) /*
771
772
773		static void
774	<	puta( /* print ascii value */
775	<	double v
774	>	puta( /* print ascii value(s) */
775	>	RREAL *v, int n
776		)
777		{
778	<	printf("%e\t", v);
778	>	if (n == 3) {
779	>	printf("%e\t%e\t%e\t", v[0], v[1], v[2]);
780	>	return;
781	>	}
782	>	while (n--)
783	>	printf("%e\t", *v++);
784		}
785
786
787		static void
788	<	putd(v) /* print binary double */
702	<	double v;
788	>	putd(RREAL v, int n) / output binary double(s) */
789		{
790	<	fwrite((char *)&v, sizeof(v), 1, stdout);
790	>	#ifdef SMLFLT
791	>	double da[3];
792	>	int i;
793	>
794	>	if (n > 3)
795	>	error(INTERNAL, "code error in putd()");
796	>	for (i = n; i--; )
797	>	da[i] = v[i];
798	>	putbinary(da, sizeof(double), n, stdout);
799	>	#else
800	>	putbinary(v, sizeof(RREAL), n, stdout);
801	>	#endif
802		}
803
804
805		static void
806	<	putf(v) /* print binary float */
710	<	double v;
806	>	putf(RREAL v, int n) / output binary float(s) */
807		{
808	<	float f = v;
808	>	#ifndef SMLFLT
809	>	float fa[3];
810	>	int i;
811
812	<	fwrite((char *)&f, sizeof(f), 1, stdout);
812	>	if (n > 3)
813	>	error(INTERNAL, "code error in putf()");
814	>	for (i = n; i--; )
815	>	fa[i] = v[i];
816	>	putbinary(fa, sizeof(float), n, stdout);
817	>	#else
818	>	putbinary(v, sizeof(RREAL), n, stdout);
819	>	#endif
820	>	}
821	>
822	>
823	>	static void
824	>	putrgbe(RREAL v, int n) / output RGBE color */
825	>	{
826	>	COLR cout;
827	>
828	>	if (n != 3)
829	>	error(INTERNAL, "putrgbe() not called with 3 components");
830	>	setcolr(cout, v[0], v[1], v[2]);
831	>	putbinary(cout, sizeof(cout), 1, stdout);
832		}

Diff Legend

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

Comparing ray/src/rt/rtrace.c (file contents): Revision 2.46 by greg, Fri Jun 10 20:44:00 2005 UTC vs. Revision 2.81 by greg, Thu Jul 4 01:25:07 2019 UTC

Diff Legend

Comparing ray/src/rt/rtrace.c (file contents):
Revision 2.46 by greg, Fri Jun 10 20:44:00 2005 UTC vs.
Revision 2.81 by greg, Thu Jul 4 01:25:07 2019 UTC