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

Comparing ray/src/rt/raytrace.c (file contents):
Revision 2.31 by gwlarson, Wed Jun 17 12:53:06 1998 UTC vs.
Revision 2.96 by greg, Fri Feb 7 16:32:56 2025 UTC

#	Line 1 \| Line 1
1	–	/* Copyright (c) 1998 Silicon Graphics, Inc. */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ SGI";
2	>	static const char RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		* raytrace.c - routines for tracing and shading rays.
6		*
7	<	* 8/7/85
7	>	* External symbols declared in ray.h
8		*/
9
10	<	#include "ray.h"
10	>	#include "copyright.h"
11
12	<	#include "octree.h"
13	<
12	>	#include "ray.h"
13	>	#include "source.h"
14		#include "otypes.h"
18	–
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	<	extern CUBE thescene; /* our scene */
22	<	extern int maxdepth; /* maximum recursion depth */
25	<	extern double minweight; /* minimum ray weight */
26	<	extern int do_irrad; /* compute irradiance? */
27	<	extern COLOR ambval; /* ambient value */
21	>	RNUMBER raynum = 0; /* next unique ray number */
22	>	RNUMBER nrays = 0; /* number of calls to localhit */
23
24	<	extern COLOR cextinction; /* global extinction coefficient */
30	<	extern COLOR salbedo; /* global scattering albedo */
31	<	extern double seccg; /* global scattering eccentricity */
32	<	extern double ssampdist; /* scatter sampling distance */
33	<
34	<	unsigned long raynum = 0; /* next unique ray number */
35	<	unsigned long nrays = 0; /* number of calls to localhit */
36	<
37	<	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
45	–	static int raymove(), checkset(), checkhit();
46	–
47	–	#define MAXLOOP 128 /* modifier loop detection */
48	–
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
52	–	rayorigin(r, ro, rt, rw) /* start new ray from old one */
53	–	register RAY r, ro;
54	–	int rt;
55	–	double rw;
56	–	{
57	–	double re;
38
39	+	int
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 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 68 \| 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 {
78	–	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 87 \| 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	<	rayclear(r) /* clear a ray for (re)evaluation */
139	<	register RAY *r;
138	>	void
139	>	rayclear( /* clear a ray for (re)evaluation */
140	>	RAY *r
141	>	)
142		{
143		r->rno = raynum++;
144		r->newcset = r->clipset;
145	+	r->hitf = rayhit;
146		r->robj = OVOID;
147		r->ro = NULL;
148	<	r->rt = r->rot = FHUGE;
148	>	r->rox = NULL;
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	<	setcolor(r->pcol, 1.0, 1.0, 1.0);
155	<	setcolor(r->rcol, 0.0, 0.0, 0.0);
154	>	r->rflips = 0;
155	>	r->uv[0] = r->uv[1] = 0.0;
156	>	setscolor(r->pcol, 1.0, 1.0, 1.0);
157	>	scolorblack(r->mcol);
158	>	scolorblack(r->rcol);
159		}
160
161
162	<	raytrace(r) /* trace a ray and compute its value */
163	<	RAY *r;
162	>	void
163	>	raytrace( /* trace a ray and compute its value */
164	>	RAY *r
165	>	)
166		{
119	–	extern int (*trace)();
120	–
167		if (localhit(r, &thescene))
168		raycont(r); /* hit local surface, evaluate */
169		else if (r->ro == &Aftplane) {
#	Line 126 \| Line 172 \| *RAY r;**
172		} else if (sourcehit(r))
173		rayshade(r, r->ro->omod); /* distant source */
174
129	–	rayparticipate(r); /* for participating medium */
130	–
175		if (trace != NULL)
176		(trace)(r); / trace execution */
177	+
178	+	rayparticipate(r); /* for participating medium */
179		}
180
181
182	<	raycont(r) /* check for clipped object and continue */
183	<	register RAY *r;
182	>	void
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 142 \| Line 190 \| *register RAY r;**
190		}
191
192
193	<	raytrans(r) /* transmit ray as is */
194	<	register RAY *r;
193	>	void
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	<	rayshade(r, mod) /* shade ray r with material mod */
231	<	register RAY *r;
232	<	int mod;
230	>	int
231	>	rayshade( /* shade ray r with material mod */
232	>	RAY *r,
233	>	int mod
234	>	)
235		{
236	<	static int depth = 0;
237	<	int gotmat;
238	<	register OBJREC *m;
239	<	/* check for infinite loop */
240	<	if (depth++ >= MAXLOOP)
168	<	objerror(r->ro, USER, "possible modifier loop");
169	<	r->rt = r->rot; /* set effective ray length */
170	<	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 176 \| Line 246 \| int mod;
246		}
247		******/
248		/* hack for irradiance calculation */
249	<	if (do_irrad && !(r->crtype & ~(PRIMARY\|TRANS))) {
250	<	if (irr_ignore(m->otype)) {
251	<	depth--;
252	<	raytrans(r);
253	<	return(1);
184	<	}
185	<	if (!islight(m->otype))
186	<	m = &Lamb;
187	<	}
188	<	/* materials call raytexture */
189	<	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	<	depth--;
192	<	return(gotmat);
255	>	return(0); /* no material! */
256		}
257
258
259	<	rayparticipate(r) /* compute ray medium participation */
260	<	register RAY *r;
259	>	void
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 209 \| 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	<	raytexture(r, mod) /* get material modifiers */
298	<	RAY *r;
299	<	int mod;
297	>	void
298	>	raytexture( /* get material modifiers */
299	>	RAY *r,
300	>	OBJECT mod
301	>	)
302		{
303	<	static int depth = 0;
232	<	register OBJREC *m;
233	<	/* check for infinite loop */
234	<	if (depth++ >= MAXLOOP)
235	<	objerror(r->ro, USER, "modifier loop");
303	>	OBJREC *m;
304		/* execute textures and patterns */
305		for ( ; mod != OVOID; mod = m->omod) {
306		m = objptr(mod);
#	Line 248 \| Line 316 \| int mod;
316		objerror(r->ro, USER, errmsg);
317		}
318		}
251	–	depth--; /* end here */
319		}
320
321
322	<	raymixture(r, fore, back, coef) /* mix modifiers */
323	<	register RAY *r;
324	<	OBJECT fore, back;
325	<	double coef;
322	>	int
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 268 \| Line 339 \| double coef;
339		/* compute foreground and background */
340		foremat = backmat = 0;
341		/* foreground */
342	<	copystruct(&fr, r);
343	<	if (coef > FTINY)
342	>	fr = *r;
343	>	if (coef > FTINY) {
344	>	fr.rweight *= coef;
345	>	scalescolor(fr.rcoef, coef);
346		foremat = rayshade(&fr, fore);
347	+	}
348		/* background */
349	<	copystruct(&br, r);
350	<	if (coef < 1.0-FTINY)
349	>	br = *r;
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)
356	>	if (backmat ^ foremat) {
357		if (backmat && coef > FTINY)
358		raytrans(&fr);
359		else if (foremat && coef < 1.0-FTINY)
360		raytrans(&br);
361	+	}
362		/* mix perturbations */
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 317 \| 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	+	double re, ge, be;
415	+	SCOLOR ce;
416	+
417	+	setscolor(rc, 1., 1., 1.);
418	+	re = ge = be = 0.;
419	+
420	+	while (r != NULL && r->crtype&flags) {
421	+	/* include this ray coefficient */
422	+	smultscolor(rc, r->rcoef);
423	+	/* check participating medium */
424	+	if (!warnedPM && bright(r->albedo) > FTINY) {
425	+	error(WARNING,
426	+	"ray contribution calculation does not support participating media");
427	+	warnedPM++;
428	+	}
429	+	/* sum PM extinction */
430	+	re += r->rot*colval(r->cext,RED);
431	+	ge += r->rot*colval(r->cext,GRN);
432	+	be += r->rot*colval(r->cext,BLU);
433	+	/* descend the tree */
434	+	r = r->parent;
435	+	}
436	+	/* cumulative extinction */
437	+	setscolor(ce, re<=FTINY ? 1. : re>92. ? 0. : exp(-re),
438	+	ge<=FTINY ? 1. : ge>92. ? 0. : exp(-ge),
439	+	be<=FTINY ? 1. : be>92. ? 0. : exp(-be));
440	+	smultscolor(rc, ce);
441	+	}
442	+
443	+
444		double
445	<	raynormal(norm, r) /* compute perturbed normal for ray */
446	<	FVECT norm;
447	<	register RAY *r;
445	>	raynormal( /* compute perturbed normal for ray */
446	>	FVECT norm,
447	>	RAY *r
448	>	)
449		{
450		double newdot;
451	<	register int i;
451	>	int i;
452
453		/* The perturbation is added to the surface normal to obtain
454		* the new normal. If the new normal would affect the surface
#	Line 343 \| Line 468 \| *register RAY r;**
468		return(r->rod);
469		}
470		newdot = -DOT(norm, r->rdir);
471	<	if ((newdot > 0.0) != (r->rod > 0.0)) { /* fix orientation */
471	>	if ((newdot > 0.0) ^ (r->rod > 0.0)) { /* fix orientation */
472		for (i = 0; i < 3; i++)
473		norm[i] += 2.0newdotr->rdir[i];
474		newdot = -newdot;
#	Line 352 \| Line 477 \| *register RAY r;**
477		}
478
479
480	<	newrayxf(r) /* get new tranformation matrix for ray */
481	<	RAY *r;
480	>	void
481	>	newrayxf( /* get new tranformation matrix for ray */
482	>	RAY *r
483	>	)
484		{
485		static struct xfn {
486		struct xfn *next;
487		FULLXF xf;
488		} xfseed = { &xfseed }, *xflast = &xfseed;
489	<	register struct xfn *xp;
490	<	register RAY *rp;
489	>	struct xfn *xp;
490	>	const RAY *rp;
491
492		/*
493		* Search for transform in circular list that
#	Line 388 \| Line 515 \| *RAY r;**
515		}
516
517
518	<	flipsurface(r) /* reverse surface orientation */
519	<	register RAY *r;
518	>	void
519	>	flipsurface( /* reverse surface orientation */
520	>	RAY *r
521	>	)
522		{
523		r->rod = -r->rod;
524		r->ron[0] = -r->ron[0];
#	Line 398 \| Line 527 \| *register RAY r;**
527		r->pert[0] = -r->pert[0];
528		r->pert[1] = -r->pert[1];
529		r->pert[2] = -r->pert[2];
530	+	r->rflips++;
531		}
532
533
534	<	localhit(r, scene) /* check for hit in the octree */
535	<	register RAY *r;
536	<	register CUBE *scene;
534	>	int
535	>	rayreject( /* check if candidate hit is worse than current */
536	>	OBJREC *o,
537	>	RAY *r,
538	>	double t,
539	>	double rod
540	>	)
541		{
542	+	OBJREC mnew, mray;
543	+
544	+	if ((t <= FTINY) \| (t > r->rot + FTINY))
545	+	return(1);
546	+	if (t < r->rot - FTINY) /* is new hit significantly closer? */
547	+	return(0);
548	+	/* coincident point, so decide... */
549	+	if (o == r->ro)
550	+	return(1); /* shouldn't happen */
551	+	if (r->ro == NULL)
552	+	return(0); /* ditto */
553	+	mnew = findmaterial(o);
554	+	mray = findmaterial(r->ro); /* check material transparencies */
555	+	if (mnew == NULL) {
556	+	if (mray != NULL)
557	+	return(1); /* old has material, new does not */
558	+	} else if (mray == NULL) {
559	+	return(0); /* new has material, old does not */
560	+	} else if (istransp(mnew)) {
561	+	if (!istransp(mray))
562	+	return(1); /* new is transparent, old is not */
563	+	} else if (istransp(mray)) {
564	+	return(0); /* old is transparent, new is not */
565	+	}
566	+	if (rod <= 0) { /* check which side we hit */
567	+	if (r->rod > 0)
568	+	return(1); /* old hit front, new did not */
569	+	} else if (r->rod <= 0) {
570	+	return(0); /* new hit front, old did not */
571	+	}
572	+	/* earlier modifier definition wins tie */
573	+	return (r->ro->omod >= o->omod);
574	+	}
575	+
576	+	void
577	+	rayhit( /* standard ray hit test */
578	+	OBJECT *oset,
579	+	RAY *r
580	+	)
581	+	{
582	+	OBJREC *o;
583	+	int i;
584	+
585	+	for (i = oset[0]; i > 0; i--) {
586	+	o = objptr(oset[i]);
587	+	if ((*ofun[o->otype].funp)(o, r))
588	+	r->robj = oset[i];
589	+	}
590	+	}
591	+
592	+
593	+	int
594	+	localhit( /* check for hit in the octree */
595	+	RAY *r,
596	+	CUBE *scene
597	+	)
598	+	{
599		OBJECT cxset[MAXCSET+1]; /* set of checked objects */
600		FVECT curpos; /* current cube position */
601		int sflags; /* sign flags */
602		double t, dt;
603	<	register int i;
603	>	int i;
604
605		nrays++; /* increment trace counter */
606		sflags = 0;
#	Line 420 \| Line 611 \| *register CUBE scene;**
611		else if (r->rdir[i] < -1e-7)
612		sflags \|= 0x10 << i;
613		}
614	<	if (sflags == 0)
615	<	error(CONSISTENCY, "zero ray direction in localhit");
614	>	if (!sflags) {
615	>	error(WARNING, "zero ray direction in localhit");
616	>	return(0);
617	>	}
618		/* start off assuming nothing hit */
619		if (r->rmax > FTINY) { /* except aft plane if one */
620		r->ro = &Aftplane;
621		r->rot = r->rmax;
622	<	for (i = 0; i < 3; i++)
430	<	r->rop[i] = r->rorg[i] + r->rot*r->rdir[i];
622	>	VSUM(r->rop, r->rorg, r->rdir, r->rot);
623		}
624		/* find global cube entrance point */
625		t = 0.0;
#	Line 450 \| Line 642 \| *register CUBE scene;**
642		if (t >= r->rot) /* clipped already */
643		return(0);
644		/* advance position */
645	<	for (i = 0; i < 3; i++)
454	<	curpos[i] += r->rdir[i]*t;
645	>	VSUM(curpos, curpos, r->rdir, t);
646
647		if (!incube(scene, curpos)) /* non-intersecting ray */
648		return(0);
649		}
650		cxset[0] = 0;
651		raymove(curpos, cxset, sflags, r, scene);
652	<	return(r->ro != NULL & r->ro != &Aftplane);
652	>	return((r->ro != NULL) & (r->ro != &Aftplane));
653		}
654
655
656		static int
657	<	raymove(pos, cxs, dirf, r, cu) /* check for hit as we move */
658	<	FVECT pos; /* current position, modified herein */
659	<	OBJECT cxs; / checked objects, modified by checkhit */
660	<	int dirf; /* direction indicators to speed tests */
661	<	register RAY *r;
662	<	register CUBE *cu;
657	>	raymove( /* check for hit as we move */
658	>	FVECT pos, /* current position, modified herein */
659	>	OBJECT cxs, / checked objects, modified by checkhit */
660	>	int dirf, /* direction indicators to speed tests */
661	>	RAY *r,
662	>	CUBE *cu
663	>	)
664		{
665		int ax;
666		double dt, t;
667
668		if (istree(cu->cutree)) { /* recurse on subcubes */
669		CUBE cukid;
670	<	register int br, sgn;
670	>	int br, sgn;
671
672		cukid.cusize = cu->cusize * 0.5; /* find subcube */
673		VCOPY(cukid.cuorg, cu->cuorg);
#	Line 541 \| Line 733 \| *register CUBE cu;**
733		ax = 2;
734		}
735		}
736	<	pos[0] += r->rdir[0]*t;
545	<	pos[1] += r->rdir[1]*t;
546	<	pos[2] += r->rdir[2]*t;
736	>	VSUM(pos, pos, r->rdir, t);
737		return(ax);
738		}
739
740
741	<	static
742	<	checkhit(r, cu, cxs) /* check for hit in full cube */
743	<	register RAY *r;
744	<	CUBE *cu;
745	<	OBJECT *cxs;
741	>	static int
742	>	checkhit( /* check for hit in full cube */
743	>	RAY *r,
744	>	CUBE *cu,
745	>	OBJECT *cxs
746	>	)
747		{
748		OBJECT oset[MAXSET+1];
558	–	register OBJREC *o;
559	–	register int i;
749
750		objset(oset, cu->cutree);
751	<	checkset(oset, cxs); /* eliminate double-checking */
752	<	for (i = oset[0]; i > 0; i--) {
753	<	o = objptr(oset[i]);
754	<	if ((*ofun[o->otype].funp)(o, r))
755	<	r->robj = oset[i];
567	<	}
568	<	if (r->ro == NULL)
751	>	checkset(oset, cxs); /* avoid double-checking */
752	>
753	>	(r->hitf)(oset, r); / test for hit in set */
754	>
755	>	if (r->robj == OVOID)
756		return(0); /* no scores yet */
757
758		return(incube(cu, r->rop)); /* hit OK if in current cube */
759		}
760
761
762	<	static
763	<	checkset(os, cs) /* modify checked set and set to check */
764	<	register OBJECT os; / os' = os - cs */
765	<	register OBJECT cs; / cs' = cs + os */
762	>	static void
763	>	checkset( /* modify checked set and set to check */
764	>	OBJECT os, / os' = os - cs */
765	>	OBJECT cs / cs' = cs + os */
766	>	)
767		{
768		OBJECT cset[MAXCSET+MAXSET+1];
769	<	register int i, j;
769	>	int i, j;
770		int k;
771		/* copy os in place, cset <- cs */
772		cset[0] = 0;

Diff Legend

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

Comparing ray/src/rt/raytrace.c (file contents): Revision 2.31 by gwlarson, Wed Jun 17 12:53:06 1998 UTC vs. Revision 2.96 by greg, Fri Feb 7 16:32:56 2025 UTC

Diff Legend

Comparing ray/src/rt/raytrace.c (file contents):
Revision 2.31 by gwlarson, Wed Jun 17 12:53:06 1998 UTC vs.
Revision 2.96 by greg, Fri Feb 7 16:32:56 2025 UTC