ViewVC Help

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

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

Comparing ray/src/rt/source.c (file contents):
Revision 2.38 by greg, Wed Dec 31 01:50:02 2003 UTC vs.
Revision 2.41 by greg, Fri Jan 9 05:37:11 2004 UTC

#	Line 7 | Line 7 | static const char RCSid[] = "$Id$";
7		*  External symbols declared in source.h
8		*/
9
10	–	#include "copyright.h"
11	–
10		#include  "ray.h"
11
12		#include  "otypes.h"
13
16	–	#include  "otspecial.h"
17	–
14		#include  "source.h"
15
16		#include  "random.h"
#	Line 294 | Line 290 | register RAY  *r
290		}
291
292
297	–	#if  SHADCACHE                  /* preemptive shadow checking */
298	–	#define ABS(x)  ((x)>0 ? (x) : -(x))
299	–
300	–	static void                             /* find closest blockers to source */
301	–	initobscache(SRCREC *srcp)
302	–	{
303	–	int     i;
304	–	int     cachelen;
305	–
306	–	if (srcp->sflags & SDISTANT)
307	–	cachelen = 4*SHADCACHE*SHADCACHE;
308	–	else if (srcp->sflags & SFLAT)
309	–	cachelen = SHADCACHE*SHADCACHE*3 + (SHADCACHE&1)*SHADCACHE*4;
310	–	else /* spherical distribution */
311	–	cachelen = SHADCACHE*SHADCACHE*6;
312	–	/* allocate cache */
313	–	DCHECK(srcp->obscache != NULL,
314	–	CONSISTENCY, "initobscache() called twice");
315	–	srcp->obscache = (OBSCACHE *)malloc(sizeof(OBSCACHE) +
316	–	sizeof(OBJECT)*(cachelen-1));
317	–	if (srcp->obscache == NULL)
318	–	error(SYSTEM, "out of memory in initobscache()");
319	–	/* set parameters */
320	–	if (srcp->sflags & SDISTANT) {
321	–	int     ax, ax1, ax2;
322	–	RREAL   amax = 0;
323	–	for (ax1 = 3; ax1--; )
324	–	if (ABS(srcp->sloc[ax1]) > amax) {
325	–	amax = ABS(srcp->sloc[ax1]);
326	–	ax = ax1;
327	–	}
328	–	srcp->obscache->p.d.ax = ax;
329	–	ax1 = (ax+1)%3;
330	–	ax2 = (ax+2)%3;
331	–	VCOPY(srcp->obscache->p.d.o, thescene.cuorg);
332	–	if (srcp->sloc[ax] > 0)
333	–	srcp->obscache->p.d.o[ax] += thescene.cusize;
334	–	if (srcp->sloc[ax1] < 0)
335	–	srcp->obscache->p.d.o[ax1] += thescene.cusize *
336	–	srcp->sloc[ax1] / ABS(srcp->sloc[ax]);
337	–	if (srcp->sloc[ax2] < 0)
338	–	srcp->obscache->p.d.o[ax2] += thescene.cusize *
339	–	srcp->sloc[ax2] / ABS(srcp->sloc[ax]);
340	–	srcp->obscache->p.d.e1 = (1.-FTINY) / (thescene.cusize*(1. +
341	–	fabs(srcp->sloc[ax1]/srcp->sloc[ax])));
342	–	srcp->obscache->p.d.e2 = (1.-FTINY) / (thescene.cusize*(1. +
343	–	fabs(srcp->sloc[ax2]/srcp->sloc[ax])));
344	–	} else if (srcp->sflags & SFLAT) {
345	–	VCOPY(srcp->obscache->p.f.u, srcp->ss[SU]);
346	–	normalize(srcp->obscache->p.f.u);
347	–	fcross(srcp->obscache->p.f.v,
348	–	srcp->snorm, srcp->obscache->p.f.u);
349	–	}
350	–	/* XXX Should cast rays from source */
351	–	for (i = cachelen; i--; )
352	–	srcp->obscache->obs[i] = OVOID;
353	–	}
354	–
355	–
356	–	static OBJECT *                 /* return occluder cache entry */
357	–	srcobstructp(register RAY *r)
358	–	{
359	–	static OBJECT   noobs;
360	–	SRCREC          *srcp;
361	–	int             ondx;
362	–
363	–	DCHECK(r->rsrc < 0, CONSISTENCY,
364	–	"srcobstructp() called with unaimed ray");
365	–	noobs = OVOID;
366	–	srcp = &source[r->rsrc];
367	–	if (srcp->obscache == NULL)     /* initialize cache */
368	–	initobscache(srcp);
369	–	/* compute cache index */
370	–	if (srcp->sflags & SDISTANT) {
371	–	int     ax, ax1, ax2;
372	–	double  t;
373	–	ax = srcp->obscache->p.d.ax;
374	–	if ((ax1 = ax+1) >= 3) ax1 -= 3;
375	–	if ((ax2 = ax+2) >= 3) ax2 -= 3;
376	–	t = (srcp->obscache->p.d.o[ax] - r->rorg[ax]) / srcp->sloc[ax];
377	–	if (t <= FTINY)
378	–	return &noobs;  /* could happen if ray is outside */
379	–	ondx = 2*SHADCACHE*(int)(2*SHADCACHE*srcp->obscache->p.d.e1 *
380	–	(r->rorg[ax1] + t*srcp->sloc[ax1] -
381	–	srcp->obscache->p.d.o[ax1]));
382	–	ondx += (int)(2*SHADCACHE*srcp->obscache->p.d.e2 *
383	–	(r->rorg[ax2] + t*srcp->sloc[ax2] -
384	–	srcp->obscache->p.d.o[ax2]));
385	–	} else if (srcp->sflags & SFLAT) {
386	–	FVECT   sd;
387	–	RREAL   sd0m, sd1m;
388	–	sd[0] = -DOT(r->rdir, srcp->obscache->p.f.u);
389	–	sd[1] = -DOT(r->rdir, srcp->obscache->p.f.v);
390	–	sd[2] = -DOT(r->rdir, srcp->snorm);
391	–	if (sd[2] < 0)
392	–	return &noobs;  /* shouldn't happen */
393	–	sd0m = ABS(sd[0]);
394	–	sd1m = ABS(sd[1]);
395	–	if (sd[2] >= sd0m && sd[2] >= sd1m) {
396	–	ondx = SHADCACHE*(int)(SHADCACHE*(.5-FTINY) *
397	–	(1. + sd[0]/sd[2]));
398	–	ondx += (int)(SHADCACHE*(.5-FTINY) *
399	–	(1. + sd[1]/sd[2]));
400	–	} else if (sd0m >= sd1m) {
401	–	ondx = SHADCACHE*SHADCACHE;
402	–	if (sd[0] < 0)
403	–	ondx += ((SHADCACHE+1)>>1)*SHADCACHE;
404	–	ondx += SHADCACHE*(int)(SHADCACHE*(.5-FTINY) *
405	–	sd[2]/sd0m);
406	–	ondx += (int)(SHADCACHE*(.5-FTINY) *
407	–	(1. + sd[1]/sd0m));
408	–	} else /* sd1m > sd0m */ {
409	–	ondx = SHADCACHE*SHADCACHE +
410	–	((SHADCACHE+1)>>1)*SHADCACHE*2;
411	–	if (sd[1] < 0)
412	–	ondx += ((SHADCACHE+1)>>1)*SHADCACHE;
413	–	ondx += SHADCACHE*(int)(SHADCACHE*(.5-FTINY) *
414	–	sd[2]/sd1m);
415	–	ondx += (int)(SHADCACHE*(.5-FTINY) *
416	–	(1. + sd[0]/sd1m));
417	–	}
418	–	} else /* spherical distribution */ {
419	–	int     ax, ax1, ax2;
420	–	RREAL   amax = 0;
421	–	for (ax1 = 3; ax1--; )
422	–	if (ABS(r->rdir[ax1]) > amax) {
423	–	amax = ABS(r->rdir[ax1]);
424	–	ax = ax1;
425	–	}
426	–	if ((ax1 = ax+1) >= 3) ax1 -= 3;
427	–	if ((ax2 = ax+2) >= 3) ax2 -= 3;
428	–	ondx = 2*SHADCACHE*SHADCACHE * ax;
429	–	if (r->rdir[ax] < 0)
430	–	ondx += SHADCACHE*SHADCACHE;
431	–	ondx += SHADCACHE*(int)(SHADCACHE*(.5-FTINY) *
432	–	(1. + r->rdir[ax1]/amax));
433	–	ondx += (int)(SHADCACHE*(.5-FTINY) *
434	–	(1. + r->rdir[ax2]/amax));
435	–	}
436	–	/* return cache pointer */
437	–	return(&srcp->obscache->obs[ondx]);
438	–	}
439	–
440	–
441	–	void                            /* free obstruction cache */
442	–	freeobscache(SRCREC *srcp)
443	–	{
444	–	if (srcp->obscache == NULL)
445	–	return;
446	–	free((void *)srcp->obscache);
447	–	srcp->obscache = NULL;
448	–	}
449	–
450	–
451	–	void                            /* record a source blocker */
452	–	srcblocker(register RAY *r)
453	–	{
454	–	OBJREC  *m;
455	–
456	–	if (r->robj == OVOID || objptr(r->robj) != r->ro ||
457	–	isvolume(r->ro->otype))
458	–	return;                 /* don't record complex blockers */
459	–	m = findmaterial(r->ro);
460	–	if (m == NULL)
461	–	return;                 /* no material?! */
462	–	if (!(ofun[m->otype].flags & T_OPAQUE))
463	–	return;                 /* material not a reliable blocker */
464	–
465	–	*srcobstructp(r) = r->robj;     /* else record obstructor */
466	–	}
467	–
468	–
469	–	int                             /* check ray against cached blocker */
470	–	srcblocked(RAY *r)
471	–	{
472	–	OBJECT  obs = *srcobstructp(r);
473	–	OBJREC  *op;
474	–
475	–	if (obs == OVOID)
476	–	return(0);
477	–	op = objptr(obs);               /* check for intersection */
478	–	return ((*ofun[op->otype].funp)(op, r));
479	–	}
480	–
481	–	#endif
482	–
483	–
293		static int
294		cntcmp(                         /* contribution compare (descending) */
295		const void *p1,
#	Line 606 | Line 415 | char  *p                       /* data for f */
415		if (bright(sr.rcol) <= FTINY) {
416		#if SHADCACHE
417		if ((scp <= srccnt || scp[-1].sno != scp->sno)
418	<	&& (scp >= srccnt+ncnts ||
418	>	&& (scp >= srccnt+ncnts-1 ||
419		scp[1].sno != scp->sno))
420		srcblocker(&sr);
421		#endif

Diff Legend

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