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

Comparing ray/src/rt/raytrace.c (file contents):
Revision 2.37 by greg, Tue Mar 11 17:08:55 2003 UTC vs.
Revision 2.73 by greg, Tue Nov 13 19:58:33 2018 UTC

#	Line 10 \| Line 10 \| static const char RCSid[] = "$Id$";
10		#include "copyright.h"
11
12		#include "ray.h"
13	<
13	>	#include "source.h"
14		#include "otypes.h"
15	–
15		#include "otspecial.h"
16	+	#include "random.h"
17	+	#include "pmap.h"
18
19		#define MAXCSET ((MAXSET+1)2-1) / maximum check set size */
20
21	<	unsigned long raynum = 0; /* next unique ray number */
22	<	unsigned long nrays = 0; /* number of calls to localhit */
21	>	RNUMBER raynum = 0; /* next unique ray number */
22	>	RNUMBER nrays = 0; /* number of calls to localhit */
23
24	<	static FLOAT Lambfa[5] = {PI, PI, PI, 0.0, 0.0};
24	>	static RREAL Lambfa[5] = {PI, PI, PI, 0.0, 0.0};
25		OBJREC Lamb = {
26		OVOID, MAT_PLASTIC, "Lambertian",
27	<	{0, 5, NULL, Lambfa}, NULL,
27	>	{NULL, Lambfa, 0, 5}, NULL
28		}; /* a Lambertian surface */
29
30		OBJREC Aftplane; /* aft clipping plane object */
31
31	–	static int raymove(), checkhit();
32	–	static void checkset();
33	–
34	–	#ifndef MAXLOOP
35	–	#define MAXLOOP 0 /* modifier loop detection */
36	–	#endif
37	–
32		#define RAYHIT (-1) /* return value for intercepted ray */
33
34	+	static int raymove(FVECT pos, OBJECT cxs, int dirf, RAY r, CUBE *cu);
35	+	static int checkhit(RAY r, CUBE cu, OBJECT *cxs);
36	+	static void checkset(OBJECT os, OBJECT cs);
37
38	+
39		int
40	<	rayorigin(r, ro, rt, rw) /* start new ray from old one */
41	<	register RAY r, ro;
42	<	int rt;
43	<	double rw;
40	>	rayorigin( /* start new ray from old one */
41	>	RAY *r,
42	>	int rt,
43	>	const RAY *ro,
44	>	const COLOR rc
45	>	)
46		{
47	<	double re;
48	<
47	>	double rw, re;
48	>	/* assign coefficient/weight */
49	>	if (rc == NULL) {
50	>	rw = 1.0;
51	>	setcolor(r->rcoef, 1., 1., 1.);
52	>	} else {
53	>	rw = intens(rc);
54	>	if (rw > 1.0)
55	>	rw = 1.0; /* avoid calculation growth */
56	>	if (rc != r->rcoef)
57	>	copycolor(r->rcoef, rc);
58	>	}
59		if ((r->parent = ro) == NULL) { /* primary ray */
60		r->rlvl = 0;
61		r->rweight = rw;
#	Line 58 \| Line 68 \| double rw;
68		r->gecc = seccg;
69		r->slights = NULL;
70		} else { /* spawned ray */
71	+	if (ro->rot >= FHUGE) {
72	+	memset(r, 0, sizeof(RAY));
73	+	return(-1); /* illegal continuation */
74	+	}
75		r->rlvl = ro->rlvl;
76		if (rt & RAYREFL) {
77		r->rlvl++;
#	Line 77 \| Line 91 \| double rw;
91		r->crtype = ro->crtype \| (r->rtype = rt);
92		VCOPY(r->rorg, ro->rop);
93		r->rweight = ro->rweight * rw;
94	<	/* estimate absorption */
94	>	/* estimate extinction */
95		re = colval(ro->cext,RED) < colval(ro->cext,GRN) ?
96		colval(ro->cext,RED) : colval(ro->cext,GRN);
97		if (colval(ro->cext,BLU) < re) re = colval(ro->cext,BLU);
98	<	if (re > 0.)
99	<	r->rweight = exp(-rero->rot);
98	>	re *= ro->rot;
99	>	if (re > 0.1) {
100	>	if (re > 92.) {
101	>	r->rweight = 0.0;
102	>	} else {
103	>	r->rweight *= exp(-re);
104	>	}
105	>	}
106		}
107		rayclear(r);
108	<	return(r->rlvl <= maxdepth && r->rweight >= minweight ? 0 : -1);
108	>	if (r->rweight <= 0.0) /* check for expiration */
109	>	return(-1);
110	>	if (r->crtype & SHADOW) /* shadow commitment */
111	>	return(0);
112	>	/* ambient in photon map? */
113	>	if (ro != NULL && ro->crtype & AMBIENT) {
114	>	if (causticPhotonMapping)
115	>	return(-1);
116	>	if (photonMapping && rt != TRANS)
117	>	return(-1);
118	>	}
119	>	if (maxdepth <= 0 && rc != NULL) { /* Russian roulette */
120	>	if (minweight <= 0.0)
121	>	error(USER, "zero ray weight in Russian roulette");
122	>	if (maxdepth < 0 && r->rlvl > -maxdepth)
123	>	return(-1); /* upper reflection limit */
124	>	if (r->rweight >= minweight)
125	>	return(0);
126	>	if (frandom() > r->rweight/minweight)
127	>	return(-1);
128	>	rw = minweight/r->rweight; /* promote survivor */
129	>	scalecolor(r->rcoef, rw);
130	>	r->rweight = minweight;
131	>	return(0);
132	>	}
133	>	return(r->rweight >= minweight && r->rlvl <= abs(maxdepth) ? 0 : -1);
134		}
135
136
137		void
138	<	rayclear(r) /* clear a ray for (re)evaluation */
139	<	register RAY *r;
138	>	rayclear( /* clear a ray for (re)evaluation */
139	>	RAY *r
140	>	)
141		{
142		r->rno = raynum++;
143		r->newcset = r->clipset;
#	Line 99 \| Line 145 \| *register RAY r;**
145		r->robj = OVOID;
146		r->ro = NULL;
147		r->rox = NULL;
148	<	r->rt = r->rot = FHUGE;
148	>	r->rxt = r->rmt = r->rot = FHUGE;
149		r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
150		r->uv[0] = r->uv[1] = 0.0;
151		setcolor(r->pcol, 1.0, 1.0, 1.0);
152	+	setcolor(r->mcol, 0.0, 0.0, 0.0);
153		setcolor(r->rcol, 0.0, 0.0, 0.0);
154		}
155
156
157		void
158	<	raytrace(r) /* trace a ray and compute its value */
159	<	RAY *r;
158	>	raytrace( /* trace a ray and compute its value */
159	>	RAY *r
160	>	)
161		{
162		if (localhit(r, &thescene))
163		raycont(r); /* hit local surface, evaluate */
#	Line 119 \| Line 167 \| *RAY r;**
167		} else if (sourcehit(r))
168		rayshade(r, r->ro->omod); /* distant source */
169
122	–	rayparticipate(r); /* for participating medium */
123	–
170		if (trace != NULL)
171		(trace)(r); / trace execution */
172	+
173	+	rayparticipate(r); /* for participating medium */
174		}
175
176
177		void
178	<	raycont(r) /* check for clipped object and continue */
179	<	register RAY *r;
178	>	raycont( /* check for clipped object and continue */
179	>	RAY *r
180	>	)
181		{
182		if ((r->clipset != NULL && inset(r->clipset, r->ro->omod)) \|\|
183		!rayshade(r, r->ro->omod))
#	Line 137 \| Line 186 \| *register RAY r;**
186
187
188		void
189	<	raytrans(r) /* transmit ray as is */
190	<	register RAY *r;
189	>	raytrans( /* transmit ray as is */
190	>	RAY *r
191	>	)
192		{
193		RAY tr;
194
195	<	if (rayorigin(&tr, r, TRANS, 1.0) == 0) {
196	<	VCOPY(tr.rdir, r->rdir);
197	<	rayvalue(&tr);
198	<	copycolor(r->rcol, tr.rcol);
199	<	r->rt = r->rot + tr.rt;
200	<	}
195	>	rayorigin(&tr, TRANS, r, NULL); /* always continue */
196	>	VCOPY(tr.rdir, r->rdir);
197	>	rayvalue(&tr);
198	>	copycolor(r->rcol, tr.rcol);
199	>	r->rmt = r->rot + tr.rmt;
200	>	r->rxt = r->rot + tr.rxt;
201		}
202
203
204		int
205	<	rayshade(r, mod) /* shade ray r with material mod */
206	<	register RAY *r;
207	<	int mod;
205	>	rayshade( /* shade ray r with material mod */
206	>	RAY *r,
207	>	int mod
208	>	)
209		{
210	<	int gotmat;
211	<	register OBJREC *m;
212	<	#if MAXLOOP
213	<	static int depth = 0;
163	<	/* check for infinite loop */
164	<	if (depth++ >= MAXLOOP)
165	<	objerror(r->ro, USER, "possible modifier loop");
166	<	#endif
167	<	r->rt = r->rot; /* set effective ray length */
168	<	for (gotmat = 0; !gotmat && mod != OVOID; mod = m->omod) {
210	>	OBJREC *m;
211	>
212	>	r->rxt = r->rmt = r->rot; /* preset effective ray length */
213	>	for ( ; mod != OVOID; mod = m->omod) {
214		m = objptr(mod);
215		/****** unnecessary test since modifier() is always called
216		if (!ismodifier(m->otype)) {
#	Line 174 \| Line 219 \| int mod;
219		}
220		******/
221		/* hack for irradiance calculation */
222	<	if (do_irrad && !(r->crtype & ~(PRIMARY\|TRANS))) {
223	<	if (irr_ignore(m->otype)) {
224	<	#if MAXLOOP
225	<	depth--;
181	<	#endif
222	>	if (do_irrad && !(r->crtype & ~(PRIMARY\|TRANS)) &&
223	>	(ofun[m->otype].flags & (T_M\|T_X)) &&
224	>	m->otype != MAT_CLIP) {
225	>	if (istransp(m->otype) \|\| isBSDFproxy(m)) {
226		raytrans(r);
227		return(1);
228		}
229		if (!islight(m->otype))
230		m = &Lamb;
231		}
232	<	/* materials call raytexture */
233	<	gotmat = (*ofun[m->otype].funp)(m, r);
232	>	if ((*ofun[m->otype].funp)(m, r))
233	>	return(1); /* materials call raytexture() */
234		}
235	<	#if MAXLOOP
192	<	depth--;
193	<	#endif
194	<	return(gotmat);
235	>	return(0); /* no material! */
236		}
237
238
239		void
240	<	rayparticipate(r) /* compute ray medium participation */
241	<	register RAY *r;
240	>	rayparticipate( /* compute ray medium participation */
241	>	RAY *r
242	>	)
243		{
244		COLOR ce, ca;
245		double re, ge, be;
#	Line 212 \| Line 254 \| *register RAY r;**
254		ge *= 1. - colval(r->albedo,GRN);
255		be *= 1. - colval(r->albedo,BLU);
256		}
257	<	setcolor(ce, re<=0. ? 1. : re>92. ? 0. : exp(-re),
258	<	ge<=0. ? 1. : ge>92. ? 0. : exp(-ge),
259	<	be<=0. ? 1. : be>92. ? 0. : exp(-be));
260	<	multcolor(r->rcol, ce); /* path absorption */
257	>	setcolor(ce, re<=FTINY ? 1. : re>92. ? 0. : exp(-re),
258	>	ge<=FTINY ? 1. : ge>92. ? 0. : exp(-ge),
259	>	be<=FTINY ? 1. : be>92. ? 0. : exp(-be));
260	>	multcolor(r->rcol, ce); /* path extinction */
261		if (r->crtype & SHADOW \|\| intens(r->albedo) <= FTINY)
262		return; /* no scattering */
263	<	setcolor(ca,
264	<	colval(r->albedo,RED)colval(ambval,RED)(1.-colval(ce,RED)),
265	<	colval(r->albedo,GRN)colval(ambval,GRN)(1.-colval(ce,GRN)),
266	<	colval(r->albedo,BLU)colval(ambval,BLU)(1.-colval(ce,BLU)));
267	<	addcolor(r->rcol, ca); /* ambient in scattering */
263	>
264	>	/* PMAP: indirect inscattering accounted for by volume photons? */
265	>	if (!volumePhotonMapping) {
266	>	setcolor(ca,
267	>	colval(r->albedo,RED)colval(ambval,RED)(1.-colval(ce,RED)),
268	>	colval(r->albedo,GRN)colval(ambval,GRN)(1.-colval(ce,GRN)),
269	>	colval(r->albedo,BLU)colval(ambval,BLU)(1.-colval(ce,BLU)));
270	>	addcolor(r->rcol, ca); /* ambient in scattering */
271	>	}
272	>
273		srcscatter(r); /* source in scattering */
274		}
275
276
277	<	raytexture(r, mod) /* get material modifiers */
278	<	RAY *r;
279	<	int mod;
277	>	void
278	>	raytexture( /* get material modifiers */
279	>	RAY *r,
280	>	OBJECT mod
281	>	)
282		{
283	<	register OBJREC *m;
235	<	#if MAXLOOP
236	<	static int depth = 0;
237	<	/* check for infinite loop */
238	<	if (depth++ >= MAXLOOP)
239	<	objerror(r->ro, USER, "modifier loop");
240	<	#endif
283	>	OBJREC *m;
284		/* execute textures and patterns */
285		for ( ; mod != OVOID; mod = m->omod) {
286		m = objptr(mod);
#	Line 253 \| Line 296 \| int mod;
296		objerror(r->ro, USER, errmsg);
297		}
298		}
256	–	#if MAXLOOP
257	–	depth--; /* end here */
258	–	#endif
299		}
300
301
302		int
303	<	raymixture(r, fore, back, coef) /* mix modifiers */
304	<	register RAY *r;
305	<	OBJECT fore, back;
306	<	double coef;
303	>	raymixture( /* mix modifiers */
304	>	RAY *r,
305	>	OBJECT fore,
306	>	OBJECT back,
307	>	double coef
308	>	)
309		{
310		RAY fr, br;
311	+	double mfore, mback;
312		int foremat, backmat;
313	<	register int i;
313	>	int i;
314		/* bound coefficient */
315		if (coef > 1.0)
316		coef = 1.0;
#	Line 276 \| Line 319 \| double coef;
319		/* compute foreground and background */
320		foremat = backmat = 0;
321		/* foreground */
322	<	copystruct(&fr, r);
323	<	if (coef > FTINY)
322	>	fr = *r;
323	>	if (coef > FTINY) {
324	>	fr.rweight *= coef;
325	>	scalecolor(fr.rcoef, coef);
326		foremat = rayshade(&fr, fore);
327	+	}
328		/* background */
329	<	copystruct(&br, r);
330	<	if (coef < 1.0-FTINY)
329	>	br = *r;
330	>	if (coef < 1.0-FTINY) {
331	>	br.rweight *= 1.0-coef;
332	>	scalecolor(br.rcoef, 1.0-coef);
333		backmat = rayshade(&br, back);
334	+	}
335		/* check for transparency */
336	<	if (backmat ^ foremat)
336	>	if (backmat ^ foremat) {
337		if (backmat && coef > FTINY)
338		raytrans(&fr);
339		else if (foremat && coef < 1.0-FTINY)
340		raytrans(&br);
341	+	}
342		/* mix perturbations */
343		for (i = 0; i < 3; i++)
344		r->pert[i] = coeffr.pert[i] + (1.0-coef)br.pert[i];
#	Line 305 \| Line 355 \| double coef;
355		scalecolor(br.rcol, 1.0-coef);
356		copycolor(r->rcol, fr.rcol);
357		addcolor(r->rcol, br.rcol);
358	<	r->rt = bright(fr.rcol) > bright(br.rcol) ? fr.rt : br.rt;
358	>	mfore = bright(fr.mcol); mback = bright(br.mcol);
359	>	r->rmt = mfore > mback ? fr.rmt : br.rmt;
360	>	r->rxt = bright(fr.rcol)-mfore > bright(br.rcol)-mback ?
361	>	fr.rxt : br.rxt;
362		return(1);
363		}
364
365
366		double
367	<	raydist(r, flags) /* compute (cumulative) ray distance */
368	<	register RAY *r;
369	<	register int flags;
367	>	raydist( /* compute (cumulative) ray distance */
368	>	const RAY *r,
369	>	int flags
370	>	)
371		{
372		double sum = 0.0;
373
#	Line 325 \| Line 379 \| register int flags;
379		}
380
381
382	+	void
383	+	raycontrib( /* compute (cumulative) ray contribution */
384	+	RREAL rc[3],
385	+	const RAY *r,
386	+	int flags
387	+	)
388	+	{
389	+	double eext[3];
390	+	int i;
391	+
392	+	eext[0] = eext[1] = eext[2] = 0.;
393	+	rc[0] = rc[1] = rc[2] = 1.;
394	+
395	+	while (r != NULL && r->crtype&flags) {
396	+	for (i = 3; i--; ) {
397	+	rc[i] *= colval(r->rcoef,i);
398	+	eext[i] += r->rot * colval(r->cext,i);
399	+	}
400	+	r = r->parent;
401	+	}
402	+	for (i = 3; i--; )
403	+	rc[i] *= (eext[i] <= FTINY) ? 1. :
404	+	(eext[i] > 92.) ? 0. : exp(-eext[i]);
405	+	}
406	+
407	+
408		double
409	<	raynormal(norm, r) /* compute perturbed normal for ray */
410	<	FVECT norm;
411	<	register RAY *r;
409	>	raynormal( /* compute perturbed normal for ray */
410	>	FVECT norm,
411	>	RAY *r
412	>	)
413		{
414		double newdot;
415	<	register int i;
415	>	int i;
416
417		/* The perturbation is added to the surface normal to obtain
418		* the new normal. If the new normal would affect the surface
#	Line 361 \| Line 442 \| *register RAY r;**
442
443
444		void
445	<	newrayxf(r) /* get new tranformation matrix for ray */
446	<	RAY *r;
445	>	newrayxf( /* get new tranformation matrix for ray */
446	>	RAY *r
447	>	)
448		{
449		static struct xfn {
450		struct xfn *next;
451		FULLXF xf;
452		} xfseed = { &xfseed }, *xflast = &xfseed;
453	<	register struct xfn *xp;
454	<	register RAY *rp;
453	>	struct xfn *xp;
454	>	const RAY *rp;
455
456		/*
457		* Search for transform in circular list that
#	Line 380 \| Line 462 \| *RAY r;**
462		if (rp->rox == &xp->xf) { /* xp in use */
463		xp = xp->next; /* move to next */
464		if (xp == xflast) { /* need new one */
465	<	xp = (struct xfn *)malloc(sizeof(struct xfn));
465	>	xp = (struct xfn *)bmalloc(sizeof(struct xfn));
466		if (xp == NULL)
467		error(SYSTEM,
468		"out of memory in newrayxf");
#	Line 398 \| Line 480 \| *RAY r;**
480
481
482		void
483	<	flipsurface(r) /* reverse surface orientation */
484	<	register RAY *r;
483	>	flipsurface( /* reverse surface orientation */
484	>	RAY *r
485	>	)
486		{
487		r->rod = -r->rod;
488		r->ron[0] = -r->ron[0];
#	Line 412 \| Line 495 \| *register RAY r;**
495
496
497		void
498	<	rayhit(oset, r) /* standard ray hit test */
499	<	OBJECT *oset;
500	<	RAY *r;
498	>	rayhit( /* standard ray hit test */
499	>	OBJECT *oset,
500	>	RAY *r
501	>	)
502		{
503		OBJREC *o;
504		int i;
#	Line 428 \| Line 512 \| *RAY r;**
512
513
514		int
515	<	localhit(r, scene) /* check for hit in the octree */
516	<	register RAY *r;
517	<	register CUBE *scene;
515	>	localhit( /* check for hit in the octree */
516	>	RAY *r,
517	>	CUBE *scene
518	>	)
519		{
520		OBJECT cxset[MAXCSET+1]; /* set of checked objects */
521		FVECT curpos; /* current cube position */
522		int sflags; /* sign flags */
523		double t, dt;
524	<	register int i;
524	>	int i;
525
526		nrays++; /* increment trace counter */
527		sflags = 0;
#	Line 447 \| Line 532 \| *register CUBE scene;**
532		else if (r->rdir[i] < -1e-7)
533		sflags \|= 0x10 << i;
534		}
535	<	if (sflags == 0)
536	<	error(CONSISTENCY, "zero ray direction in localhit");
535	>	if (!sflags) {
536	>	error(WARNING, "zero ray direction in localhit");
537	>	return(0);
538	>	}
539		/* start off assuming nothing hit */
540		if (r->rmax > FTINY) { /* except aft plane if one */
541		r->ro = &Aftplane;
542		r->rot = r->rmax;
543	<	for (i = 0; i < 3; i++)
457	<	r->rop[i] = r->rorg[i] + r->rot*r->rdir[i];
543	>	VSUM(r->rop, r->rorg, r->rdir, r->rot);
544		}
545		/* find global cube entrance point */
546		t = 0.0;
#	Line 477 \| Line 563 \| *register CUBE scene;**
563		if (t >= r->rot) /* clipped already */
564		return(0);
565		/* advance position */
566	<	for (i = 0; i < 3; i++)
481	<	curpos[i] += r->rdir[i]*t;
566	>	VSUM(curpos, curpos, r->rdir, t);
567
568		if (!incube(scene, curpos)) /* non-intersecting ray */
569		return(0);
570		}
571		cxset[0] = 0;
572		raymove(curpos, cxset, sflags, r, scene);
573	<	return(r->ro != NULL & r->ro != &Aftplane);
573	>	return((r->ro != NULL) & (r->ro != &Aftplane));
574		}
575
576
577		static int
578	<	raymove(pos, cxs, dirf, r, cu) /* check for hit as we move */
579	<	FVECT pos; /* current position, modified herein */
580	<	OBJECT cxs; / checked objects, modified by checkhit */
581	<	int dirf; /* direction indicators to speed tests */
582	<	register RAY *r;
583	<	register CUBE *cu;
578	>	raymove( /* check for hit as we move */
579	>	FVECT pos, /* current position, modified herein */
580	>	OBJECT cxs, / checked objects, modified by checkhit */
581	>	int dirf, /* direction indicators to speed tests */
582	>	RAY *r,
583	>	CUBE *cu
584	>	)
585		{
586		int ax;
587		double dt, t;
588
589		if (istree(cu->cutree)) { /* recurse on subcubes */
590		CUBE cukid;
591	<	register int br, sgn;
591	>	int br, sgn;
592
593		cukid.cusize = cu->cusize * 0.5; /* find subcube */
594		VCOPY(cukid.cuorg, cu->cuorg);
#	Line 568 \| Line 654 \| *register CUBE cu;**
654		ax = 2;
655		}
656		}
657	<	pos[0] += r->rdir[0]*t;
572	<	pos[1] += r->rdir[1]*t;
573	<	pos[2] += r->rdir[2]*t;
657	>	VSUM(pos, pos, r->rdir, t);
658		return(ax);
659		}
660
661
662		static int
663	<	checkhit(r, cu, cxs) /* check for hit in full cube */
664	<	register RAY *r;
665	<	CUBE *cu;
666	<	OBJECT *cxs;
663	>	checkhit( /* check for hit in full cube */
664	>	RAY *r,
665	>	CUBE *cu,
666	>	OBJECT *cxs
667	>	)
668		{
669		OBJECT oset[MAXSET+1];
670
#	Line 596 \| Line 681 \| *OBJECT cxs;**
681
682
683		static void
684	<	checkset(os, cs) /* modify checked set and set to check */
685	<	register OBJECT os; / os' = os - cs */
686	<	register OBJECT cs; / cs' = cs + os */
684	>	checkset( /* modify checked set and set to check */
685	>	OBJECT os, / os' = os - cs */
686	>	OBJECT cs / cs' = cs + os */
687	>	)
688		{
689		OBJECT cset[MAXCSET+MAXSET+1];
690	<	register int i, j;
690	>	int i, j;
691		int k;
692		/* copy os in place, cset <- cs */
693		cset[0] = 0;

Diff Legend

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

Comparing ray/src/rt/raytrace.c (file contents): Revision 2.37 by greg, Tue Mar 11 17:08:55 2003 UTC vs. Revision 2.73 by greg, Tue Nov 13 19:58:33 2018 UTC

Diff Legend

Comparing ray/src/rt/raytrace.c (file contents):
Revision 2.37 by greg, Tue Mar 11 17:08:55 2003 UTC vs.
Revision 2.73 by greg, Tue Nov 13 19:58:33 2018 UTC