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

Comparing ray/src/rt/raytrace.c (file contents):
Revision 2.47 by greg, Thu Apr 14 18:04:12 2005 UTC vs.
Revision 2.78 by greg, Wed Apr 3 16:04:33 2019 UTC

#	Line 13 \| Line 13 \| static const char RCSid[] = "$Id$";
13		#include "source.h"
14		#include "otypes.h"
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 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 */
#	Line 34 \| Line 36 \| *static int checkhit(RAY r, CUBE cu, OBJECT cxs);**
36		static void checkset(OBJECT os, OBJECT cs);
37
38
39	<	extern int
39	>	int
40		rayorigin( /* start new ray from old one */
41	<	register RAY *r,
40	<	register RAY *ro,
41	>	RAY *r,
42		int rt,
43	<	double rw
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 55 \| Line 67 \| *rayorigin( / start new ray from old one /*
67		copycolor(r->albedo, salbedo);
68		r->gecc = seccg;
69		r->slights = NULL;
58	–	} else if (ro->rot >= FHUGE) { /* illegal continuation */
59	–	memset(r, 0, sizeof(RAY));
60	–	return(-1);
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 78 \| Line 91 \| *rayorigin( / start new ray from old one /*
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	<	extern void
137	>	void
138		rayclear( /* clear a ray for (re)evaluation */
139	<	register RAY *r
139	>	RAY *r
140		)
141		{
142		r->rno = raynum++;
#	Line 101 \| Line 145 \| *rayclear( / clear a ray for (re)evaluation /*
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	<	extern void
157	>	void
158		raytrace( /* trace a ray and compute its value */
159		RAY *r
160		)
#	Line 122 \| Line 167 \| *raytrace( / trace a ray and compute its value /*
167		} else if (sourcehit(r))
168		rayshade(r, r->ro->omod); /* distant source */
169
125	–	rayparticipate(r); /* for participating medium */
126	–
170		if (trace != NULL)
171		(trace)(r); / trace execution */
172	+
173	+	rayparticipate(r); /* for participating medium */
174		}
175
176
177	<	extern void
177	>	void
178		raycont( /* check for clipped object and continue */
179	<	register RAY *r
179	>	RAY *r
180		)
181		{
182		if ((r->clipset != NULL && inset(r->clipset, r->ro->omod)) \|\|
#	Line 140 \| Line 185 \| *raycont( / check for clipped object and continue /*
185		}
186
187
188	<	extern void
188	>	void
189		raytrans( /* transmit ray as is */
190	<	register RAY *r
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;
195	>	rayorigin(&tr, TRANS, r, NULL); /* always continue */
196	>	VCOPY(tr.rdir, r->rdir);
197	>	rayvalue(&tr);
198	>	copycolor(r->mcol, tr.mcol);
199	>	copycolor(r->rcol, tr.rcol);
200	>	r->rmt = r->rot + tr.rmt;
201	>	r->rxt = r->rot + tr.rxt;
202	>	}
203	>
204	>
205	>	int
206	>	raytirrad( /* irradiance hack */
207	>	OBJREC *m,
208	>	RAY *r
209	>	)
210	>	{
211	>	if (ofun[m->otype].flags & (T_M\|T_X) && m->otype != MAT_CLIP) {
212	>	if (istransp(m->otype) \|\| isBSDFproxy(m)) {
213	>	raytrans(r);
214	>	return(1);
215	>	}
216	>	if (!islight(m->otype))
217	>	return((*ofun[Lamb.otype].funp)(&Lamb, r));
218		}
219	+	return(0); /* not a qualifying surface */
220		}
221
222
223	<	extern int
223	>	int
224		rayshade( /* shade ray r with material mod */
225	<	register RAY *r,
225	>	RAY *r,
226		int mod
227		)
228		{
229	<	register OBJREC *m;
229	>	int tst_irrad = do_irrad && !(r->crtype & ~(PRIMARY\|TRANS));
230	>	OBJREC *m;
231
232	<	r->rt = r->rot; /* set effective ray length */
232	>	r->rxt = r->rot; /* preset effective ray length */
233		for ( ; mod != OVOID; mod = m->omod) {
234		m = objptr(mod);
235		/****** unnecessary test since modifier() is always called
#	Line 174 \| Line 239 \| *rayshade( / shade ray r with material mod /*
239		}
240		******/
241		/* hack for irradiance calculation */
242	<	if (do_irrad && !(r->crtype & ~(PRIMARY\|TRANS)) &&
243	<	m->otype != MAT_CLIP &&
244	<	(ofun[m->otype].flags & (T_M\|T_X))) {
180	<	if (irr_ignore(m->otype)) {
181	<	raytrans(r);
182	<	return(1);
183	<	}
184	<	if (!islight(m->otype))
185	<	m = &Lamb;
186	<	}
242	>	if (tst_irrad && raytirrad(m, r))
243	>	return(1);
244	>
245		if ((*ofun[m->otype].funp)(m, r))
246		return(1); /* materials call raytexture() */
247		}
#	Line 191 \| Line 249 \| *rayshade( / shade ray r with material mod /*
249		}
250
251
252	<	extern void
252	>	void
253		rayparticipate( /* compute ray medium participation */
254	<	register RAY *r
254	>	RAY *r
255		)
256		{
257		COLOR ce, ca;
#	Line 209 \| Line 267 \| *rayparticipate( / compute ray medium participation**
267		ge *= 1. - colval(r->albedo,GRN);
268		be *= 1. - colval(r->albedo,BLU);
269		}
270	<	setcolor(ce, re<=0. ? 1. : re>92. ? 0. : exp(-re),
271	<	ge<=0. ? 1. : ge>92. ? 0. : exp(-ge),
272	<	be<=0. ? 1. : be>92. ? 0. : exp(-be));
273	<	multcolor(r->rcol, ce); /* path absorption */
270	>	setcolor(ce, re<=FTINY ? 1. : re>92. ? 0. : exp(-re),
271	>	ge<=FTINY ? 1. : ge>92. ? 0. : exp(-ge),
272	>	be<=FTINY ? 1. : be>92. ? 0. : exp(-be));
273	>	multcolor(r->rcol, ce); /* path extinction */
274		if (r->crtype & SHADOW \|\| intens(r->albedo) <= FTINY)
275		return; /* no scattering */
276	<	setcolor(ca,
277	<	colval(r->albedo,RED)colval(ambval,RED)(1.-colval(ce,RED)),
278	<	colval(r->albedo,GRN)colval(ambval,GRN)(1.-colval(ce,GRN)),
279	<	colval(r->albedo,BLU)colval(ambval,BLU)(1.-colval(ce,BLU)));
280	<	addcolor(r->rcol, ca); /* ambient in scattering */
276	>
277	>	/* PMAP: indirect inscattering accounted for by volume photons? */
278	>	if (!volumePhotonMapping) {
279	>	setcolor(ca,
280	>	colval(r->albedo,RED)colval(ambval,RED)(1.-colval(ce,RED)),
281	>	colval(r->albedo,GRN)colval(ambval,GRN)(1.-colval(ce,GRN)),
282	>	colval(r->albedo,BLU)colval(ambval,BLU)(1.-colval(ce,BLU)));
283	>	addcolor(r->rcol, ca); /* ambient in scattering */
284	>	}
285	>
286		srcscatter(r); /* source in scattering */
287		}
288
289
290	<	extern void
290	>	void
291		raytexture( /* get material modifiers */
292		RAY *r,
293		OBJECT mod
294		)
295		{
296	<	register OBJREC *m;
296	>	OBJREC *m;
297		/* execute textures and patterns */
298		for ( ; mod != OVOID; mod = m->omod) {
299		m = objptr(mod);
#	Line 249 \| Line 312 \| *raytexture( / get material modifiers /*
312		}
313
314
315	<	extern int
315	>	int
316		raymixture( /* mix modifiers */
317	<	register RAY *r,
317	>	RAY *r,
318		OBJECT fore,
319		OBJECT back,
320		double coef
321		)
322		{
323		RAY fr, br;
324	+	double mfore, mback;
325		int foremat, backmat;
326	<	register int i;
326	>	int i;
327		/* bound coefficient */
328		if (coef > 1.0)
329		coef = 1.0;
#	Line 269 \| Line 333 \| *raymixture( / mix modifiers /*
333		foremat = backmat = 0;
334		/* foreground */
335		fr = *r;
336	<	if (coef > FTINY)
336	>	if (coef > FTINY) {
337	>	fr.rweight *= coef;
338	>	scalecolor(fr.rcoef, coef);
339		foremat = rayshade(&fr, fore);
340	+	}
341		/* background */
342		br = *r;
343	<	if (coef < 1.0-FTINY)
343	>	if (coef < 1.0-FTINY) {
344	>	br.rweight *= 1.0-coef;
345	>	scalecolor(br.rcoef, 1.0-coef);
346		backmat = rayshade(&br, back);
347	+	}
348		/* check for transparency */
349		if (backmat ^ foremat) {
350		if (backmat && coef > FTINY)
#	Line 298 \| Line 368 \| *raymixture( / mix modifiers /*
368		scalecolor(br.rcol, 1.0-coef);
369		copycolor(r->rcol, fr.rcol);
370		addcolor(r->rcol, br.rcol);
371	<	r->rt = bright(fr.rcol) > bright(br.rcol) ? fr.rt : br.rt;
371	>	scalecolor(fr.mcol, coef);
372	>	scalecolor(br.mcol, 1.0-coef);
373	>	copycolor(r->mcol, fr.mcol);
374	>	addcolor(r->mcol, br.mcol);
375	>	mfore = bright(fr.mcol); mback = bright(br.mcol);
376	>	r->rmt = mfore > mback ? fr.rmt : br.rmt;
377	>	r->rxt = bright(fr.rcol)-mfore > bright(br.rcol)-mback ?
378	>	fr.rxt : br.rxt;
379		return(1);
380		}
381
382
383	<	extern double
383	>	double
384		raydist( /* compute (cumulative) ray distance */
385	<	register RAY *r,
386	<	register int flags
385	>	const RAY *r,
386	>	int flags
387		)
388		{
389		double sum = 0.0;
#	Line 319 \| Line 396 \| *raydist( / compute (cumulative) ray distance /*
396		}
397
398
399	<	extern double
399	>	void
400	>	raycontrib( /* compute (cumulative) ray contribution */
401	>	RREAL rc[3],
402	>	const RAY *r,
403	>	int flags
404	>	)
405	>	{
406	>	static int warnedPM = 0;
407	>
408	>	rc[0] = rc[1] = rc[2] = 1.;
409	>
410	>	while (r != NULL && r->crtype&flags) {
411	>	int i = 3;
412	>	while (i--)
413	>	rc[i] *= colval(r->rcoef,i);
414	>	/* check for participating medium */
415	>	if (!warnedPM && (bright(r->cext) > FTINY) \|
416	>	(bright(r->albedo) > FTINY)) {
417	>	error(WARNING,
418	>	"ray contribution calculation does not support participating media");
419	>	warnedPM++;
420	>	}
421	>	r = r->parent;
422	>	}
423	>	}
424	>
425	>
426	>	double
427		raynormal( /* compute perturbed normal for ray */
428		FVECT norm,
429	<	register RAY *r
429	>	RAY *r
430		)
431		{
432		double newdot;
433	<	register int i;
433	>	int i;
434
435		/* The perturbation is added to the surface normal to obtain
436		* the new normal. If the new normal would affect the surface
#	Line 355 \| Line 459 \| *raynormal( / compute perturbed normal for ray /*
459		}
460
461
462	<	extern void
462	>	void
463		newrayxf( /* get new tranformation matrix for ray */
464		RAY *r
465		)
#	Line 364 \| Line 468 \| *newrayxf( / get new tranformation matrix for ray /*
468		struct xfn *next;
469		FULLXF xf;
470		} xfseed = { &xfseed }, *xflast = &xfseed;
471	<	register struct xfn *xp;
472	<	register RAY *rp;
471	>	struct xfn *xp;
472	>	const RAY *rp;
473
474		/*
475		* Search for transform in circular list that
#	Line 376 \| Line 480 \| *newrayxf( / get new tranformation matrix for ray /*
480		if (rp->rox == &xp->xf) { /* xp in use */
481		xp = xp->next; /* move to next */
482		if (xp == xflast) { /* need new one */
483	<	xp = (struct xfn *)malloc(sizeof(struct xfn));
483	>	xp = (struct xfn *)bmalloc(sizeof(struct xfn));
484		if (xp == NULL)
485		error(SYSTEM,
486		"out of memory in newrayxf");
#	Line 393 \| Line 497 \| *newrayxf( / get new tranformation matrix for ray /*
497		}
498
499
500	<	extern void
500	>	void
501		flipsurface( /* reverse surface orientation */
502	<	register RAY *r
502	>	RAY *r
503		)
504		{
505		r->rod = -r->rod;
#	Line 408 \| Line 512 \| *flipsurface( / reverse surface orientation /*
512		}
513
514
515	<	extern void
515	>	void
516		rayhit( /* standard ray hit test */
517		OBJECT *oset,
518		RAY *r
#	Line 425 \| Line 529 \| *rayhit( / standard ray hit test /*
529		}
530
531
532	<	extern int
532	>	int
533		localhit( /* check for hit in the octree */
534	<	register RAY *r,
535	<	register CUBE *scene
534	>	RAY *r,
535	>	CUBE *scene
536		)
537		{
538		OBJECT cxset[MAXCSET+1]; /* set of checked objects */
539		FVECT curpos; /* current cube position */
540		int sflags; /* sign flags */
541		double t, dt;
542	<	register int i;
542	>	int i;
543
544		nrays++; /* increment trace counter */
545		sflags = 0;
#	Line 446 \| Line 550 \| *localhit( / check for hit in the octree /*
550		else if (r->rdir[i] < -1e-7)
551		sflags \|= 0x10 << i;
552		}
553	<	if (sflags == 0)
554	<	error(CONSISTENCY, "zero ray direction in localhit");
553	>	if (!sflags) {
554	>	error(WARNING, "zero ray direction in localhit");
555	>	return(0);
556	>	}
557		/* start off assuming nothing hit */
558		if (r->rmax > FTINY) { /* except aft plane if one */
559		r->ro = &Aftplane;
560		r->rot = r->rmax;
561	<	for (i = 0; i < 3; i++)
456	<	r->rop[i] = r->rorg[i] + r->rot*r->rdir[i];
561	>	VSUM(r->rop, r->rorg, r->rdir, r->rot);
562		}
563		/* find global cube entrance point */
564		t = 0.0;
#	Line 476 \| Line 581 \| *localhit( / check for hit in the octree /*
581		if (t >= r->rot) /* clipped already */
582		return(0);
583		/* advance position */
584	<	for (i = 0; i < 3; i++)
480	<	curpos[i] += r->rdir[i]*t;
584	>	VSUM(curpos, curpos, r->rdir, t);
585
586		if (!incube(scene, curpos)) /* non-intersecting ray */
587		return(0);
#	Line 493 \| Line 597 \| *raymove( / check for hit as we move /*
597		FVECT pos, /* current position, modified herein */
598		OBJECT cxs, / checked objects, modified by checkhit */
599		int dirf, /* direction indicators to speed tests */
600	<	register RAY *r,
601	<	register CUBE *cu
600	>	RAY *r,
601	>	CUBE *cu
602		)
603		{
604		int ax;
#	Line 502 \| Line 606 \| *raymove( / check for hit as we move /*
606
607		if (istree(cu->cutree)) { /* recurse on subcubes */
608		CUBE cukid;
609	<	register int br, sgn;
609	>	int br, sgn;
610
611		cukid.cusize = cu->cusize * 0.5; /* find subcube */
612		VCOPY(cukid.cuorg, cu->cuorg);
#	Line 568 \| Line 672 \| *raymove( / check for hit as we move /*
672		ax = 2;
673		}
674		}
675	<	pos[0] += r->rdir[0]*t;
572	<	pos[1] += r->rdir[1]*t;
573	<	pos[2] += r->rdir[2]*t;
675	>	VSUM(pos, pos, r->rdir, t);
676		return(ax);
677		}
678
679
680		static int
681		checkhit( /* check for hit in full cube */
682	<	register RAY *r,
682	>	RAY *r,
683		CUBE *cu,
684		OBJECT *cxs
685		)
#	Line 598 \| Line 700 \| *checkhit( / check for hit in full cube /*
700
701		static void
702		checkset( /* modify checked set and set to check */
703	<	register OBJECT os, / os' = os - cs */
704	<	register OBJECT cs / cs' = cs + os */
703	>	OBJECT os, / os' = os - cs */
704	>	OBJECT cs / cs' = cs + os */
705		)
706		{
707		OBJECT cset[MAXCSET+MAXSET+1];
708	<	register int i, j;
708	>	int i, j;
709		int k;
710		/* copy os in place, cset <- cs */
711		cset[0] = 0;

Diff Legend

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

Comparing ray/src/rt/raytrace.c (file contents): Revision 2.47 by greg, Thu Apr 14 18:04:12 2005 UTC vs. Revision 2.78 by greg, Wed Apr 3 16:04:33 2019 UTC

Diff Legend

Comparing ray/src/rt/raytrace.c (file contents):
Revision 2.47 by greg, Thu Apr 14 18:04:12 2005 UTC vs.
Revision 2.78 by greg, Wed Apr 3 16:04:33 2019 UTC