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

Comparing ray/src/rt/raytrace.c (file contents):
Revision 2.41 by schorsch, Mon Jul 21 22:30:19 2003 UTC vs.
Revision 2.95 by greg, Thu Feb 6 02:17:33 2025 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 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 SCOLOR rc
45	>	)
46		{
47	<	double re;
48	<
47	>	double rw, re;
48	>	/* assign coefficient/weight */
49	>	if (rc == NULL) {
50	>	rw = 1.0;
51	>	setscolor(r->rcoef, 1., 1., 1.);
52	>	} else {
53	>	rw = sintens((COLORV *)rc);
54	>	if (rw > 1.0)
55	>	rw = 1.0; /* avoid calculation growth */
56	>	if (rc != r->rcoef)
57	>	copyscolor(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*.99) {
72	+	memset(r, 0, sizeof(RAY));
73	+	return(-1); /* illegal continuation */
74	+	}
75		r->rlvl = ro->rlvl;
76	+	r->rsrc = ro->rsrc;
77		if (rt & RAYREFL) {
78		r->rlvl++;
79	<	r->rsrc = -1;
79	>	if (r->rsrc >= 0) /* malfunctioning material? */
80	>	r->rsrc = -1;
81		r->clipset = ro->clipset;
82		r->rmax = 0.0;
83		} else {
68	–	r->rsrc = ro->rsrc;
84		r->clipset = ro->newcset;
85	<	r->rmax = ro->rmax <= FTINY ? 0.0 : ro->rmax - ro->rot;
85	>	r->rmax = (ro->rmax > FTINY)*(ro->rmax - ro->rot);
86		}
87		r->revf = ro->revf;
88		copycolor(r->cext, ro->cext);
#	Line 77 \| Line 92 \| double rw;
92		r->crtype = ro->crtype \| (r->rtype = rt);
93		VCOPY(r->rorg, ro->rop);
94		r->rweight = ro->rweight * rw;
95	<	/* estimate absorption */
95	>	/* estimate extinction */
96		re = colval(ro->cext,RED) < colval(ro->cext,GRN) ?
97		colval(ro->cext,RED) : colval(ro->cext,GRN);
98		if (colval(ro->cext,BLU) < re) re = colval(ro->cext,BLU);
99	<	if (re > 0.)
100	<	r->rweight = exp(-rero->rot);
99	>	re *= ro->rot;
100	>	if (re > 0.1) {
101	>	if (re > 92.) {
102	>	r->rweight = 0.0;
103	>	} else {
104	>	r->rweight *= exp(-re);
105	>	}
106	>	}
107		}
108		rayclear(r);
109	<	return(r->rlvl <= maxdepth && r->rweight >= minweight ? 0 : -1);
109	>	if (r->rweight <= 0.0) /* check for expiration */
110	>	return(-1);
111	>	if (r->crtype & SHADOW) /* shadow commitment */
112	>	return(0);
113	>	/* ambient in photon map? */
114	>	if (ro != NULL && ro->crtype & AMBIENT) {
115	>	if (causticPhotonMapping)
116	>	return(-1);
117	>	if (photonMapping && rt != TRANS)
118	>	return(-1);
119	>	}
120	>	if ((maxdepth <= 0) & (rc != NULL)) { /* Russian roulette */
121	>	if (minweight <= 0.0)
122	>	error(USER, "zero ray weight in Russian roulette");
123	>	if ((maxdepth < 0) & (r->rlvl > -maxdepth))
124	>	return(-1); /* upper reflection limit */
125	>	if (r->rweight >= minweight)
126	>	return(0);
127	>	if (frandom() > r->rweight/minweight)
128	>	return(-1);
129	>	rw = minweight/r->rweight; /* promote survivor */
130	>	scalescolor(r->rcoef, rw);
131	>	r->rweight = minweight;
132	>	return(0);
133	>	}
134	>	return((r->rweight >= minweight) & (r->rlvl <= abs(maxdepth)) ? 0 : -1);
135		}
136
137
138		void
139	<	rayclear(r) /* clear a ray for (re)evaluation */
140	<	register RAY *r;
139	>	rayclear( /* clear a ray for (re)evaluation */
140	>	RAY *r
141	>	)
142		{
143		r->rno = raynum++;
144		r->newcset = r->clipset;
#	Line 99 \| Line 146 \| *register RAY r;**
146		r->robj = OVOID;
147		r->ro = NULL;
148		r->rox = NULL;
149	<	r->rt = r->rot = FHUGE;
149	>	r->rxt = r->rmt = r->rot = FHUGE;
150	>	VCOPY(r->rop, r->rorg);
151	>	r->ron[0] = -r->rdir[0]; r->ron[1] = -r->rdir[1]; r->ron[2] = -r->rdir[2];
152	>	r->rod = 1.0;
153		r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
154	+	r->rflips = 0;
155		r->uv[0] = r->uv[1] = 0.0;
156	<	setcolor(r->pcol, 1.0, 1.0, 1.0);
157	<	setcolor(r->rcol, 0.0, 0.0, 0.0);
156	>	setscolor(r->pcol, 1.0, 1.0, 1.0);
157	>	scolorblack(r->mcol);
158	>	scolorblack(r->rcol);
159		}
160
161
162		void
163	<	raytrace(r) /* trace a ray and compute its value */
164	<	RAY *r;
163	>	raytrace( /* trace a ray and compute its value */
164	>	RAY *r
165	>	)
166		{
167		if (localhit(r, &thescene))
168		raycont(r); /* hit local surface, evaluate */
#	Line 119 \| Line 172 \| *RAY r;**
172		} else if (sourcehit(r))
173		rayshade(r, r->ro->omod); /* distant source */
174
122	–	rayparticipate(r); /* for participating medium */
123	–
175		if (trace != NULL)
176		(trace)(r); / trace execution */
177	+
178	+	rayparticipate(r); /* for participating medium */
179		}
180
181
182		void
183	<	raycont(r) /* check for clipped object and continue */
184	<	register RAY *r;
183	>	raycont( /* check for clipped object and continue */
184	>	RAY *r
185	>	)
186		{
187		if ((r->clipset != NULL && inset(r->clipset, r->ro->omod)) \|\|
188		!rayshade(r, r->ro->omod))
#	Line 137 \| Line 191 \| *register RAY r;**
191
192
193		void
194	<	raytrans(r) /* transmit ray as is */
195	<	register RAY *r;
194	>	raytrans( /* transmit ray as is */
195	>	RAY *r
196	>	)
197		{
198		RAY tr;
199
200	<	if (rayorigin(&tr, r, TRANS, 1.0) == 0) {
201	<	VCOPY(tr.rdir, r->rdir);
202	<	rayvalue(&tr);
203	<	copycolor(r->rcol, tr.rcol);
204	<	r->rt = r->rot + tr.rt;
200	>	rayorigin(&tr, TRANS, r, NULL); /* always continue */
201	>	VCOPY(tr.rdir, r->rdir);
202	>	rayvalue(&tr);
203	>	copyscolor(r->mcol, tr.mcol);
204	>	copyscolor(r->rcol, tr.rcol);
205	>	r->rmt = r->rot + tr.rmt;
206	>	r->rxt = r->rot + tr.rxt;
207	>	}
208	>
209	>
210	>	int
211	>	raytirrad( /* irradiance hack */
212	>	OBJREC *m,
213	>	RAY *r
214	>	)
215	>	{
216	>	if (m->otype != MAT_CLIP && ismaterial(m->otype)) {
217	>	if (istransp(m) \|\| isBSDFproxy(m)) {
218	>	raytrans(r);
219	>	return(1);
220	>	}
221	>	if (!islight(m->otype)) {
222	>	setscolor(r->pcol, 1.0, 1.0, 1.0);
223	>	return((*ofun[Lamb.otype].funp)(&Lamb, r));
224	>	}
225		}
226	+	return(0); /* not a qualifying surface */
227		}
228
229
230		int
231	<	rayshade(r, mod) /* shade ray r with material mod */
232	<	register RAY *r;
233	<	int mod;
231	>	rayshade( /* shade ray r with material mod */
232	>	RAY *r,
233	>	int mod
234	>	)
235		{
236	<	int gotmat;
237	<	register OBJREC *m;
238	<	#if MAXLOOP
239	<	static int depth = 0;
240	<	/* 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) {
236	>	int tst_irrad = do_irrad && !(r->crtype & ~(PRIMARY\|TRANS));
237	>	OBJREC *m;
238	>
239	>	r->rxt = r->rot; /* preset effective ray length */
240	>	for ( ; mod != OVOID; mod = m->omod) {
241		m = objptr(mod);
242		/****** unnecessary test since modifier() is always called
243		if (!ismodifier(m->otype)) {
#	Line 174 \| Line 246 \| int mod;
246		}
247		******/
248		/* hack for irradiance calculation */
249	<	if (do_irrad && !(r->crtype & ~(PRIMARY\|TRANS)) &&
250	<	(ofun[m->otype].flags & (T_M\|T_X))) {
251	<	if (irr_ignore(m->otype)) {
252	<	#if MAXLOOP
253	<	depth--;
182	<	#endif
183	<	raytrans(r);
184	<	return(1);
185	<	}
186	<	if (!islight(m->otype))
187	<	m = &Lamb;
188	<	}
189	<	/* materials call raytexture */
190	<	gotmat = (*ofun[m->otype].funp)(m, r);
249	>	if (tst_irrad && raytirrad(m, r))
250	>	return(1);
251	>
252	>	if ((*ofun[m->otype].funp)(m, r))
253	>	return(1); /* materials call raytexture() */
254		}
255	<	#if MAXLOOP
193	<	depth--;
194	<	#endif
195	<	return(gotmat);
255	>	return(0); /* no material! */
256		}
257
258
259		void
260	<	rayparticipate(r) /* compute ray medium participation */
261	<	register RAY *r;
260	>	rayparticipate( /* compute ray medium participation */
261	>	RAY *r
262	>	)
263		{
264	<	COLOR ce, ca;
264	>	SCOLOR ce, ca;
265		double re, ge, be;
266
267		if (intens(r->cext) <= 1./FHUGE)
#	Line 213 \| Line 274 \| *register RAY r;**
274		ge *= 1. - colval(r->albedo,GRN);
275		be *= 1. - colval(r->albedo,BLU);
276		}
277	<	setcolor(ce, re<=0. ? 1. : re>92. ? 0. : exp(-re),
278	<	ge<=0. ? 1. : ge>92. ? 0. : exp(-ge),
279	<	be<=0. ? 1. : be>92. ? 0. : exp(-be));
280	<	multcolor(r->rcol, ce); /* path absorption */
277	>	setscolor(ce, re<=FTINY ? 1. : re>92. ? 0. : exp(-re),
278	>	ge<=FTINY ? 1. : ge>92. ? 0. : exp(-ge),
279	>	be<=FTINY ? 1. : be>92. ? 0. : exp(-be));
280	>	smultscolor(r->rcol, ce); /* path extinction */
281		if (r->crtype & SHADOW \|\| intens(r->albedo) <= FTINY)
282		return; /* no scattering */
283	<	setcolor(ca,
284	<	colval(r->albedo,RED)colval(ambval,RED)(1.-colval(ce,RED)),
285	<	colval(r->albedo,GRN)colval(ambval,GRN)(1.-colval(ce,GRN)),
286	<	colval(r->albedo,BLU)colval(ambval,BLU)(1.-colval(ce,BLU)));
287	<	addcolor(r->rcol, ca); /* ambient in scattering */
283	>
284	>	/* PMAP: indirect inscattering accounted for by volume photons? */
285	>	if (!volumePhotonMapping) {
286	>	setscolor(ca,
287	>	colval(r->albedo,RED)colval(ambval,RED)(1.-scolval(ce,RED)),
288	>	colval(r->albedo,GRN)colval(ambval,GRN)(1.-scolval(ce,GRN)),
289	>	colval(r->albedo,BLU)colval(ambval,BLU)(1.-scolval(ce,BLU)));
290	>	saddscolor(r->rcol, ca); /* ambient in scattering */
291	>	}
292	>
293		srcscatter(r); /* source in scattering */
294		}
295
296
297		void
298	<	raytexture(r, mod) /* get material modifiers */
299	<	RAY *r;
300	<	OBJECT mod;
298	>	raytexture( /* get material modifiers */
299	>	RAY *r,
300	>	OBJECT mod
301	>	)
302		{
303	<	register OBJREC *m;
237	<	#if MAXLOOP
238	<	static int depth = 0;
239	<	/* check for infinite loop */
240	<	if (depth++ >= MAXLOOP)
241	<	objerror(r->ro, USER, "modifier loop");
242	<	#endif
303	>	OBJREC *m;
304		/* execute textures and patterns */
305		for ( ; mod != OVOID; mod = m->omod) {
306		m = objptr(mod);
#	Line 255 \| Line 316 \| OBJECT mod;
316		objerror(r->ro, USER, errmsg);
317		}
318		}
258	–	#if MAXLOOP
259	–	depth--; /* end here */
260	–	#endif
319		}
320
321
322		int
323	<	raymixture(r, fore, back, coef) /* mix modifiers */
324	<	register RAY *r;
325	<	OBJECT fore, back;
326	<	double coef;
323	>	raymixture( /* mix modifiers */
324	>	RAY *r,
325	>	OBJECT fore,
326	>	OBJECT back,
327	>	double coef
328	>	)
329		{
330		RAY fr, br;
331	+	double mfore, mback;
332		int foremat, backmat;
333	<	register int i;
333	>	int i;
334		/* bound coefficient */
335		if (coef > 1.0)
336		coef = 1.0;
#	Line 279 \| Line 340 \| double coef;
340		foremat = backmat = 0;
341		/* foreground */
342		fr = *r;
343	<	if (coef > FTINY)
343	>	if (coef > FTINY) {
344	>	fr.rweight *= coef;
345	>	scalescolor(fr.rcoef, coef);
346		foremat = rayshade(&fr, fore);
347	+	}
348		/* background */
349		br = *r;
350	<	if (coef < 1.0-FTINY)
350	>	if (coef < 1.0-FTINY) {
351	>	br.rweight *= 1.0-coef;
352	>	scalescolor(br.rcoef, 1.0-coef);
353		backmat = rayshade(&br, back);
354	+	}
355		/* check for transparency */
356		if (backmat ^ foremat) {
357		if (backmat && coef > FTINY)
#	Line 296 \| Line 363 \| double coef;
363		for (i = 0; i < 3; i++)
364		r->pert[i] = coeffr.pert[i] + (1.0-coef)br.pert[i];
365		/* mix pattern colors */
366	<	scalecolor(fr.pcol, coef);
367	<	scalecolor(br.pcol, 1.0-coef);
368	<	copycolor(r->pcol, fr.pcol);
369	<	addcolor(r->pcol, br.pcol);
366	>	scalescolor(fr.pcol, coef);
367	>	scalescolor(br.pcol, 1.0-coef);
368	>	copyscolor(r->pcol, fr.pcol);
369	>	saddscolor(r->pcol, br.pcol);
370		/* return value tells if material */
371		if (!foremat & !backmat)
372		return(0);
373		/* mix returned ray values */
374	<	scalecolor(fr.rcol, coef);
375	<	scalecolor(br.rcol, 1.0-coef);
376	<	copycolor(r->rcol, fr.rcol);
377	<	addcolor(r->rcol, br.rcol);
378	<	r->rt = bright(fr.rcol) > bright(br.rcol) ? fr.rt : br.rt;
374	>	scalescolor(fr.rcol, coef);
375	>	scalescolor(br.rcol, 1.0-coef);
376	>	copyscolor(r->rcol, fr.rcol);
377	>	saddscolor(r->rcol, br.rcol);
378	>	scalescolor(fr.mcol, coef);
379	>	scalescolor(br.mcol, 1.0-coef);
380	>	copyscolor(r->mcol, fr.mcol);
381	>	saddscolor(r->mcol, br.mcol);
382	>	mfore = pbright(fr.mcol); mback = pbright(br.mcol);
383	>	r->rmt = mfore > mback ? fr.rmt : br.rmt;
384	>	r->rxt = pbright(fr.rcol)-mfore > pbright(br.rcol)-mback ?
385	>	fr.rxt : br.rxt;
386		return(1);
387		}
388
389
390		double
391	<	raydist(r, flags) /* compute (cumulative) ray distance */
392	<	register RAY *r;
393	<	register int flags;
391	>	raydist( /* compute (cumulative) ray distance */
392	>	const RAY *r,
393	>	int flags
394	>	)
395		{
396		double sum = 0.0;
397
#	Line 328 \| Line 403 \| register int flags;
403		}
404
405
406	+	void
407	+	raycontrib( /* compute (cumulative) ray contribution */
408	+	SCOLOR rc,
409	+	const RAY *r,
410	+	int flags
411	+	)
412	+	{
413	+	static int warnedPM = 0;
414	+
415	+	setscolor(rc, 1., 1., 1.);
416	+
417	+	while (r != NULL && r->crtype&flags) {
418	+	smultscolor(rc, r->rcoef);
419	+	/* check for participating medium */
420	+	if (bright(r->cext) > FTINY) {
421	+	double re = r->rot*colval(r->cext,RED),
422	+	ge = r->rot*colval(r->cext,GRN),
423	+	be = r->rot*colval(r->cext,BLU);
424	+	SCOLOR ce;
425	+	setscolor(ce, re<=FTINY ? 1. : re>92. ? 0. : exp(-re),
426	+	ge<=FTINY ? 1. : ge>92. ? 0. : exp(-ge),
427	+	be<=FTINY ? 1. : be>92. ? 0. : exp(-be));
428	+	smultscolor(rc, ce);
429	+	}
430	+	if (!warnedPM && bright(r->albedo) > FTINY) {
431	+	error(WARNING,
432	+	"ray contribution calculation does not support participating media");
433	+	warnedPM++;
434	+	}
435	+	r = r->parent;
436	+	}
437	+	}
438	+
439	+
440		double
441	<	raynormal(norm, r) /* compute perturbed normal for ray */
442	<	FVECT norm;
443	<	register RAY *r;
441	>	raynormal( /* compute perturbed normal for ray */
442	>	FVECT norm,
443	>	RAY *r
444	>	)
445		{
446		double newdot;
447	<	register int i;
447	>	int i;
448
449		/* The perturbation is added to the surface normal to obtain
450		* the new normal. If the new normal would affect the surface
#	Line 354 \| Line 464 \| *register RAY r;**
464		return(r->rod);
465		}
466		newdot = -DOT(norm, r->rdir);
467	<	if ((newdot > 0.0) != (r->rod > 0.0)) { /* fix orientation */
467	>	if ((newdot > 0.0) ^ (r->rod > 0.0)) { /* fix orientation */
468		for (i = 0; i < 3; i++)
469		norm[i] += 2.0newdotr->rdir[i];
470		newdot = -newdot;
#	Line 364 \| Line 474 \| *register RAY r;**
474
475
476		void
477	<	newrayxf(r) /* get new tranformation matrix for ray */
478	<	RAY *r;
477	>	newrayxf( /* get new tranformation matrix for ray */
478	>	RAY *r
479	>	)
480		{
481		static struct xfn {
482		struct xfn *next;
483		FULLXF xf;
484		} xfseed = { &xfseed }, *xflast = &xfseed;
485	<	register struct xfn *xp;
486	<	register RAY *rp;
485	>	struct xfn *xp;
486	>	const RAY *rp;
487
488		/*
489		* Search for transform in circular list that
#	Line 383 \| Line 494 \| *RAY r;**
494		if (rp->rox == &xp->xf) { /* xp in use */
495		xp = xp->next; /* move to next */
496		if (xp == xflast) { /* need new one */
497	<	xp = (struct xfn *)malloc(sizeof(struct xfn));
497	>	xp = (struct xfn *)bmalloc(sizeof(struct xfn));
498		if (xp == NULL)
499		error(SYSTEM,
500		"out of memory in newrayxf");
#	Line 401 \| Line 512 \| *RAY r;**
512
513
514		void
515	<	flipsurface(r) /* reverse surface orientation */
516	<	register RAY *r;
515	>	flipsurface( /* reverse surface orientation */
516	>	RAY *r
517	>	)
518		{
519		r->rod = -r->rod;
520		r->ron[0] = -r->ron[0];
#	Line 411 \| Line 523 \| *register RAY r;**
523		r->pert[0] = -r->pert[0];
524		r->pert[1] = -r->pert[1];
525		r->pert[2] = -r->pert[2];
526	+	r->rflips++;
527		}
528
529
530	+	int
531	+	rayreject( /* check if candidate hit is worse than current */
532	+	OBJREC *o,
533	+	RAY *r,
534	+	double t,
535	+	double rod
536	+	)
537	+	{
538	+	OBJREC mnew, mray;
539	+
540	+	if ((t <= FTINY) \| (t > r->rot + FTINY))
541	+	return(1);
542	+	if (t < r->rot - FTINY) /* is new hit significantly closer? */
543	+	return(0);
544	+	/* coincident point, so decide... */
545	+	if (o == r->ro)
546	+	return(1); /* shouldn't happen */
547	+	if (r->ro == NULL)
548	+	return(0); /* ditto */
549	+	mnew = findmaterial(o);
550	+	mray = findmaterial(r->ro); /* check material transparencies */
551	+	if (mnew == NULL) {
552	+	if (mray != NULL)
553	+	return(1); /* old has material, new does not */
554	+	} else if (mray == NULL) {
555	+	return(0); /* new has material, old does not */
556	+	} else if (istransp(mnew)) {
557	+	if (!istransp(mray))
558	+	return(1); /* new is transparent, old is not */
559	+	} else if (istransp(mray)) {
560	+	return(0); /* old is transparent, new is not */
561	+	}
562	+	if (rod <= 0) { /* check which side we hit */
563	+	if (r->rod > 0)
564	+	return(1); /* old hit front, new did not */
565	+	} else if (r->rod <= 0) {
566	+	return(0); /* new hit front, old did not */
567	+	}
568	+	/* earlier modifier definition wins tie */
569	+	return (r->ro->omod >= o->omod);
570	+	}
571	+
572		void
573	<	rayhit(oset, r) /* standard ray hit test */
574	<	OBJECT *oset;
575	<	RAY *r;
573	>	rayhit( /* standard ray hit test */
574	>	OBJECT *oset,
575	>	RAY *r
576	>	)
577		{
578		OBJREC *o;
579		int i;
#	Line 431 \| Line 587 \| *RAY r;**
587
588
589		int
590	<	localhit(r, scene) /* check for hit in the octree */
591	<	register RAY *r;
592	<	register CUBE *scene;
590	>	localhit( /* check for hit in the octree */
591	>	RAY *r,
592	>	CUBE *scene
593	>	)
594		{
595		OBJECT cxset[MAXCSET+1]; /* set of checked objects */
596		FVECT curpos; /* current cube position */
597		int sflags; /* sign flags */
598		double t, dt;
599	<	register int i;
599	>	int i;
600
601		nrays++; /* increment trace counter */
602		sflags = 0;
#	Line 450 \| Line 607 \| *register CUBE scene;**
607		else if (r->rdir[i] < -1e-7)
608		sflags \|= 0x10 << i;
609		}
610	<	if (sflags == 0)
611	<	error(CONSISTENCY, "zero ray direction in localhit");
610	>	if (!sflags) {
611	>	error(WARNING, "zero ray direction in localhit");
612	>	return(0);
613	>	}
614		/* start off assuming nothing hit */
615		if (r->rmax > FTINY) { /* except aft plane if one */
616		r->ro = &Aftplane;
617		r->rot = r->rmax;
618	<	for (i = 0; i < 3; i++)
460	<	r->rop[i] = r->rorg[i] + r->rot*r->rdir[i];
618	>	VSUM(r->rop, r->rorg, r->rdir, r->rot);
619		}
620		/* find global cube entrance point */
621		t = 0.0;
#	Line 480 \| Line 638 \| *register CUBE scene;**
638		if (t >= r->rot) /* clipped already */
639		return(0);
640		/* advance position */
641	<	for (i = 0; i < 3; i++)
484	<	curpos[i] += r->rdir[i]*t;
641	>	VSUM(curpos, curpos, r->rdir, t);
642
643		if (!incube(scene, curpos)) /* non-intersecting ray */
644		return(0);
645		}
646		cxset[0] = 0;
647		raymove(curpos, cxset, sflags, r, scene);
648	<	return(r->ro != NULL & r->ro != &Aftplane);
648	>	return((r->ro != NULL) & (r->ro != &Aftplane));
649		}
650
651
652		static int
653	<	raymove(pos, cxs, dirf, r, cu) /* check for hit as we move */
654	<	FVECT pos; /* current position, modified herein */
655	<	OBJECT cxs; / checked objects, modified by checkhit */
656	<	int dirf; /* direction indicators to speed tests */
657	<	register RAY *r;
658	<	register CUBE *cu;
653	>	raymove( /* check for hit as we move */
654	>	FVECT pos, /* current position, modified herein */
655	>	OBJECT cxs, / checked objects, modified by checkhit */
656	>	int dirf, /* direction indicators to speed tests */
657	>	RAY *r,
658	>	CUBE *cu
659	>	)
660		{
661		int ax;
662		double dt, t;
663
664		if (istree(cu->cutree)) { /* recurse on subcubes */
665		CUBE cukid;
666	<	register int br, sgn;
666	>	int br, sgn;
667
668		cukid.cusize = cu->cusize * 0.5; /* find subcube */
669		VCOPY(cukid.cuorg, cu->cuorg);
#	Line 571 \| Line 729 \| *register CUBE cu;**
729		ax = 2;
730		}
731		}
732	<	pos[0] += r->rdir[0]*t;
575	<	pos[1] += r->rdir[1]*t;
576	<	pos[2] += r->rdir[2]*t;
732	>	VSUM(pos, pos, r->rdir, t);
733		return(ax);
734		}
735
736
737		static int
738	<	checkhit(r, cu, cxs) /* check for hit in full cube */
739	<	register RAY *r;
740	<	CUBE *cu;
741	<	OBJECT *cxs;
738	>	checkhit( /* check for hit in full cube */
739	>	RAY *r,
740	>	CUBE *cu,
741	>	OBJECT *cxs
742	>	)
743		{
744		OBJECT oset[MAXSET+1];
745
#	Line 599 \| Line 756 \| *OBJECT cxs;**
756
757
758		static void
759	<	checkset(os, cs) /* modify checked set and set to check */
760	<	register OBJECT os; / os' = os - cs */
761	<	register OBJECT cs; / cs' = cs + os */
759	>	checkset( /* modify checked set and set to check */
760	>	OBJECT os, / os' = os - cs */
761	>	OBJECT cs / cs' = cs + os */
762	>	)
763		{
764		OBJECT cset[MAXCSET+MAXSET+1];
765	<	register int i, j;
765	>	int i, j;
766		int k;
767		/* copy os in place, cset <- cs */
768		cset[0] = 0;

Diff Legend

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

Comparing ray/src/rt/raytrace.c (file contents): Revision 2.41 by schorsch, Mon Jul 21 22:30:19 2003 UTC vs. Revision 2.95 by greg, Thu Feb 6 02:17:33 2025 UTC

Diff Legend

Comparing ray/src/rt/raytrace.c (file contents):
Revision 2.41 by schorsch, Mon Jul 21 22:30:19 2003 UTC vs.
Revision 2.95 by greg, Thu Feb 6 02:17:33 2025 UTC