ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/rt/srcobstr.c

Comparing ray/src/rt/srcobstr.c (file contents):
Revision 2.2 by greg, Thu Jan 1 19:31:46 2004 UTC vs.
Revision 2.22 by greg, Mon Dec 9 00:44:29 2024 UTC

#	Line 11 | Line 11 | static const char RCSid[] = "$Id$";
11
12		#include  "otspecial.h"
13
14	+	#include  "rtotypes.h"
15	+
16		#include  "source.h"
17
18	+	#if  SHADCACHE                  /* preemptive shadow checking */
19	+
20	+	#ifndef MAX2SHADE
21	+	#define MAX2SHADE       200             /* limit # of sources to precheck */
22	+	#endif
23	+
24		#define ABS(x)  ((x)>0 ? (x) : -(x))
25
26
27	<	#if  SHADCACHE                  /* preemptive shadow checking */
27	>	OBJECT *        antimodlist = NULL;     /* set of clipped materials */
28
29
30	<	static void                             /* cast source ray to first blocker */
30	>	static int                              /* cast source ray to first blocker */
31		castshadow(int sn, FVECT rorg, FVECT rdir)
32		{
33		RAY     rt;
#	Line 27 | Line 35 | castshadow(int sn, FVECT rorg, FVECT rdir)
35		VCOPY(rt.rorg, rorg);
36		VCOPY(rt.rdir, rdir);
37		rt.rmax = 0;
38	<	rayorigin(&rt, NULL, PRIMARY, 1.0);
39	<	if (!localhit(&rt, &thescene))
40	<	return;
41	<	/* pretend we were aimed at source */
42	<	rt.crtype |= rt.rtype = SHADOW;
43	<	rt.rdir[0] = -rt.rdir[0];
44	<	rt.rdir[1] = -rt.rdir[1];
45	<	rt.rdir[2] = -rt.rdir[2];
46	<	rt.rod = -rt.rod;
47	<	VSUB(rt.rorg, rt.rop, rt.rdir);
48	<	rt.rot = 1.;
49	<	rt.rsrc = sn;
38	>	rayorigin(&rt, PRIMARY, NULL, NULL);
39	>	/* check for intersection */
40	>	while (localhit(&rt, &thescene)) {
41	>	RAY     rt1 = rt;       /* pretend we were aimed at source */
42	>	rt1.crtype |= rt1.rtype = RSHADOW;
43	>	rt1.rdir[0] = -rt.rdir[0];
44	>	rt1.rdir[1] = -rt.rdir[1];
45	>	rt1.rdir[2] = -rt.rdir[2];
46	>	rt1.rod = -rt.rod;
47	>	VSUB(rt1.rorg, rt.rop, rt.rdir);
48	>	rt1.rot = 1.;
49	>	rt1.rsrc = sn;
50		/* record blocker */
51	<	srcblocker(&rt);
51	>	if (srcblocker(&rt1))
52	>	return(1);
53	>	/* move past failed blocker */
54	>	VSUM(rt.rorg, rt.rop, rt.rdir, 10.*FTINY);
55	>	rayclear(&rt);          /* & try again... */
56	>	}
57	>	return(0);                      /* found no blockers */
58		}
59
60
61	<	static void                             /* initialize occlusion cache */
61	>	void                                    /* initialize occlusion cache */
62		initobscache(int sn)
63		{
64	<	register SRCREC *srcp = &source[sn];
65	<	int             cachelen;
66	<	FVECT           rorg, rdir;
67	<	RREAL           d;
68	<	int             i, j, k;
69	<	int             ax, ax1, ax2;
64	>	SRCREC  *srcp = &source[sn];
65	>	int     cachelen;
66	>	FVECT   rorg, rdir;
67	>	RREAL   d;
68	>	int     i, j, k;
69	>	int     ax=0, ax1=1, ax2=2;
70
71	+	if (srcp->sflags & (SSKIP|SPROX|SSPOT|SVIRTUAL))
72	+	return;                 /* don't cache these */
73		if (srcp->sflags & SDISTANT)
74		cachelen = 4*SHADCACHE*SHADCACHE;
75		else if (srcp->sflags & SFLAT)
#	Line 61 | Line 77 | initobscache(int sn)
77		else /* spherical distribution */
78		cachelen = SHADCACHE*SHADCACHE*6;
79		/* allocate cache */
64	–	DCHECK(srcp->obscache != NULL,
65	–	CONSISTENCY, "initobscache() called twice");
80		srcp->obscache = (OBSCACHE *)malloc(sizeof(OBSCACHE) +
81		sizeof(OBJECT)*(cachelen-1));
82		if (srcp->obscache == NULL)
#	Line 100 | Line 114 | initobscache(int sn)
114		/* clear cache */
115		for (i = cachelen; i--; )
116		srcp->obscache->obs[i] = OVOID;
117	+	#if (MAX2SHADE >= 0)
118	+	if (sn >= MAX2SHADE)            /* limit on prechecking */
119	+	return;
120	+	#endif
121		/* cast shadow rays */
122		if (srcp->sflags & SDISTANT) {
123		for (k = 3; k--; )
#	Line 136 | Line 154 | initobscache(int sn)
154		else
155		VSUM(rdir, srcp->obscache->p.f.v,
156		srcp->obscache->p.f.u, d);
157	<	d = 2./SHADCACHE*(j+.5);
157	>	d = 1. - 2./SHADCACHE*(j+.5);
158		VSUM(rdir, rdir, srcp->snorm, d);
159		normalize(rdir);
160		castshadow(sn, rorg, rdir);
#	Line 167 | Line 185 | initobscache(int sn)
185
186
187		static OBJECT *                 /* return occluder cache entry */
188	<	srcobstructp(register RAY *r)
188	>	srcobstructp(RAY *r)
189		{
190	+	static RNUMBER  lastrno = ~0;
191		static OBJECT   noobs;
192	+	static OBJECT   *lastobjp;
193		SRCREC          *srcp;
194		int             ondx;
195
196	+	noobs = OVOID;
197	+	if (r->rno == lastrno)
198	+	return lastobjp;        /* just recall last pointer */
199		DCHECK(r->rsrc < 0, CONSISTENCY,
200		"srcobstructp() called with unaimed ray");
201	<	noobs = OVOID;
201	>	lastrno = r->rno;
202	>	lastobjp = &noobs;
203		srcp = &source[r->rsrc];
204		if (srcp->sflags & (SSKIP|SPROX|SSPOT|SVIRTUAL))
205		return(&noobs);         /* don't cache these */
#	Line 183 | Line 207 | srcobstructp(register RAY *r)
207		initobscache(r->rsrc);
208		/* compute cache index */
209		if (srcp->sflags & SDISTANT) {
210	<	int     ax, ax1, ax2;
210	>	int     ax=0, ax1=1, ax2=2;
211		double  t;
212		ax = srcp->obscache->p.d.ax;
213		if ((ax1 = ax+1) >= 3) ax1 -= 3;
#	Line 197 | Line 221 | srcobstructp(register RAY *r)
221		ondx += (int)(2*SHADCACHE*srcp->obscache->p.d.e2 *
222		(r->rorg[ax2] + t*srcp->sloc[ax2] -
223		srcp->obscache->p.d.o[ax2]));
224	<	if (ondx < 0 | ondx >= 4*SHADCACHE*SHADCACHE)
224	>	if ((ondx < 0) | (ondx >= 4*SHADCACHE*SHADCACHE))
225		return(&noobs); /* could happen if ray is outside */
226		} else if (srcp->sflags & SFLAT) {
227		FVECT   sd;
#	Line 219 | Line 243 | srcobstructp(register RAY *r)
243		if (sd[0] < 0)
244		ondx += ((SHADCACHE+1)>>1)*SHADCACHE;
245		ondx += SHADCACHE*(int)(SHADCACHE*(.5-FTINY) *
246	<	sd[2]/sd0m);
246	>	(1. - sd[2]/sd0m));
247		ondx += (int)(SHADCACHE*(.5-FTINY) *
248		(1. + sd[1]/sd0m));
249		} else /* sd1m > sd0m */ {
#	Line 228 | Line 252 | srcobstructp(register RAY *r)
252		if (sd[1] < 0)
253		ondx += ((SHADCACHE+1)>>1)*SHADCACHE;
254		ondx += SHADCACHE*(int)(SHADCACHE*(.5-FTINY) *
255	<	sd[2]/sd1m);
255	>	(1. - sd[2]/sd1m));
256		ondx += (int)(SHADCACHE*(.5-FTINY) *
257		(1. + sd[0]/sd1m));
258		}
259	+	DCHECK((ondx < 0) | (ondx >= SHADCACHE*SHADCACHE*3 +
260	+	(SHADCACHE&1)*SHADCACHE*4), CONSISTENCY,
261	+	"flat source cache index out of bounds");
262		} else /* spherical distribution */ {
263		int     ax, ax1, ax2;
264		RREAL   amax = 0;
#	Line 249 | Line 276 | srcobstructp(register RAY *r)
276		(1. + r->rdir[ax1]/amax));
277		ondx += (int)(SHADCACHE*(.5-FTINY) *
278		(1. + r->rdir[ax2]/amax));
279	+	DCHECK((ondx < 0) | (ondx >= SHADCACHE*SHADCACHE*6), CONSISTENCY,
280	+	"radial source cache index out of bounds");
281		}
282		/* return cache pointer */
283	<	return(&srcp->obscache->obs[ondx]);
283	>	return(lastobjp = &srcp->obscache->obs[ondx]);
284		}
285
286
#	Line 265 | Line 294 | freeobscache(SRCREC *srcp)
294		}
295
296
297	<	void                            /* record a source blocker */
298	<	srcblocker(register RAY *r)
297	>	int                             /* record a source blocker */
298	>	srcblocker(RAY *r)
299		{
300		OBJREC  *m;
301
302		if (r->robj == OVOID || objptr(r->robj) != r->ro ||
303		isvolume(r->ro->otype))
304	<	return;                 /* don't record complex blockers */
304	>	return(0);              /* don't record complex blockers */
305	>	if (r->rsrc < 0 || source[r->rsrc].so == r->ro)
306	>	return(0);              /* just a mistake, that's all */
307	>	if (antimodlist != NULL && inset(antimodlist, r->ro->omod))
308	>	return(0);              /* could be clipped */
309		m = findmaterial(r->ro);
310		if (m == NULL)
311	<	return;                 /* no material?! */
312	<	if (!(ofun[m->otype].flags & T_OPAQUE))
313	<	return;                 /* material not a reliable blocker */
311	>	return(0);              /* no material?! */
312	>	if (!isopaque(m))
313	>	return(0);              /* material not a reliable blocker */
314		*srcobstructp(r) = r->robj;     /* else record obstructor */
315	+	return(1);
316		}
317
318
#	Line 290 | Line 324 | srcblocked(RAY *r)
324
325		if (obs == OVOID)
326		return(0);
327	<	op = objptr(obs);               /* check for intersection */
328	<	return((*ofun[op->otype].funp)(op, r));
327	>	op = objptr(obs);               /* check blocker intersection */
328	>	if (!(*ofun[op->otype].funp)(op, r))
329	>	return(0);
330	>	if (source[r->rsrc].sflags & SDISTANT)
331	>	return(1);
332	>	op = source[r->rsrc].so;        /* check source intersection */
333	>	if (!(*ofun[op->otype].funp)(op, r))
334	>	return(1);
335	>	rayclear(r);
336	>	return(0);                      /* source in front */
337	>	}
338	>
339	>
340	>	void                            /* record potentially clipped materials */
341	>	markclip(OBJREC *m)
342	>	{
343	>	OBJECT  *set2add, *oldset;
344	>
345	>	if (m == NULL) {                /* starting over */
346	>	if (antimodlist != NULL)
347	>	free((void *)antimodlist);
348	>	antimodlist = NULL;
349	>	return;
350	>	}
351	>	m_clip(m, NULL);                /* initialize modifier list */
352	>	if ((set2add = (OBJECT *)m->os) == NULL || !set2add[0])
353	>	return;
354	>
355	>	if (antimodlist == NULL) {      /* start of list */
356	>	antimodlist = setsave(set2add);
357	>	return;
358	>	}
359	>	/* else add to previous list */
360	>	oldset = antimodlist;
361	>	antimodlist = (OBJECT *)malloc((oldset[0]+set2add[0]+1)*sizeof(OBJECT));
362	>	if (antimodlist == NULL)
363	>	error(SYSTEM, "out of memory in markclip");
364	>	setunion(antimodlist, oldset, set2add);
365	>	free((void *)oldset);
366	>	}
367	>
368	>
369	>	#else   /* SHADCACHE */
370	>
371	>
372	>	void                            /* no-op also avoids linker warning */
373	>	markclip(OBJREC *m)
374	>	{
375	>	(void)m;
376		}
377
378

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)