[ViewVC] Diff of: Development/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.73 by greg, Tue Nov 13 19:58:33 2018 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;
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	<	extern int
204	>	int
205		rayshade( /* shade ray r with material mod */
206	<	register RAY *r,
206	>	RAY *r,
207		int mod
208		)
209		{
210	<	register OBJREC *m;
210	>	OBJREC *m;
211
212	<	r->rt = r->rot; /* set effective ray length */
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
#	Line 175 \| Line 220 \| *rayshade( / shade ray r with material mod /*
220		******/
221		/* hack for irradiance calculation */
222		if (do_irrad && !(r->crtype & ~(PRIMARY\|TRANS)) &&
223	<	m->otype != MAT_CLIP &&
224	<	(ofun[m->otype].flags & (T_M\|T_X))) {
225	<	if (irr_ignore(m->otype)) {
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		}
#	Line 191 \| Line 236 \| *rayshade( / shade ray r with material mod /*
236		}
237
238
239	<	extern void
239	>	void
240		rayparticipate( /* compute ray medium participation */
241	<	register RAY *r
241	>	RAY *r
242		)
243		{
244		COLOR ce, ca;
#	Line 209 \| Line 254 \| *rayparticipate( / compute ray medium participation**
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	<	extern void
277	>	void
278		raytexture( /* get material modifiers */
279		RAY *r,
280		OBJECT mod
281		)
282		{
283	<	register OBJREC *m;
283	>	OBJREC *m;
284		/* execute textures and patterns */
285		for ( ; mod != OVOID; mod = m->omod) {
286		m = objptr(mod);
#	Line 249 \| Line 299 \| *raytexture( / get material modifiers /*
299		}
300
301
302	<	extern int
302	>	int
303		raymixture( /* mix modifiers */
304	<	register RAY *r,
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 269 \| Line 320 \| *raymixture( / mix modifiers /*
320		foremat = backmat = 0;
321		/* foreground */
322		fr = *r;
323	<	if (coef > FTINY)
323	>	if (coef > FTINY) {
324	>	fr.rweight *= coef;
325	>	scalecolor(fr.rcoef, coef);
326		foremat = rayshade(&fr, fore);
327	+	}
328		/* background */
329		br = *r;
330	<	if (coef < 1.0-FTINY)
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) {
337		if (backmat && coef > FTINY)
#	Line 298 \| Line 355 \| *raymixture( / mix modifiers /*
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	<	extern double
366	>	double
367		raydist( /* compute (cumulative) ray distance */
368	<	register RAY *r,
369	<	register int flags
368	>	const RAY *r,
369	>	int flags
370		)
371		{
372		double sum = 0.0;
#	Line 319 \| Line 379 \| *raydist( / compute (cumulative) ray distance /*
379		}
380
381
382	<	extern double
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( /* compute perturbed normal for ray */
410		FVECT norm,
411	<	register RAY *r
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 355 \| Line 441 \| *raynormal( / compute perturbed normal for ray /*
441		}
442
443
444	<	extern void
444	>	void
445		newrayxf( /* get new tranformation matrix for ray */
446		RAY *r
447		)
#	Line 364 \| Line 450 \| *newrayxf( / get new tranformation matrix for ray /*
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 376 \| Line 462 \| *newrayxf( / get new tranformation matrix for ray /*
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 393 \| Line 479 \| *newrayxf( / get new tranformation matrix for ray /*
479		}
480
481
482	<	extern void
482	>	void
483		flipsurface( /* reverse surface orientation */
484	<	register RAY *r
484	>	RAY *r
485		)
486		{
487		r->rod = -r->rod;
#	Line 408 \| Line 494 \| *flipsurface( / reverse surface orientation /*
494		}
495
496
497	<	extern void
497	>	void
498		rayhit( /* standard ray hit test */
499		OBJECT *oset,
500		RAY *r
#	Line 425 \| Line 511 \| *rayhit( / standard ray hit test /*
511		}
512
513
514	<	extern int
514	>	int
515		localhit( /* check for hit in the octree */
516	<	register RAY *r,
517	<	register CUBE *scene
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 446 \| Line 532 \| *localhit( / check for hit in the octree /*
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++)
456	<	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 476 \| Line 563 \| *localhit( / check for hit in the octree /*
563		if (t >= r->rot) /* clipped already */
564		return(0);
565		/* advance position */
566	<	for (i = 0; i < 3; i++)
480	<	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);
#	Line 493 \| Line 579 \| *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	<	register RAY *r,
583	<	register CUBE *cu
582	>	RAY *r,
583	>	CUBE *cu
584		)
585		{
586		int ax;
#	Line 502 \| Line 588 \| *raymove( / check for hit as we move /*
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 \| *raymove( / check for hit as we move /*
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( /* check for hit in full cube */
664	<	register RAY *r,
664	>	RAY *r,
665		CUBE *cu,
666		OBJECT *cxs
667		)
#	Line 598 \| Line 682 \| *checkhit( / check for hit in full cube /*
682
683		static void
684		checkset( /* modify checked set and set to check */
685	<	register OBJECT os, / os' = os - cs */
686	<	register OBJECT cs / cs' = cs + os */
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.47 by greg, Thu Apr 14 18:04:12 2005 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.47 by greg, Thu Apr 14 18:04:12 2005 UTC vs.
Revision 2.73 by greg, Tue Nov 13 19:58:33 2018 UTC