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

Comparing ray/src/rt/raytrace.c (file contents):
Revision 1.6 by greg, Mon Oct 16 18:57:02 1989 UTC vs.
Revision 2.97 by greg, Fri Jun 20 23:21:33 2025 UTC

#	Line 1 \| Line 1
1	–	/* Copyright (c) 1986 Regents of the University of California */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ LBL";
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"
15	+	#include "otspecial.h"
16	+	#include "random.h"
17	+	#include "pmap.h"
18
19	<	extern CUBE thescene; /* our scene */
20	<	extern int maxdepth; /* maximum recursion depth */
21	<	extern double minweight; /* minimum ray weight */
19	>	#define MAXCSET ((MAXSET+1)2-1) / maximum check set size */
20
21	<	long nrays = 0L; /* number of rays traced */
21	>	RNUMBER raynum = 0; /* next unique ray number */
22	>	RNUMBER nrays = 0; /* number of calls to localhit */
23
24	<	#define MAXLOOP 128 /* modifier loop detection */
24	>	static RREAL Lambfa[5] = {PI, PI, PI, 0.0, 0.0};
25	>	OBJREC Lamb = {
26	>	OVOID, MAT_PLASTIC, "Lambertian",
27	>	{NULL, Lambfa, 0, 5}, NULL
28	>	}; /* a Lambertian surface */
29
30	+	OBJREC Aftplane; /* aft clipping plane object */
31	+
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	<	rayorigin(r, ro, rt, rw) /* start new ray from old one */
39	<	register RAY r, ro;
40	<	int rt;
41	<	double rw;
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;
62		r->crtype = r->rtype = rt;
63		r->rsrc = -1;
64		r->clipset = NULL;
65	+	r->revf = raytrace;
66	+	copycolor(r->cext, cextinction);
67	+	copycolor(r->albedo, salbedo);
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 {
48	–	r->rsrc = ro->rsrc;
84		r->clipset = ro->newcset;
85	+	r->rmax = (ro->rmax > FTINY)*(ro->rmax - ro->rot);
86		}
87	<	r->rweight = ro->rweight * rw;
87	>	r->revf = ro->revf;
88	>	copycolor(r->cext, ro->cext);
89	>	copycolor(r->albedo, ro->albedo);
90	>	r->gecc = ro->gecc;
91	>	r->slights = ro->slights;
92		r->crtype = ro->crtype \| (r->rtype = rt);
93		VCOPY(r->rorg, ro->rop);
94	+	r->rweight = ro->rweight * rw;
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	+	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	<	r->rno = nrays;
108	>	rayclear(r);
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( /* 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->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);
156	<	return(r->rlvl <= maxdepth && r->rweight >= minweight ? 0 : -1);
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	<	rayvalue(r) /* compute a ray's value */
163	<	register RAY *r;
162	>	void
163	>	raytrace( /* trace a ray and compute its value */
164	>	RAY *r
165	>	)
166		{
167	<	extern int (*trace)();
167	>	if (localhit(r, &thescene))
168	>	raycont(r); /* hit local surface, evaluate */
169	>	else if (r->ro == &Aftplane) {
170	>	r->ro = NULL; /* hit aft clipping plane */
171	>	r->rot = FHUGE;
172	>	} else if (sourcehit(r))
173	>	rayshade(r, r->ro->omod); /* distant source */
174
71	–	if (localhit(r, &thescene) \|\| sourcehit(r))
72	–	rayshade(r, r->ro->omod);
73	–
175		if (trace != NULL)
176		(trace)(r); / trace execution */
177	+
178	+	rayparticipate(r); /* for participating medium */
179		}
180
181
182	<	raytrans(r) /* transmit ray as is */
183	<	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))
189	+	raytrans(r);
190	+	}
191	+
192	+
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	<	}
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	<	rayshade(r, mod) /* shade ray r with material mod */
211	<	register RAY *r;
212	<	int mod;
210	>	int
211	>	raytirrad( /* irradiance hack */
212	>	OBJREC *m,
213	>	RAY *r
214	>	)
215		{
216	<	static int depth = 0;
217	<	register OBJREC *m;
218	<	/* check for clipped surface */
219	<	if (r->clipset != NULL && r->rot < FHUGE &&
220	<	inset(r->clipset, mod)) {
221	<	raytrans(r);
222	<	return;
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	<	/* check for infinite loop */
227	<	if (depth++ >= MAXLOOP)
228	<	objerror(r->ro, USER, "possible modifier loop");
226	>	return(0); /* not a qualifying surface */
227	>	}
228	>
229	>
230	>	int
231	>	rayshade( /* shade ray r with material mod */
232	>	RAY *r,
233	>	int mod
234	>	)
235	>	{
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
#	Line 112 \| Line 245 \| int mod;
245		error(USER, errmsg);
246		}
247		******/
248	<	(ofun[m->otype].funp)(m, r); / execute function */
249	<	m->lastrno = r->rno;
250	<	if (ismaterial(m->otype)) { /* materials call raytexture */
251	<	depth--;
252	<	return; /* we're done */
253	<	}
248	>	/* hack for irradiance calculation */
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	<	objerror(r->ro, USER, "material not found");
255	>	return(0); /* no material! */
256		}
257
258
259	<	raytexture(r, mod) /* get material modifiers */
260	<	RAY *r;
261	<	int mod;
259	>	void
260	>	rayparticipate( /* compute ray medium participation */
261	>	RAY *r
262	>	)
263		{
264	<	static int depth = 0;
265	<	register OBJREC *m;
266	<	/* check for infinite loop */
267	<	if (depth++ >= MAXLOOP)
268	<	objerror(r->ro, USER, "modifier loop");
264	>	COLOR ce;
265	>	double re, ge, be;
266	>
267	>	if (intens(r->cext) <= 1./FHUGE)
268	>	return; /* no medium */
269	>	re = r->rot*colval(r->cext,RED);
270	>	ge = r->rot*colval(r->cext,GRN);
271	>	be = r->rot*colval(r->cext,BLU);
272	>	if (r->crtype & SHADOW) { /* no scattering for sources */
273	>	re *= 1. - colval(r->albedo,RED);
274	>	ge *= 1. - colval(r->albedo,GRN);
275	>	be *= 1. - colval(r->albedo,BLU);
276	>	}
277	>	setcolor(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	>	smultcolor(r->rcol, ce); /* path extinction */
281	>	if (r->crtype & SHADOW \|\| intens(r->albedo) <= FTINY)
282	>	return; /* no scattering */
283	>
284	>	/* PMAP: indirect inscattering accounted for by volume photons? */
285	>	if (!volumePhotonMapping) {
286	>	SCOLOR ca;
287	>	setscolor(ca,
288	>	colval(r->albedo,RED)colval(ambval,RED)(1.-colval(ce,RED)),
289	>	colval(r->albedo,GRN)colval(ambval,GRN)(1.-colval(ce,GRN)),
290	>	colval(r->albedo,BLU)colval(ambval,BLU)(1.-colval(ce,BLU)));
291	>	saddscolor(r->rcol, ca); /* ambient in scattering */
292	>	}
293	>
294	>	srcscatter(r); /* source in scattering */
295	>	}
296	>
297	>
298	>	void
299	>	raytexture( /* get material modifiers */
300	>	RAY *r,
301	>	OBJECT mod
302	>	)
303	>	{
304	>	OBJREC *m;
305		/* execute textures and patterns */
306		for ( ; mod != OVOID; mod = m->omod) {
307		m = objptr(mod);
308	<	if (!istexture(m->otype)) {
308	>	/****** unnecessary test since modifier() is always called
309	>	if (!ismodifier(m->otype)) {
310		sprintf(errmsg, "illegal modifier \"%s\"", m->oname);
311		error(USER, errmsg);
312		}
313	<	(*ofun[m->otype].funp)(m, r);
314	<	m->lastrno = r->rno;
313	>	******/
314	>	if ((*ofun[m->otype].funp)(m, r)) {
315	>	sprintf(errmsg, "conflicting material \"%s\"",
316	>	m->oname);
317	>	objerror(r->ro, USER, errmsg);
318	>	}
319		}
145	–	depth--; /* end here */
320		}
321
322
323	<	raymixture(r, fore, back, coef) /* mix modifiers */
324	<	register RAY *r;
325	<	OBJECT fore, back;
326	<	double coef;
323	>	int
324	>	raymixture( /* mix modifiers */
325	>	RAY *r,
326	>	OBJECT fore,
327	>	OBJECT back,
328	>	double coef
329	>	)
330		{
331	<	FVECT curpert, forepert, backpert;
332	<	COLOR curpcol, forepcol, backpcol;
333	<	register int i;
334	<	/* clip coefficient */
331	>	RAY fr, br;
332	>	double mfore, mback;
333	>	int foremat, backmat;
334	>	int i;
335	>	/* bound coefficient */
336		if (coef > 1.0)
337		coef = 1.0;
338		else if (coef < 0.0)
339		coef = 0.0;
340	<	/* save current mods */
341	<	VCOPY(curpert, r->pert);
342	<	copycolor(curpcol, r->pcol);
343	<	/* compute new mods */
344	<	/* foreground */
345	<	r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
346	<	setcolor(r->pcol, 1.0, 1.0, 1.0);
347	<	if (fore != OVOID && coef > FTINY)
348	<	raytexture(r, fore);
349	<	VCOPY(forepert, r->pert);
350	<	copycolor(forepcol, r->pcol);
351	<	/* background */
352	<	r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
353	<	setcolor(r->pcol, 1.0, 1.0, 1.0);
354	<	if (back != OVOID && coef < 1.0-FTINY)
355	<	raytexture(r, back);
356	<	VCOPY(backpert, r->pert);
357	<	copycolor(backpcol, r->pcol);
358	<	/* sum perturbations */
340	>	/* compute foreground and background */
341	>	foremat = backmat = 0;
342	>	/* foreground */
343	>	fr = *r;
344	>	if (coef > FTINY) {
345	>	fr.rweight *= coef;
346	>	scalescolor(fr.rcoef, coef);
347	>	foremat = rayshade(&fr, fore);
348	>	}
349	>	/* background */
350	>	br = *r;
351	>	if (coef < 1.0-FTINY) {
352	>	br.rweight *= 1.0-coef;
353	>	scalescolor(br.rcoef, 1.0-coef);
354	>	backmat = rayshade(&br, back);
355	>	}
356	>	/* check for transparency */
357	>	if (backmat ^ foremat) {
358	>	if (backmat && coef > FTINY)
359	>	raytrans(&fr);
360	>	else if (foremat && coef < 1.0-FTINY)
361	>	raytrans(&br);
362	>	}
363	>	/* mix perturbations */
364		for (i = 0; i < 3; i++)
365	<	r->pert[i] = curpert[i] + coef*forepert[i] +
366	<	(1.0-coef)*backpert[i];
367	<	/* multiply colors */
368	<	setcolor(r->pcol, coef*colval(forepcol,RED) +
369	<	(1.0-coef)*colval(backpcol,RED),
370	<	coef*colval(forepcol,GRN) +
371	<	(1.0-coef)*colval(backpcol,GRN),
372	<	coef*colval(forepcol,BLU) +
373	<	(1.0-coef)*colval(backpcol,BLU));
374	<	multcolor(r->pcol, curpcol);
365	>	r->pert[i] = coeffr.pert[i] + (1.0-coef)br.pert[i];
366	>	/* mix pattern colors */
367	>	scalescolor(fr.pcol, coef);
368	>	scalescolor(br.pcol, 1.0-coef);
369	>	copyscolor(r->pcol, fr.pcol);
370	>	saddscolor(r->pcol, br.pcol);
371	>	/* return value tells if material */
372	>	if (!foremat & !backmat)
373	>	return(0);
374	>	/* mix returned ray values */
375	>	scalescolor(fr.rcol, coef);
376	>	scalescolor(br.rcol, 1.0-coef);
377	>	copyscolor(r->rcol, fr.rcol);
378	>	saddscolor(r->rcol, br.rcol);
379	>	scalescolor(fr.mcol, coef);
380	>	scalescolor(br.mcol, 1.0-coef);
381	>	copyscolor(r->mcol, fr.mcol);
382	>	saddscolor(r->mcol, br.mcol);
383	>	mfore = pbright(fr.mcol); mback = pbright(br.mcol);
384	>	r->rmt = mfore > mback ? fr.rmt : br.rmt;
385	>	r->rxt = pbright(fr.rcol)-mfore > pbright(br.rcol)-mback ?
386	>	fr.rxt : br.rxt;
387	>	return(1);
388		}
389
390
391		double
392	<	raynormal(norm, r) /* compute perturbed normal for ray */
393	<	FVECT norm;
394	<	register RAY *r;
392	>	raydist( /* compute (cumulative) ray distance */
393	>	const RAY *r,
394	>	int flags
395	>	)
396		{
397	+	double sum = 0.0;
398	+
399	+	while (r != NULL && r->crtype&flags) {
400	+	sum += r->rot;
401	+	r = r->parent;
402	+	}
403	+	return(sum);
404	+	}
405	+
406	+
407	+	void
408	+	raycontrib( /* compute (cumulative) ray contribution */
409	+	SCOLOR rc,
410	+	const RAY *r,
411	+	int flags
412	+	)
413	+	{
414	+	static int warnedPM = 0;
415	+	double re, ge, be;
416	+	SCOLOR ce;
417	+
418	+	setscolor(rc, 1., 1., 1.);
419	+	re = ge = be = 0.;
420	+
421	+	while (r != NULL && r->crtype&flags) {
422	+	/* include this ray coefficient */
423	+	smultscolor(rc, r->rcoef);
424	+	/* check participating medium */
425	+	if (!warnedPM && bright(r->albedo) > FTINY) {
426	+	error(WARNING,
427	+	"ray contribution calculation does not support participating media");
428	+	warnedPM++;
429	+	}
430	+	/* sum PM extinction */
431	+	re += r->rot*colval(r->cext,RED);
432	+	ge += r->rot*colval(r->cext,GRN);
433	+	be += r->rot*colval(r->cext,BLU);
434	+	/* descend the tree */
435	+	r = r->parent;
436	+	}
437	+	/* cumulative extinction */
438	+	setscolor(ce, re<=FTINY ? 1. : re>92. ? 0. : exp(-re),
439	+	ge<=FTINY ? 1. : ge>92. ? 0. : exp(-ge),
440	+	be<=FTINY ? 1. : be>92. ? 0. : exp(-be));
441	+	smultscolor(rc, ce);
442	+	}
443	+
444	+
445	+	double
446	+	raynormal( /* compute perturbed normal for ray */
447	+	FVECT norm,
448	+	RAY *r
449	+	)
450	+	{
451		double newdot;
452	<	register int i;
452	>	int i;
453
454		/* The perturbation is added to the surface normal to obtain
455		* the new normal. If the new normal would affect the surface
#	Line 206 \| Line 457 \| *register RAY r;**
457		* still fraught with problems since reflected rays and similar
458		* directions calculated from the surface normal may spawn rays behind
459		* the surface. The only solution is to curb textures at high
460	<	* incidence (Rdot << 1).
460	>	* incidence (namely, keep DOT(rdir,pert) < Rdot).
461		*/
462
463		for (i = 0; i < 3; i++)
#	Line 218 \| Line 469 \| *register RAY r;**
469		return(r->rod);
470		}
471		newdot = -DOT(norm, r->rdir);
472	<	if ((newdot > 0.0) != (r->rod > 0.0)) { /* fix orientation */
472	>	if ((newdot > 0.0) ^ (r->rod > 0.0)) { /* fix orientation */
473		for (i = 0; i < 3; i++)
474		norm[i] += 2.0newdotr->rdir[i];
475		newdot = -newdot;
#	Line 227 \| Line 478 \| *register RAY r;**
478		}
479
480
481	<	flipsurface(r) /* reverse surface orientation */
482	<	register RAY *r;
481	>	void
482	>	newrayxf( /* get new tranformation matrix for ray */
483	>	RAY *r
484	>	)
485		{
486	+	static struct xfn {
487	+	struct xfn *next;
488	+	FULLXF xf;
489	+	} xfseed = { &xfseed }, *xflast = &xfseed;
490	+	struct xfn *xp;
491	+	const RAY *rp;
492	+
493	+	/*
494	+	* Search for transform in circular list that
495	+	* has no associated ray in the tree.
496	+	*/
497	+	xp = xflast;
498	+	for (rp = r->parent; rp != NULL; rp = rp->parent)
499	+	if (rp->rox == &xp->xf) { /* xp in use */
500	+	xp = xp->next; /* move to next */
501	+	if (xp == xflast) { /* need new one */
502	+	xp = (struct xfn *)bmalloc(sizeof(struct xfn));
503	+	if (xp == NULL)
504	+	error(SYSTEM,
505	+	"out of memory in newrayxf");
506	+	/* insert in list */
507	+	xp->next = xflast->next;
508	+	xflast->next = xp;
509	+	break; /* we're done */
510	+	}
511	+	rp = r; /* start check over */
512	+	}
513	+	/* got it */
514	+	r->rox = &xp->xf;
515	+	xflast = xp;
516	+	}
517	+
518	+
519	+	void
520	+	flipsurface( /* reverse surface orientation */
521	+	RAY *r
522	+	)
523	+	{
524		r->rod = -r->rod;
525		r->ron[0] = -r->ron[0];
526		r->ron[1] = -r->ron[1];
#	Line 237 \| Line 528 \| *register RAY r;**
528		r->pert[0] = -r->pert[0];
529		r->pert[1] = -r->pert[1];
530		r->pert[2] = -r->pert[2];
531	+	r->rflips++;
532		}
533
534
535	<	localhit(r, scene) /* check for hit in the octree */
536	<	register RAY *r;
537	<	register CUBE *scene;
535	>	int
536	>	rayreject( /* check if candidate hit is worse than current */
537	>	OBJREC *o,
538	>	RAY *r,
539	>	double t,
540	>	double rod
541	>	)
542		{
543	+	OBJREC mnew, mray;
544	+
545	+	if ((t <= FTINY) \| (t > r->rot + FTINY))
546	+	return(1);
547	+	if (t < r->rot - FTINY) /* is new hit significantly closer? */
548	+	return(0);
549	+	/* coincident point, so decide... */
550	+	if (o == r->ro)
551	+	return(1); /* shouldn't happen */
552	+	if (r->ro == NULL)
553	+	return(0); /* ditto */
554	+	mnew = findmaterial(o);
555	+	mray = findmaterial(r->ro); /* check material transparencies */
556	+	if (mnew == NULL) {
557	+	if (mray != NULL)
558	+	return(1); /* old has material, new does not */
559	+	} else if (mray == NULL) {
560	+	return(0); /* new has material, old does not */
561	+	} else if (istransp(mnew)) {
562	+	if (!istransp(mray))
563	+	return(1); /* new is transparent, old is not */
564	+	} else if (istransp(mray)) {
565	+	return(0); /* old is transparent, new is not */
566	+	}
567	+	if (rod <= 0) { /* check which side we hit */
568	+	if (r->rod > 0)
569	+	return(1); /* old hit front, new did not */
570	+	} else if (r->rod <= 0) {
571	+	return(0); /* new hit front, old did not */
572	+	}
573	+	/* earlier modifier definition wins tie */
574	+	return (r->ro->omod >= o->omod);
575	+	}
576	+
577	+	void
578	+	rayhit( /* standard ray hit test */
579	+	OBJECT *oset,
580	+	RAY *r
581	+	)
582	+	{
583	+	OBJREC *o;
584	+	int i;
585	+
586	+	for (i = oset[0]; i > 0; i--) {
587	+	o = objptr(oset[i]);
588	+	if ((*ofun[o->otype].funp)(o, r))
589	+	r->robj = oset[i];
590	+	}
591	+	}
592	+
593	+
594	+	int
595	+	localhit( /* check for hit in the octree */
596	+	RAY *r,
597	+	CUBE *scene
598	+	)
599	+	{
600	+	OBJECT cxset[MAXCSET+1]; /* set of checked objects */
601		FVECT curpos; /* current cube position */
602	<	int mpos, mneg; /* sign flags */
602	>	int sflags; /* sign flags */
603		double t, dt;
604	<	register int i;
604	>	int i;
605
606		nrays++; /* increment trace counter */
607	<
254	<	mpos = mneg = 0;
607	>	sflags = 0;
608		for (i = 0; i < 3; i++) {
609		curpos[i] = r->rorg[i];
610	<	if (r->rdir[i] > FTINY)
611	<	mpos \|= 1 << i;
612	<	else if (r->rdir[i] < -FTINY)
613	<	mneg \|= 1 << i;
610	>	if (r->rdir[i] > 1e-7)
611	>	sflags \|= 1 << i;
612	>	else if (r->rdir[i] < -1e-7)
613	>	sflags \|= 0x10 << i;
614		}
615	+	if (!sflags) {
616	+	error(WARNING, "zero ray direction in localhit");
617	+	return(0);
618	+	}
619	+	/* start off assuming nothing hit */
620	+	if (r->rmax > FTINY) { /* except aft plane if one */
621	+	r->ro = &Aftplane;
622	+	r->rot = r->rmax;
623	+	VSUM(r->rop, r->rorg, r->rdir, r->rot);
624	+	}
625	+	/* find global cube entrance point */
626		t = 0.0;
627		if (!incube(scene, curpos)) {
628		/* find distance to entry */
629		for (i = 0; i < 3; i++) {
630		/* plane in our direction */
631	<	if (mpos & 1<<i)
631	>	if (sflags & 1<<i)
632		dt = scene->cuorg[i];
633	<	else if (mneg & 1<<i)
633	>	else if (sflags & 0x10<<i)
634		dt = scene->cuorg[i] + scene->cusize;
635		else
636		continue;
#	Line 276 \| Line 640 \| *register CUBE scene;**
640		t = dt; /* farthest face is the one */
641		}
642		t += FTINY; /* fudge to get inside cube */
643	+	if (t >= r->rot) /* clipped already */
644	+	return(0);
645		/* advance position */
646	<	for (i = 0; i < 3; i++)
281	<	curpos[i] += r->rdir[i]*t;
646	>	VSUM(curpos, curpos, r->rdir, t);
647
648		if (!incube(scene, curpos)) /* non-intersecting ray */
649		return(0);
650		}
651	<	return(raymove(curpos, mpos, mneg, r, scene) == RAYHIT);
651	>	cxset[0] = 0;
652	>	raymove(curpos, cxset, sflags, r, scene);
653	>	return((r->ro != NULL) & (r->ro != &Aftplane));
654		}
655
656
657		static int
658	<	raymove(pos, plus, minus, r, cu) /* check for hit as we move */
659	<	FVECT pos; /* modified */
660	<	int plus, minus; /* direction indicators to speed tests */
661	<	register RAY *r;
662	<	register CUBE *cu;
658	>	raymove( /* check for hit as we move */
659	>	FVECT pos, /* current position, modified herein */
660	>	OBJECT cxs, / checked objects, modified by checkhit */
661	>	int dirf, /* direction indicators to speed tests */
662	>	RAY *r,
663	>	CUBE *cu
664	>	)
665		{
666		int ax;
667		double dt, t;
299	–	register int sgn;
668
669		if (istree(cu->cutree)) { /* recurse on subcubes */
670		CUBE cukid;
671	<	register int br;
671	>	int br, sgn;
672
673		cukid.cusize = cu->cusize * 0.5; /* find subcube */
674		VCOPY(cukid.cuorg, cu->cuorg);
#	Line 319 \| Line 687 \| *register CUBE cu;**
687		}
688		for ( ; ; ) {
689		cukid.cutree = octkid(cu->cutree, br);
690	<	if ((ax = raymove(pos,plus,minus,r,&cukid)) == RAYHIT)
690	>	if ((ax = raymove(pos,cxs,dirf,r,&cukid)) == RAYHIT)
691		return(RAYHIT);
692		sgn = 1 << ax;
693	<	if (sgn & minus) /* negative axis? */
326	<	if (sgn & br) {
327	<	cukid.cuorg[ax] -= cukid.cusize;
328	<	br &= ~sgn;
329	<	} else
330	<	return(ax); /* underflow */
331	<	else
693	>	if (sgn & dirf) /* positive axis? */
694		if (sgn & br)
695		return(ax); /* overflow */
696		else {
697		cukid.cuorg[ax] += cukid.cusize;
698		br \|= sgn;
699		}
700	+	else
701	+	if (sgn & br) {
702	+	cukid.cuorg[ax] -= cukid.cusize;
703	+	br &= ~sgn;
704	+	} else
705	+	return(ax); /* underflow */
706		}
707		/NOTREACHED/
708		}
709	<	if (isfull(cu->cutree) && checkhit(r, cu))
709	>	if (isfull(cu->cutree)) {
710	>	if (checkhit(r, cu, cxs))
711	>	return(RAYHIT);
712	>	} else if (r->ro == &Aftplane && incube(cu, r->rop))
713		return(RAYHIT);
714		/* advance to next cube */
715	<	sgn = plus \| minus;
716	<	if (sgn&1) {
346	<	dt = plus&1 ? cu->cuorg[0] + cu->cusize : cu->cuorg[0];
715	>	if (dirf&0x11) {
716	>	dt = dirf&1 ? cu->cuorg[0] + cu->cusize : cu->cuorg[0];
717		t = (dt - pos[0])/r->rdir[0];
718		ax = 0;
719		} else
720		t = FHUGE;
721	<	if (sgn&2) {
722	<	dt = plus&2 ? cu->cuorg[1] + cu->cusize : cu->cuorg[1];
721	>	if (dirf&0x22) {
722	>	dt = dirf&2 ? cu->cuorg[1] + cu->cusize : cu->cuorg[1];
723		dt = (dt - pos[1])/r->rdir[1];
724		if (dt < t) {
725		t = dt;
726		ax = 1;
727		}
728		}
729	<	if (sgn&4) {
730	<	dt = plus&4 ? cu->cuorg[2] + cu->cusize : cu->cuorg[2];
729	>	if (dirf&0x44) {
730	>	dt = dirf&4 ? cu->cuorg[2] + cu->cusize : cu->cuorg[2];
731		dt = (dt - pos[2])/r->rdir[2];
732		if (dt < t) {
733		t = dt;
734		ax = 2;
735		}
736		}
737	<	pos[0] += r->rdir[0]*t;
368	<	pos[1] += r->rdir[1]*t;
369	<	pos[2] += r->rdir[2]*t;
737	>	VSUM(pos, pos, r->rdir, t);
738		return(ax);
739		}
740
741
742	<	static
743	<	checkhit(r, cu) /* check for hit in full cube */
744	<	register RAY *r;
745	<	CUBE *cu;
742	>	static int
743	>	checkhit( /* check for hit in full cube */
744	>	RAY *r,
745	>	CUBE *cu,
746	>	OBJECT *cxs
747	>	)
748		{
749		OBJECT oset[MAXSET+1];
380	–	register OBJREC *o;
381	–	register int i;
750
751		objset(oset, cu->cutree);
752	<	for (i = oset[0]; i > 0; i--) {
753	<	o = objptr(oset[i]);
754	<	if (o->lastrno == r->rno) /* checked already? */
755	<	continue;
756	<	(*ofun[o->otype].funp)(o, r);
389	<	o->lastrno = r->rno;
390	<	}
391	<	if (r->ro == NULL)
752	>	checkset(oset, cxs); /* avoid double-checking */
753	>
754	>	(r->hitf)(oset, r); / test for hit in set */
755	>
756	>	if (r->robj == OVOID)
757		return(0); /* no scores yet */
758
759		return(incube(cu, r->rop)); /* hit OK if in current cube */
760	+	}
761	+
762	+
763	+	static void
764	+	checkset( /* modify checked set and set to check */
765	+	OBJECT os, / os' = os - cs */
766	+	OBJECT cs / cs' = cs + os */
767	+	)
768	+	{
769	+	OBJECT cset[MAXCSET+MAXSET+1];
770	+	int i, j;
771	+	int k;
772	+	/* copy os in place, cset <- cs */
773	+	cset[0] = 0;
774	+	k = 0;
775	+	for (i = j = 1; i <= os[0]; i++) {
776	+	while (j <= cs[0] && cs[j] < os[i])
777	+	cset[++cset[0]] = cs[j++];
778	+	if (j > cs[0] \|\| os[i] != cs[j]) { /* object to check */
779	+	os[++k] = os[i];
780	+	cset[++cset[0]] = os[i];
781	+	}
782	+	}
783	+	if (!(os[0] = k)) /* new "to check" set size */
784	+	return; /* special case */
785	+	while (j <= cs[0]) /* get the rest of cs */
786	+	cset[++cset[0]] = cs[j++];
787	+	if (cset[0] > MAXCSET) /* truncate "checked" set if nec. */
788	+	cset[0] = MAXCSET;
789	+	/* setcopy(cs, cset); / / copy cset back to cs */
790	+	os = cset;
791	+	for (i = os[0]; i-- >= 0; )
792	+	cs++ = os++;
793		}

Diff Legend

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

Comparing ray/src/rt/raytrace.c (file contents): Revision 1.6 by greg, Mon Oct 16 18:57:02 1989 UTC vs. Revision 2.97 by greg, Fri Jun 20 23:21:33 2025 UTC

Diff Legend

Comparing ray/src/rt/raytrace.c (file contents):
Revision 1.6 by greg, Mon Oct 16 18:57:02 1989 UTC vs.
Revision 2.97 by greg, Fri Jun 20 23:21:33 2025 UTC