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

Comparing ray/src/rt/rtrace.c (file contents):
Revision 2.27 by greg, Sat Feb 22 02:07:29 2003 UTC vs.
Revision 2.64 by greg, Sun Sep 26 15:49:39 2010 UTC

#	Line 5 \| Line 5 \| static const char RCSid[] = "$Id$";
5		* rtrace.c - program and variables for individual ray tracing.
6		*/
7
8	<	/* ====================================================================
9	<	* The Radiance Software License, Version 1.0
10	<	*
11	<	* Copyright (c) 1990 - 2002 The Regents of the University of California,
12	<	* through Lawrence Berkeley National Laboratory. All rights reserved.
13	<	*
14	<	* Redistribution and use in source and binary forms, with or without
15	<	* modification, are permitted provided that the following conditions
16	<	* are met:
17	<	*
18	<	* 1. Redistributions of source code must retain the above copyright
19	<	* notice, this list of conditions and the following disclaimer.
20	<	*
21	<	* 2. Redistributions in binary form must reproduce the above copyright
22	<	* notice, this list of conditions and the following disclaimer in
23	<	* the documentation and/or other materials provided with the
24	<	* distribution.
25	<	*
26	<	* 3. The end-user documentation included with the redistribution,
27	<	* if any, must include the following acknowledgment:
28	<	* "This product includes Radiance software
29	<	* (http://radsite.lbl.gov/)
30	<	* developed by the Lawrence Berkeley National Laboratory
31	<	* (http://www.lbl.gov/)."
32	<	* Alternately, this acknowledgment may appear in the software itself,
33	<	* if and wherever such third-party acknowledgments normally appear.
34	<	*
35	<	* 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
36	<	* and "The Regents of the University of California" must
37	<	* not be used to endorse or promote products derived from this
38	<	* software without prior written permission. For written
39	<	* permission, please contact [email protected].
40	<	*
41	<	* 5. Products derived from this software may not be called "Radiance",
42	<	* nor may "Radiance" appear in their name, without prior written
43	<	* permission of Lawrence Berkeley National Laboratory.
44	<	*
45	<	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
46	<	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
47	<	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
48	<	* DISCLAIMED. IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
49	<	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
50	<	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
51	<	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
52	<	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
53	<	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
54	<	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
55	<	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56	<	* SUCH DAMAGE.
57	<	* ====================================================================
58	<	*
59	<	* This software consists of voluntary contributions made by many
60	<	* individuals on behalf of Lawrence Berkeley National Laboratory. For more
61	<	* information on Lawrence Berkeley National Laboratory, please see
62	<	* <http://www.lbl.gov/>.
63	<	*/
8	>	#include "copyright.h"
9
10		/*
11		* Input is in the form:
#	Line 76 \| Line 21 \| static const char RCSid[] = "$Id$";
21		* irradiance values are desired.
22		*/
23
24	<	#include "ray.h"
24	>	#include <time.h>
25
26	+	#include "platform.h"
27	+	#include "ray.h"
28	+	#include "ambient.h"
29	+	#include "source.h"
30		#include "otypes.h"
82	–
31		#include "resolu.h"
32	+	#include "random.h"
33
34	<	CUBE thescene; /* our scene */
35	<	OBJECT nsceneobjs; /* number of objects in our scene */
34	>	extern int inform; /* input format */
35	>	extern int outform; /* output format */
36	>	extern char outvals; / output values */
37
38	<	int dimlist[MAXDIM]; /* sampling dimensions */
39	<	int ndims = 0; /* number of sampling dimensions */
90	<	int samplendx = 0; /* index for this sample */
38	>	extern int imm_irrad; /* compute immediate irradiance? */
39	>	extern int lim_dist; /* limit distance? */
40
41	<	int imm_irrad = 0; /* compute immediate irradiance? */
42	<	int lim_dist = 0; /* limit distance? */
41	>	extern char tralist[]; / list of modifers to trace (or no) */
42	>	extern int traincl; /* include == 1, exclude == 0 */
43
44	<	int inform = 'a'; /* input format */
45	<	int outform = 'a'; /* output format */
97	<	char outvals = "v"; / output specification */
44	>	extern int hresolu; /* horizontal resolution */
45	>	extern int vresolu; /* vertical resolution */
46
47	<	int do_irrad = 0; /* compute irradiance? */
47	>	static int castonly = 0;
48
49	<	void (trace)() = NULL; / trace call */
50	<
51	<	extern void ambnotify(), tranotify();
104	<	void (*addobjnotify[])() = {ambnotify, tranotify, NULL};
105	<	char tralist[128]; / list of modifers to trace (or no) */
106	<	int traincl = -1; /* include == 1, exclude == 0 */
107	<	#define MAXTSET 511 /* maximum number in trace set */
49	>	#ifndef MAXTSET
50	>	#define MAXTSET 8191 /* maximum number in trace set */
51	>	#endif
52		OBJECT traset[MAXTSET+1]={0}; /* trace include/exclude set */
53
110	–	int hresolu = 0; /* horizontal (scan) size */
111	–	int vresolu = 0; /* vertical resolution */
112	–
113	–	double dstrsrc = 0.0; /* square source distribution */
114	–	double shadthresh = .05; /* shadow threshold */
115	–	double shadcert = .5; /* shadow certainty */
116	–	int directrelay = 2; /* number of source relays */
117	–	int vspretest = 512; /* virtual source pretest density */
118	–	int directvis = 1; /* sources visible? */
119	–	double srcsizerat = .2; /* maximum ratio source size/dist. */
120	–
121	–	COLOR cextinction = BLKCOLOR; /* global extinction coefficient */
122	–	COLOR salbedo = BLKCOLOR; /* global scattering albedo */
123	–	double seccg = 0.; /* global scattering eccentricity */
124	–	double ssampdist = 0.; /* scatter sampling distance */
125	–
126	–	double specthresh = .15; /* specular sampling threshold */
127	–	double specjitter = 1.; /* specular sampling jitter */
128	–
129	–	int backvis = 1; /* back face visibility */
130	–
131	–	int maxdepth = 6; /* maximum recursion depth */
132	–	double minweight = 4e-3; /* minimum ray weight */
133	–
134	–	char ambfile = NULL; / ambient file name */
135	–	COLOR ambval = BLKCOLOR; /* ambient value */
136	–	int ambvwt = 0; /* initial weight for ambient value */
137	–	double ambacc = 0.2; /* ambient accuracy */
138	–	int ambres = 128; /* ambient resolution */
139	–	int ambdiv = 512; /* ambient divisions */
140	–	int ambssamp = 0; /* ambient super-samples */
141	–	int ambounce = 0; /* ambient bounces */
142	–	char amblist[128]; / ambient include/exclude list */
143	–	int ambincl = -1; /* include == 1, exclude == 0 */
144	–
145	–
54		static RAY thisray; /* for our convenience */
55
56	<	static void oputo(), oputd(), oputv(), oputl(), oputL(),
57	<	oputp(), oputn(), oputN(), oputs(), oputw(), oputm();
56	>	typedef void putf_t(double v);
57	>	static putf_t puta, putd, putf;
58
59	<	static void ourtrace(), tabin();
60	<	static void (ray_out[16])(), (every_out[16])();
61	<	static int castonly = 0;
59	>	typedef void oputf_t(RAY *r);
60	>	static oputf_t oputo, oputd, oputv, oputV, oputl, oputL, oputc, oputp,
61	>	oputn, oputN, oputs, oputw, oputW, oputm, oputM, oputtilde;
62
63	<	static void puta(), putf(), putd();
63	>	static void setoutput(char *vs);
64	>	extern void tranotify(OBJECT obj);
65	>	static void bogusray(void);
66	>	static void raycast(RAY *r);
67	>	static void rayirrad(RAY *r);
68	>	static void rtcompute(FVECT org, FVECT dir, double dmax);
69	>	static int printvals(RAY *r);
70	>	static int getvec(FVECT vec, int fmt, FILE *fp);
71	>	static void tabin(RAY *r);
72	>	static void ourtrace(RAY *r);
73
74	<	static void (*putreal)();
74	>	static oputf_t ray_out[16], every_out[16];
75	>	static putf_t *putreal;
76
159	–	void bogusray(), rad(), irrad(), printvals();
77
161	–
78		void
79	<	quit(code) /* quit program */
80	<	int code;
79	>	quit( /* quit program */
80	>	int code
81	>	)
82		{
83	<	#ifndef NIX
84	<	headclean(); /* delete header file */
85	<	pfclean(); /* clean up persist files */
83	>	if (ray_pnprocs > 0) /* close children if any */
84	>	ray_pclose(0);
85	>	#ifndef NON_POSIX
86	>	else if (!ray_pnprocs) {
87	>	headclean(); /* delete header file */
88	>	pfclean(); /* clean up persist files */
89	>	}
90		#endif
91		exit(code);
92		}
93
94
95		char *
96	<	formstr(f) /* return format identifier */
97	<	int f;
96	>	formstr( /* return format identifier */
97	>	int f
98	>	)
99		{
100		switch (f) {
101		case 'a': return("ascii");
#	Line 185 \| Line 107 \| int f;
107		}
108
109
110	<	void
111	<	rtrace(fname) /* trace rays from file */
112	<	char *fname;
110	>	extern void
111	>	rtrace( /* trace rays from file */
112	>	char *fname,
113	>	int nproc
114	>	)
115		{
116	<	long vcount = hresolu>1 ? hresolu*vresolu : vresolu;
117	<	long nextflush = hresolu;
116	>	unsigned long vcount = (hresolu > 1) ? (unsigned long)hresolu*vresolu
117	>	: vresolu;
118	>	long nextflush = (vresolu > 0) & (hresolu > 1) ? 0 : hresolu;
119		FILE *fp;
120		double d;
121		FVECT orig, direc;
#	Line 201 \| Line 126 \| *char fname;**
126		sprintf(errmsg, "cannot open input file \"%s\"", fname);
127		error(SYSTEM, errmsg);
128		}
204	–	#ifdef MSDOS
129		if (inform != 'a')
130	<	setmode(fileno(fp), O_BINARY);
207	<	#endif
130	>	SET_FILE_BINARY(fp);
131		/* set up output */
132		setoutput(outvals);
133	+	if (imm_irrad)
134	+	castonly = 0;
135	+	else if (castonly)
136	+	nproc = 1; /* don't bother multiprocessing */
137		switch (outform) {
138		case 'a': putreal = puta; break;
139		case 'f': putreal = putf; break;
#	Line 218 \| Line 145 \| *char fname;**
145		default:
146		error(CONSISTENCY, "botched output format");
147		}
148	+	if (nproc > 1) { /* start multiprocessing */
149	+	ray_popen(nproc);
150	+	ray_fifo_out = printvals;
151	+	}
152		if (hresolu > 0) {
153		if (vresolu > 0)
154		fprtresolu(hresolu, vresolu, stdout);
#	Line 229 \| Line 160 \| *char fname;**
160
161		d = normalize(direc);
162		if (d == 0.0) { /* zero ==> flush */
163	<	bogusray();
164	<	if (--nextflush <= 0 \|\| vcount <= 0) {
163	>	if (--nextflush <= 0 \|\| !vcount) {
164	>	if (nproc > 1 && ray_fifo_flush() < 0)
165	>	error(USER, "lost children");
166	>	bogusray();
167		fflush(stdout);
168	<	nextflush = hresolu;
169	<	}
170	<	} else {
171	<	samplendx++;
172	<	/* compute and print */
173	<	if (imm_irrad)
241	<	irrad(orig, direc);
242	<	else
243	<	rad(orig, direc, lim_dist ? d : 0.0);
168	>	nextflush = (vresolu > 0) & (hresolu > 1) ? 0 :
169	>	hresolu;
170	>	} else
171	>	bogusray();
172	>	} else { /* compute and print */
173	>	rtcompute(orig, direc, lim_dist ? d : 0.0);
174		/* flush if time */
175	<	if (--nextflush == 0) {
175	>	if (!--nextflush) {
176	>	if (nproc > 1 && ray_fifo_flush() < 0)
177	>	error(USER, "lost children");
178		fflush(stdout);
179		nextflush = hresolu;
180		}
181		}
182		if (ferror(stdout))
183		error(SYSTEM, "write error");
184	<	if (--vcount == 0) /* check for end */
184	>	if (vcount && !--vcount) /* check for end */
185		break;
186		}
187	<	fflush(stdout);
188	<	if (vcount > 0)
189	<	error(USER, "read error");
187	>	if (nproc > 1) { /* clean up children */
188	>	if (ray_fifo_flush() < 0)
189	>	error(USER, "unable to complete processing");
190	>	ray_pclose(0);
191	>	}
192	>	if (fflush(stdout) < 0)
193	>	error(SYSTEM, "write error");
194	>	if (vcount)
195	>	error(USER, "unexpected EOF on input");
196		if (fname != NULL)
197		fclose(fp);
198		}
199
200
201	<	setoutput(vs) /* set up output tables */
202	<	register char *vs;
201	>	static void
202	>	trace_sources(void) /* trace rays to light sources, also */
203		{
204	<	extern void (*trace)();
205	<	register void (**table)() = ray_out;
204	>	int sn;
205	>
206	>	for (sn = 0; sn < nsources; sn++)
207	>	source[sn].sflags \|= SFOLLOW;
208	>	}
209
210	+
211	+	static void
212	+	setoutput( /* set up output tables */
213	+	char *vs
214	+	)
215	+	{
216	+	oputf_t **table = ray_out;
217	+
218		castonly = 1;
219		while (*vs)
220		switch (*vs++) {
221	+	case 'T': /* trace sources */
222	+	if (!*vs) break;
223	+	trace_sources();
224	+	/* fall through */
225		case 't': /* trace */
226	+	if (!*vs) break;
227		*table = NULL;
228		table = every_out;
229		trace = ourtrace;
#	Line 285 \| Line 239 \| *register char vs;**
239		*table++ = oputv;
240		castonly = 0;
241		break;
242	+	case 'V': /* contribution */
243	+	*table++ = oputV;
244	+	if (ambounce > 0 && (ambacc > FTINY \|\| ambssamp > 0))
245	+	error(WARNING,
246	+	"-otV accuracy depends on -aa 0 -as 0");
247	+	break;
248		case 'l': /* effective distance */
249		*table++ = oputl;
250		castonly = 0;
251		break;
252	+	case 'c': /* local coordinates */
253	+	*table++ = oputc;
254	+	break;
255		case 'L': /* single ray length */
256		*table++ = oputL;
257		break;
#	Line 308 \| Line 271 \| *register char vs;**
271		case 'w': /* weight */
272		*table++ = oputw;
273		break;
274	+	case 'W': /* coefficient */
275	+	*table++ = oputW;
276	+	if (ambounce > 0 && (ambacc > FTINY \|\| ambssamp > 0))
277	+	error(WARNING,
278	+	"-otW accuracy depends on -aa 0 -as 0");
279	+	break;
280		case 'm': /* modifier */
281		*table++ = oputm;
282		break;
283	+	case 'M': /* material */
284	+	*table++ = oputM;
285	+	break;
286	+	case '~': /* tilde */
287	+	*table++ = oputtilde;
288	+	break;
289		}
290		*table = NULL;
291		}
292
293
294	<	void
295	<	bogusray() /* print out empty record */
294	>	static void
295	>	bogusray(void) /* print out empty record */
296		{
297		thisray.rorg[0] = thisray.rorg[1] = thisray.rorg[2] =
298		thisray.rdir[0] = thisray.rdir[1] = thisray.rdir[2] = 0.0;
299	<	rayorigin(&thisray, NULL, PRIMARY, 1.0);
299	>	thisray.rmax = 0.0;
300	>	rayorigin(&thisray, PRIMARY, NULL, NULL);
301		printvals(&thisray);
302		}
303
304
305	<	void
306	<	rad(org, dir, dmax) /* compute and print ray value(s) */
307	<	FVECT org, dir;
308	<	double dmax;
305	>	static void
306	>	raycast( /* compute first ray intersection only */
307	>	RAY *r
308	>	)
309		{
310	<	VCOPY(thisray.rorg, org);
311	<	VCOPY(thisray.rdir, dir);
312	<	thisray.rmax = dmax;
313	<	rayorigin(&thisray, NULL, PRIMARY, 1.0);
314	<	if (castonly) {
315	<	if (!localhit(&thisray, &thescene))
316	<	if (thisray.ro == &Aftplane) { /* clipped */
341	<	thisray.ro = NULL;
342	<	thisray.rot = FHUGE;
343	<	} else
344	<	sourcehit(&thisray);
345	<	} else
346	<	rayvalue(&thisray);
347	<	printvals(&thisray);
310	>	if (!localhit(r, &thescene)) {
311	>	if (r->ro == &Aftplane) { /* clipped */
312	>	r->ro = NULL;
313	>	r->rot = FHUGE;
314	>	} else
315	>	sourcehit(r);
316	>	}
317		}
318
319
320	<	void
321	<	irrad(org, dir) /* compute immediate irradiance value */
322	<	FVECT org, dir;
320	>	static void
321	>	rayirrad( /* compute irradiance rather than radiance */
322	>	RAY *r
323	>	)
324		{
325	<	register int i;
325	>	void (old_revf)(RAY ) = r->revf;
326
327	<	for (i = 0; i < 3; i++) {
328	<	thisray.rorg[i] = org[i] + dir[i];
329	<	thisray.rdir[i] = -dir[i];
327	>	r->rot = 1e-5; /* pretend we hit surface */
328	>	VSUM(r->rop, r->rorg, r->rdir, r->rot);
329	>	r->ron[0] = -r->rdir[0];
330	>	r->ron[1] = -r->rdir[1];
331	>	r->ron[2] = -r->rdir[2];
332	>	r->rod = 1.0;
333	>	/* compute result */
334	>	r->revf = raytrace;
335	>	(*ofun[Lamb.otype].funp)(&Lamb, r);
336	>	r->revf = old_revf;
337	>	}
338	>
339	>
340	>	static void
341	>	rtcompute( /* compute and print ray value(s) */
342	>	FVECT org,
343	>	FVECT dir,
344	>	double dmax
345	>	)
346	>	{
347	>	/* set up ray */
348	>	rayorigin(&thisray, PRIMARY, NULL, NULL);
349	>	if (imm_irrad) {
350	>	VSUM(thisray.rorg, org, dir, 1.1e-4);
351	>	thisray.rdir[0] = -dir[0];
352	>	thisray.rdir[1] = -dir[1];
353	>	thisray.rdir[2] = -dir[2];
354	>	thisray.rmax = 0.0;
355	>	thisray.revf = rayirrad;
356	>	} else {
357	>	VCOPY(thisray.rorg, org);
358	>	VCOPY(thisray.rdir, dir);
359	>	thisray.rmax = dmax;
360	>	if (castonly)
361	>	thisray.revf = raycast;
362		}
363	<	rayorigin(&thisray, NULL, PRIMARY, 1.0);
364	<	/* pretend we hit surface */
365	<	thisray.rot = 1.0-1e-4;
366	<	thisray.rod = 1.0;
367	<	VCOPY(thisray.ron, dir);
368	<	for (i = 0; i < 3; i++) /* fudge factor */
369	<	thisray.rop[i] = org[i] + 1e-4*dir[i];
368	<	/* compute and print */
369	<	(*ofun[Lamb.otype].funp)(&Lamb, &thisray);
363	>	if (ray_pnprocs > 1) { /* multiprocessing FIFO? */
364	>	if (ray_fifo_in(&thisray) < 0)
365	>	error(USER, "lost children");
366	>	return;
367	>	}
368	>	samplendx++; /* else do it ourselves */
369	>	rayvalue(&thisray);
370		printvals(&thisray);
371		}
372
373
374	<	void
375	<	printvals(r) /* print requested ray values */
376	<	RAY *r;
374	>	static int
375	>	printvals( /* print requested ray values */
376	>	RAY *r
377	>	)
378		{
379	<	register void (**tp)();
379	>	oputf_t **tp;
380
381		if (ray_out[0] == NULL)
382	<	return;
382	>	return(0);
383		for (tp = ray_out; *tp != NULL; tp++)
384		(**tp)(r);
385		if (outform == 'a')
386		putchar('\n');
387	+	return(1);
388		}
389
390
391	<	int
392	<	getvec(vec, fmt, fp) /* get a vector from fp */
393	<	register FVECT vec;
394	<	int fmt;
395	<	FILE *fp;
391	>	static int
392	>	getvec( /* get a vector from fp */
393	>	FVECT vec,
394	>	int fmt,
395	>	FILE *fp
396	>	)
397		{
398		static float vf[3];
399		static double vd[3];
400		char buf[32];
401	<	register int i;
401	>	int i;
402
403		switch (fmt) {
404		case 'a': /* ascii */
#	Line 409 \| Line 412 \| *FILE fp;**
412		case 'f': /* binary float */
413		if (fread((char *)vf, sizeof(float), 3, fp) != 3)
414		return(-1);
415	<	vec[0] = vf[0]; vec[1] = vf[1]; vec[2] = vf[2];
415	>	VCOPY(vec, vf);
416		break;
417		case 'd': /* binary double */
418		if (fread((char *)vd, sizeof(double), 3, fp) != 3)
419		return(-1);
420	<	vec[0] = vd[0]; vec[1] = vd[1]; vec[2] = vd[2];
420	>	VCOPY(vec, vd);
421		break;
422		default:
423		error(CONSISTENCY, "botched input format");
#	Line 424 \| Line 427 \| *FILE fp;**
427
428
429		void
430	<	tranotify(obj) /* record new modifier */
431	<	OBJECT obj;
430	>	tranotify( /* record new modifier */
431	>	OBJECT obj
432	>	)
433		{
434		static int hitlimit = 0;
435	<	register OBJREC *o = objptr(obj);
436	<	register char **tralp;
435	>	OBJREC *o = objptr(obj);
436	>	char **tralp;
437
438		if (obj == OVOID) { /* starting over */
439		traset[0] = 0;
#	Line 452 \| Line 456 \| OBJECT obj;
456
457
458		static void
459	<	ourtrace(r) /* print ray values */
460	<	RAY *r;
459	>	ourtrace( /* print ray values */
460	>	RAY *r
461	>	)
462		{
463	<	register void (**tp)();
463	>	oputf_t **tp;
464
465		if (every_out[0] == NULL)
466		return;
#	Line 467 \| Line 472 \| *RAY r;**
472		tabin(r);
473		for (tp = every_out; *tp != NULL; tp++)
474		(**tp)(r);
475	<	putchar('\n');
475	>	if (outform == 'a')
476	>	putchar('\n');
477		}
478
479
480		static void
481	<	tabin(r) /* tab in appropriate amount */
482	<	RAY *r;
481	>	tabin( /* tab in appropriate amount */
482	>	RAY *r
483	>	)
484		{
485	<	register RAY *rp;
485	>	const RAY *rp;
486
487		for (rp = r->parent; rp != NULL; rp = rp->parent)
488		putchar('\t');
#	Line 483 \| Line 490 \| *RAY r;**
490
491
492		static void
493	<	oputo(r) /* print origin */
494	<	register RAY *r;
493	>	oputo( /* print origin */
494	>	RAY *r
495	>	)
496		{
497		(*putreal)(r->rorg[0]);
498		(*putreal)(r->rorg[1]);
#	Line 493 \| Line 501 \| *register RAY r;**
501
502
503		static void
504	<	oputd(r) /* print direction */
505	<	register RAY *r;
504	>	oputd( /* print direction */
505	>	RAY *r
506	>	)
507		{
508		(*putreal)(r->rdir[0]);
509		(*putreal)(r->rdir[1]);
#	Line 503 \| Line 512 \| *register RAY r;**
512
513
514		static void
515	<	oputv(r) /* print value */
516	<	register RAY *r;
515	>	oputv( /* print value */
516	>	RAY *r
517	>	)
518		{
509	–	COLR cout;
510	–
519		if (outform == 'c') {
520	+	COLR cout;
521		setcolr(cout, colval(r->rcol,RED),
522		colval(r->rcol,GRN),
523		colval(r->rcol,BLU));
#	Line 522 \| Line 531 \| *register RAY r;**
531
532
533		static void
534	<	oputl(r) /* print effective distance */
535	<	register RAY *r;
534	>	oputV( /* print value contribution */
535	>	RAY *r
536	>	)
537		{
538	+	double contr[3];
539	+
540	+	raycontrib(contr, r, PRIMARY);
541	+	multcolor(contr, r->rcol);
542	+	(*putreal)(contr[RED]);
543	+	(*putreal)(contr[GRN]);
544	+	(*putreal)(contr[BLU]);
545	+	}
546	+
547	+
548	+	static void
549	+	oputl( /* print effective distance */
550	+	RAY *r
551	+	)
552	+	{
553		(*putreal)(r->rt);
554		}
555
556
557		static void
558	<	oputL(r) /* print single ray length */
559	<	register RAY *r;
558	>	oputL( /* print single ray length */
559	>	RAY *r
560	>	)
561		{
562		(*putreal)(r->rot);
563		}
564
565
566		static void
567	<	oputp(r) /* print point */
568	<	register RAY *r;
567	>	oputc( /* print local coordinates */
568	>	RAY *r
569	>	)
570		{
571	+	(*putreal)(r->uv[0]);
572	+	(*putreal)(r->uv[1]);
573	+	}
574	+
575	+
576	+	static void
577	+	oputp( /* print point */
578	+	RAY *r
579	+	)
580	+	{
581		if (r->rot < FHUGE) {
582		(*putreal)(r->rop[0]);
583		(*putreal)(r->rop[1]);
#	Line 554 \| Line 591 \| *register RAY r;**
591
592
593		static void
594	<	oputN(r) /* print unperturbed normal */
595	<	register RAY *r;
594	>	oputN( /* print unperturbed normal */
595	>	RAY *r
596	>	)
597		{
598		if (r->rot < FHUGE) {
599		(*putreal)(r->ron[0]);
#	Line 570 \| Line 608 \| *register RAY r;**
608
609
610		static void
611	<	oputn(r) /* print perturbed normal */
612	<	RAY *r;
611	>	oputn( /* print perturbed normal */
612	>	RAY *r
613	>	)
614		{
615		FVECT pnorm;
616
#	Line 589 \| Line 628 \| *RAY r;**
628
629
630		static void
631	<	oputs(r) /* print name */
632	<	register RAY *r;
631	>	oputs( /* print name */
632	>	RAY *r
633	>	)
634		{
635		if (r->ro != NULL)
636		fputs(r->ro->oname, stdout);
#	Line 601 \| Line 641 \| *register RAY r;**
641
642
643		static void
644	<	oputw(r) /* print weight */
645	<	register RAY *r;
644	>	oputw( /* print weight */
645	>	RAY *r
646	>	)
647		{
648		(*putreal)(r->rweight);
649		}
650
651
652		static void
653	<	oputm(r) /* print modifier */
654	<	register RAY *r;
653	>	oputW( /* print coefficient */
654	>	RAY *r
655	>	)
656		{
657	+	double contr[3];
658	+
659	+	raycontrib(contr, r, PRIMARY);
660	+	(*putreal)(contr[RED]);
661	+	(*putreal)(contr[GRN]);
662	+	(*putreal)(contr[BLU]);
663	+	}
664	+
665	+
666	+	static void
667	+	oputm( /* print modifier */
668	+	RAY *r
669	+	)
670	+	{
671		if (r->ro != NULL)
672		if (r->ro->omod != OVOID)
673		fputs(objptr(r->ro->omod)->oname, stdout);
#	Line 624 \| Line 680 \| *register RAY r;**
680
681
682		static void
683	<	puta(v) /* print ascii value */
684	<	double v;
683	>	oputM( /* print material */
684	>	RAY *r
685	>	)
686	>	{
687	>	OBJREC *mat;
688	>
689	>	if (r->ro != NULL) {
690	>	if ((mat = findmaterial(r->ro)) != NULL)
691	>	fputs(mat->oname, stdout);
692	>	else
693	>	fputs(VOIDID, stdout);
694	>	} else
695	>	putchar('*');
696	>	putchar('\t');
697	>	}
698	>
699	>
700	>	static void
701	>	oputtilde( /* output tilde (spacer) */
702	>	RAY *r
703	>	)
704	>	{
705	>	fputs("~\t", stdout);
706	>	}
707	>
708	>
709	>	static void
710	>	puta( /* print ascii value */
711	>	double v
712	>	)
713		{
714		printf("%e\t", v);
715		}

Diff Legend

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

Comparing ray/src/rt/rtrace.c (file contents): Revision 2.27 by greg, Sat Feb 22 02:07:29 2003 UTC vs. Revision 2.64 by greg, Sun Sep 26 15:49:39 2010 UTC

Diff Legend

Comparing ray/src/rt/rtrace.c (file contents):
Revision 2.27 by greg, Sat Feb 22 02:07:29 2003 UTC vs.
Revision 2.64 by greg, Sun Sep 26 15:49:39 2010 UTC