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

Comparing ray/src/rt/rtrace.c (file contents):
Revision 2.38 by greg, Fri Nov 5 17:36:56 2004 UTC vs.
Revision 2.79 by greg, Mon May 6 16:49:38 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,
62	<	oputp, oputn, oputN, oputs, oputw, oputm;
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 something2flush = 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	+	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;
#	Line 177 \| Line 152 \| *rtrace( / trace rays from file /*
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 188 \| 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 <= 0) {
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);
201	<	else
202	<	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 == 0) {
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 == 0) /* check for end */
194	>	if (vcount && !--vcount) /* check for end */
195		break;
196		}
197	<	fflush(stdout);
198	<	if (vcount > 0)
199	<	error(USER, "read error");
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)
207		fclose(fp);
208		}
209
210
211		static void
212	+	trace_sources(void) /* trace rays to light sources, also */
213	+	{
214	+	int sn;
215	+
216	+	for (sn = 0; sn < nsources; sn++)
217	+	source[sn].sflags \|= SFOLLOW;
218	+	}
219	+
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)
230		switch (*vs++) {
231	+	case 'T': /* trace sources */
232	+	if (!*vs) break;
233	+	trace_sources();
234	+	/* fall through */
235		case 't': /* trace */
236	+	if (!*vs) break;
237		*table = NULL;
238		table = every_out;
239		trace = ourtrace;
#	Line 241 \| 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 271 \| Line 298 \| *setoutput( / set up output tables /*
298		case 'w': /* weight */
299		*table++ = oputw;
300		break;
301	+	case 'W': /* coefficient */
302	+	*table++ = oputW;
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;
308		case 'm': /* modifier */
309		*table++ = oputm;
310		break;
311	+	case 'M': /* material */
312	+	*table++ = oputM;
313	+	break;
314	+	case '~': /* tilde */
315	+	*table++ = oputtilde;
316	+	break;
317		}
318		*table = NULL;
319		}
#	Line 282 \| Line 322 \| *setoutput( / set up output tables /*
322		static void
323		bogusray(void) /* print out empty record */
324		{
325	<	thisray.rorg[0] = thisray.rorg[1] = thisray.rorg[2] =
286	<	thisray.rdir[0] = thisray.rdir[1] = thisray.rdir[2] = 0.0;
287	<	rayorigin(&thisray, NULL, PRIMARY, 1.0);
325	>	rayorigin(&thisray, PRIMARY, NULL, NULL);
326		printvals(&thisray);
327		}
328
329
330		static void
331	<	rad( /* compute and print ray value(s) */
332	<	FVECT org,
295	<	FVECT dir,
296	<	double dmax
331	>	raycast( /* compute first ray intersection only */
332	>	RAY *r
333		)
334		{
335	<	VCOPY(thisray.rorg, org);
336	<	VCOPY(thisray.rdir, dir);
337	<	thisray.rmax = dmax;
338	<	rayorigin(&thisray, NULL, PRIMARY, 1.0);
339	<	if (castonly) {
340	<	if (!localhit(&thisray, &thescene)) {
341	<	if (thisray.ro == &Aftplane) { /* clipped */
306	<	thisray.ro = NULL;
307	<	thisray.rot = FHUGE;
308	<	} else
309	<	sourcehit(&thisray);
310	<	}
311	<	} else
312	<	rayvalue(&thisray);
313	<	printvals(&thisray);
335	>	if (!localhit(r, &thescene)) {
336	>	if (r->ro == &Aftplane) { /* clipped */
337	>	r->ro = NULL;
338	>	r->rot = FHUGE;
339	>	} else
340	>	sourcehit(r);
341	>	}
342		}
343
344
345		static void
346	<	irrad( /* compute immediate irradiance value */
347	<	FVECT org,
320	<	FVECT dir
346	>	rayirrad( /* compute irradiance rather than radiance */
347	>	RAY *r
348		)
349		{
350	<	register int i;
350	>	void (old_revf)(RAY ) = r->revf;
351	>	/* pretend we hit surface */
352	>	r->rxt = r->rot = 1e-5;
353	>	VSUM(r->rop, r->rorg, r->rdir, r->rot);
354	>	r->ron[0] = -r->rdir[0];
355	>	r->ron[1] = -r->rdir[1];
356	>	r->ron[2] = -r->rdir[2];
357	>	r->rod = 1.0;
358	>	/* compute result */
359	>	r->revf = raytrace;
360	>	(*ofun[Lamb.otype].funp)(&Lamb, r);
361	>	r->revf = old_revf;
362	>	}
363
364	<	for (i = 0; i < 3; i++) {
365	<	thisray.rorg[i] = org[i] + dir[i];
366	<	thisray.rdir[i] = -dir[i];
364	>
365	>	static void
366	>	rtcompute( /* compute and print ray value(s) */
367	>	FVECT org,
368	>	FVECT dir,
369	>	double dmax
370	>	)
371	>	{
372	>	/* set up ray */
373	>	rayorigin(&thisray, PRIMARY, NULL, NULL);
374	>	if (imm_irrad) {
375	>	VSUM(thisray.rorg, org, dir, 1.1e-4);
376	>	thisray.rdir[0] = -dir[0];
377	>	thisray.rdir[1] = -dir[1];
378	>	thisray.rdir[2] = -dir[2];
379	>	thisray.rmax = 0.0;
380	>	thisray.revf = rayirrad;
381	>	} else {
382	>	VCOPY(thisray.rorg, org);
383	>	VCOPY(thisray.rdir, dir);
384	>	thisray.rmax = dmax;
385	>	if (castonly)
386	>	thisray.revf = raycast;
387		}
388	<	rayorigin(&thisray, NULL, PRIMARY, 1.0);
389	<	/* pretend we hit surface */
390	<	thisray.rot = 1.0-1e-4;
391	<	thisray.rod = 1.0;
392	<	VCOPY(thisray.ron, dir);
393	<	for (i = 0; i < 3; i++) /* fudge factor */
394	<	thisray.rop[i] = org[i] + 1e-4*dir[i];
336	<	/* compute and print */
337	<	(*ofun[Lamb.otype].funp)(&Lamb, &thisray);
388	>	if (ray_pnprocs > 1) { /* multiprocessing FIFO? */
389	>	if (ray_fifo_in(&thisray) < 0)
390	>	error(USER, "lost children");
391	>	return;
392	>	}
393	>	samplendx++; /* else do it ourselves */
394	>	rayvalue(&thisray);
395		printvals(&thisray);
396		}
397
398
399	<	static void
399	>	static int
400		printvals( /* print requested ray values */
401		RAY *r
402		)
403		{
404	<	register oputf_t **tp;
404	>	oputf_t **tp;
405
406		if (ray_out[0] == NULL)
407	<	return;
407	>	return(0);
408		for (tp = ray_out; *tp != NULL; tp++)
409		(**tp)(r);
410		if (outform == 'a')
411		putchar('\n');
412	+	return(1);
413		}
414
415
416		static int
417		getvec( /* get a vector from fp */
418	<	register FVECT vec,
418	>	FVECT vec,
419		int fmt,
420		FILE *fp
421		)
#	Line 365 \| Line 423 \| *getvec( / get a vector from fp /*
423		static float vf[3];
424		static double vd[3];
425		char buf[32];
426	<	register int i;
426	>	int i;
427
428		switch (fmt) {
429		case 'a': /* ascii */
#	Line 377 \| Line 435 \| *getvec( / get a vector from fp /*
435		}
436		break;
437		case 'f': /* binary float */
438	<	if (fread((char *)vf, sizeof(float), 3, fp) != 3)
438	>	if (getbinary(vf, sizeof(float), 3, fp) != 3)
439		return(-1);
440	<	vec[0] = vf[0]; vec[1] = vf[1]; vec[2] = vf[2];
440	>	VCOPY(vec, vf);
441		break;
442		case 'd': /* binary double */
443	<	if (fread((char *)vd, sizeof(double), 3, fp) != 3)
443	>	if (getbinary(vd, sizeof(double), 3, fp) != 3)
444		return(-1);
445	<	vec[0] = vd[0]; vec[1] = vd[1]; vec[2] = vd[2];
445	>	VCOPY(vec, vd);
446		break;
447		default:
448		error(CONSISTENCY, "botched input format");
#	Line 393 \| Line 451 \| *getvec( / get a vector from fp /*
451		}
452
453
454	<	static void
454	>	void
455		tranotify( /* record new modifier */
456		OBJECT obj
457		)
458		{
459		static int hitlimit = 0;
460	<	register OBJREC *o = objptr(obj);
461	<	register char **tralp;
460	>	OBJREC *o = objptr(obj);
461	>	char **tralp;
462
463		if (obj == OVOID) { /* starting over */
464		traset[0] = 0;
#	Line 427 \| Line 485 \| *ourtrace( / print ray values /*
485		RAY *r
486		)
487		{
488	<	register oputf_t **tp;
488	>	oputf_t **tp;
489
490		if (every_out[0] == NULL)
491		return;
#	Line 439 \| Line 497 \| *ourtrace( / print ray values /*
497		tabin(r);
498		for (tp = every_out; *tp != NULL; tp++)
499		(**tp)(r);
500	<	putchar('\n');
500	>	if (outform == 'a')
501	>	putchar('\n');
502		}
503
504
#	Line 448 \| Line 507 \| *tabin( / tab in appropriate amount /*
507		RAY *r
508		)
509		{
510	<	register RAY *rp;
510	>	const RAY *rp;
511
512		for (rp = r->parent; rp != NULL; rp = rp->parent)
513		putchar('\t');
#	Line 460 \| Line 519 \| *oputo( / print origin /*
519		RAY *r
520		)
521		{
522	<	(*putreal)(r->rorg[0]);
464	<	(*putreal)(r->rorg[1]);
465	<	(*putreal)(r->rorg[2]);
522	>	(*putreal)(r->rorg, 3);
523		}
524
525
#	Line 471 \| Line 528 \| *oputd( / print direction /*
528		RAY *r
529		)
530		{
531	<	(*putreal)(r->rdir[0]);
475	<	(*putreal)(r->rdir[1]);
476	<	(*putreal)(r->rdir[2]);
531	>	(*putreal)(r->rdir, 3);
532		}
533
534
535		static void
536	+	oputr( /* print mirrored contribution */
537	+	RAY *r
538	+	)
539	+	{
540	+	RREAL cval[3];
541	+
542	+	cval[0] = colval(r->mcol,RED);
543	+	cval[1] = colval(r->mcol,GRN);
544	+	cval[2] = colval(r->mcol,BLU);
545	+	(*putreal)(cval, 3);
546	+	}
547	+
548	+
549	+
550	+	static void
551	+	oputR( /* print mirrored distance */
552	+	RAY *r
553	+	)
554	+	{
555	+	(*putreal)(&r->rmt, 1);
556	+	}
557	+
558	+
559	+	static void
560	+	oputx( /* print unmirrored contribution */
561	+	RAY *r
562	+	)
563	+	{
564	+	RREAL cval[3];
565	+
566	+	cval[0] = colval(r->rcol,RED) - colval(r->mcol,RED);
567	+	cval[1] = colval(r->rcol,GRN) - colval(r->mcol,GRN);
568	+	cval[2] = colval(r->rcol,BLU) - colval(r->mcol,BLU);
569	+	(*putreal)(cval, 3);
570	+	}
571	+
572	+
573	+	static void
574	+	oputX( /* print unmirrored distance */
575	+	RAY *r
576	+	)
577	+	{
578	+	(*putreal)(&r->rxt, 1);
579	+	}
580	+
581	+
582	+	static void
583		oputv( /* print value */
584		RAY *r
585		)
586		{
587	<	COLR cout;
588	<
587	>	RREAL cval[3];
588	>
589		if (outform == 'c') {
590	+	COLR cout;
591		setcolr(cout, colval(r->rcol,RED),
592		colval(r->rcol,GRN),
593		colval(r->rcol,BLU));
594	<	fwrite((char *)cout, sizeof(cout), 1, stdout);
594	>	putbinary(cout, sizeof(cout), 1, stdout);
595		return;
596		}
597	<	(*putreal)(colval(r->rcol,RED));
598	<	(*putreal)(colval(r->rcol,GRN));
599	<	(*putreal)(colval(r->rcol,BLU));
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 511 \| 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 520 \| Line 639 \| *oputc( / print local coordinates /*
639		RAY *r
640		)
641		{
642	<	(*putreal)(r->uv[0]);
524	<	(*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]);
537	<	} else {
538	<	(*putreal)(0.0);
539	<	(*putreal)(0.0);
540	<	(*putreal)(0.0);
541	<	}
654	>	if (r->rot < FHUGE)
655	>	(*putreal)(r->rop, 3);
656	>	else
657	>	(*putreal)(vdummy, 3);
658		}
659
660
#	Line 547 \| Line 663 \| *oputN( / print unperturbed normal /*
663		RAY *r
664		)
665		{
666	<	if (r->rot < FHUGE) {
667	<	(*putreal)(r->ron[0]);
668	<	(*putreal)(r->ron[1]);
669	<	(*putreal)(r->ron[2]);
554	<	} else {
555	<	(*putreal)(0.0);
556	<	(*putreal)(0.0);
557	<	(*putreal)(0.0);
558	<	}
666	>	if (r->rot < FHUGE)
667	>	(*putreal)(r->ron, 3);
668	>	else
669	>	(*putreal)(vdummy, 3);
670		}
671
672
#	Line 567 \| Line 678 \| *oputn( / print perturbed normal /*
678		FVECT pnorm;
679
680		if (r->rot >= FHUGE) {
681	<	(*putreal)(0.0);
571	<	(*putreal)(0.0);
572	<	(*putreal)(0.0);
681	>	(*putreal)(vdummy, 3);
682		return;
683		}
684		raynormal(pnorm, r);
685	<	(*putreal)(pnorm[0]);
577	<	(*putreal)(pnorm[1]);
578	<	(*putreal)(pnorm[2]);
685	>	(*putreal)(pnorm, 3);
686		}
687
688
#	Line 597 \| Line 704 \| *oputw( / print weight /*
704		RAY *r
705		)
706		{
707	<	(*putreal)(r->rweight);
707	>	RREAL rwt = r->rweight;
708	>
709	>	(*putreal)(&rwt, 1);
710		}
711
712
713		static void
714	+	oputW( /* print coefficient */
715	+	RAY *r
716	+	)
717	+	{
718	+	RREAL contr[3];
719	+	/* shadow ray not on source? */
720	+	if (r->rsrc >= 0 && source[r->rsrc].so != r->ro)
721	+	setcolor(contr, 0.0, 0.0, 0.0);
722	+	else
723	+	raycontrib(contr, r, PRIMARY);
724	+
725	+	(*putreal)(contr, 3);
726	+	}
727	+
728	+
729	+	static void
730		oputm( /* print modifier */
731		RAY *r
732		)
#	Line 618 \| Line 743 \| *oputm( / print modifier /*
743
744
745		static void
746	<	puta( /* print ascii value */
747	<	double v
746	>	oputM( /* print material */
747	>	RAY *r
748		)
749		{
750	<	printf("%e\t", v);
750	>	OBJREC *mat;
751	>
752	>	if (r->ro != NULL) {
753	>	if ((mat = findmaterial(r->ro)) != NULL)
754	>	fputs(mat->oname, stdout);
755	>	else
756	>	fputs(VOIDID, stdout);
757	>	} else
758	>	putchar('*');
759	>	putchar('\t');
760		}
761
762
763		static void
764	<	putd(v) /* print binary double */
765	<	double v;
764	>	oputtilde( /* output tilde (spacer) */
765	>	RAY *r
766	>	)
767		{
768	<	fwrite((char *)&v, sizeof(v), 1, stdout);
768	>	fputs("~\t", stdout);
769		}
770
771
772		static void
773	<	putf(v) /* print binary float */
774	<	double v;
773	>	puta( /* print ascii value(s) */
774	>	RREAL *v, int n
775	>	)
776		{
777	<	float f = v;
777	>	if (n == 3) {
778	>	printf("%e\t%e\t%e\t", v[0], v[1], v[2]);
779	>	return;
780	>	}
781	>	while (n--)
782	>	printf("%e\t", *v++);
783	>	}
784
785	<	fwrite((char *)&f, sizeof(f), 1, stdout);
785	>
786	>	static void
787	>	putd(RREAL v, int n) / print binary double(s) */
788	>	{
789	>	#ifdef SMLFLT
790	>	double da[3];
791	>	int i;
792	>
793	>	if (n > 3)
794	>	error(INTERNAL, "code error in putd()");
795	>	for (i = n; i--; )
796	>	da[i] = v[i];
797	>	putbinary(da, sizeof(double), n, stdout);
798	>	#else
799	>	putbinary(v, sizeof(RREAL), n, stdout);
800	>	#endif
801	>	}
802	>
803	>
804	>	static void
805	>	putf(RREAL v, int n) / print binary float(s) */
806	>	{
807	>	#ifndef SMLFLT
808	>	float fa[3];
809	>	int i;
810	>
811	>	if (n > 3)
812	>	error(INTERNAL, "code error in putf()");
813	>	for (i = n; i--; )
814	>	fa[i] = v[i];
815	>	putbinary(fa, sizeof(float), n, stdout);
816	>	#else
817	>	putbinary(v, sizeof(RREAL), n, stdout);
818	>	#endif
819		}

Diff Legend

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

Comparing ray/src/rt/rtrace.c (file contents): Revision 2.38 by greg, Fri Nov 5 17:36:56 2004 UTC vs. Revision 2.79 by greg, Mon May 6 16:49:38 2019 UTC

Diff Legend

Comparing ray/src/rt/rtrace.c (file contents):
Revision 2.38 by greg, Fri Nov 5 17:36:56 2004 UTC vs.
Revision 2.79 by greg, Mon May 6 16:49:38 2019 UTC