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.41 by greg, Fri Jan 9 05:37:11 2004 UTC vs.
Revision 2.52 by greg, Tue May 31 18:01:09 2005 UTC

#	Line 8 | Line 8 | static const char RCSid[] = "$Id$";
8		*/
9
10		#include  "ray.h"
11	–
11		#include  "otypes.h"
12	<
12	>	#include  "rtotypes.h"
13		#include  "source.h"
15	–
14		#include  "random.h"
15
16		extern double  ssampdist;               /* scatter sampling distance */
#	Line 41 | Line 39 | static CONTRIB  *srccnt;               /* source contributions in d
39		static CNTPTR  *cntord;                 /* source ordering in direct() */
40		static int  maxcntr = 0;                /* size of contribution arrays */
41
42	+	static int cntcmp(const void *p1, const void *p2);
43
44	<	OBJREC *                        /* find an object's actual material */
44	>
45	>	extern OBJREC *                 /* find an object's actual material */
46		findmaterial(register OBJREC *o)
47		{
48		while (!ismaterial(o->otype)) {
49	–	if (ismixture(o->otype))
50	–	return(NULL);   /* reject mixed materials */
49		if (o->otype == MOD_ALIAS && o->oargs.nsargs) {
50		OBJECT  aobj;
51		OBJREC  *ao;
#	Line 62 | Line 60 | findmaterial(register OBJREC *o)
60		return(NULL);
61		o = objptr(o->omod);
62		}
63	<	return(o);
63	>	return(o);              /* mixtures will return NULL */
64		}
65
66
67	<	void
68	<	marksources()                   /* find and mark source objects */
67	>	extern void
68	>	marksources(void)                       /* find and mark source objects */
69		{
70		int  foundsource = 0;
71		int  i;
#	Line 83 | Line 81 | marksources()                  /* find and mark source objects */
81		if (!issurface(o->otype) || o->omod == OVOID)
82		continue;
83		/* find material */
84	<	m = findmaterial(o);
84	>	m = findmaterial(objptr(o->omod));
85		if (m == NULL || !islight(m->otype))
86		continue;       /* not source modifier */
87
#	Line 125 | Line 123 | marksources()                  /* find and mark source objects */
123		}
124		}
125		#if  SHADCACHE
126	<	source[ns].obscache = NULL;
126	>	initobscache(ns);
127		#endif
128		if (!(source[ns].sflags & SSKIP))
129		foundsource++;
#	Line 147 | Line 145 | memerr:
145		}
146
147
148	<	void
149	<	freesources()                   /* free all source structures */
148	>	extern void
149	>	freesources(void)                       /* free all source structures */
150		{
151		if (nsources > 0) {
152		#if SHADCACHE
#	Line 169 | Line 167 | freesources()                  /* free all source structures */
167		}
168
169
170	<	int
170	>	extern int
171		srcray(                         /* send a ray to a source, return domega */
172	<	register RAY  *sr,              /* returned source ray */
173	<	RAY  *r,                        /* ray which hit object */
174	<	SRCINDEX  *si                   /* source sample index */
172	>	register RAY  *sr,              /* returned source ray */
173	>	RAY  *r,                        /* ray which hit object */
174	>	SRCINDEX  *si                   /* source sample index */
175		)
176		{
177		double  d;                          /* distance to source */
178		register SRCREC  *srcp;
179
180	<	rayorigin(sr, r, SHADOW, 1.0);              /* ignore limits */
180	>	rayorigin(sr, SHADOW, r, NULL);             /* ignore limits */
181
182		while ((d = nextssamp(sr, si)) != 0.0) {
183		sr->rsrc = si->sn;                      /* remember source */
#	Line 208 | Line 206 | SRCINDEX  *si                  /* source sample index */
206		}
207
208
209	<	void
209	>	extern void
210		srcvalue(                       /* punch ray to source and compute value */
211	<	register RAY  *r
211	>	register RAY  *r
212		)
213		{
214		register SRCREC  *sp;
#	Line 250 | Line 248 | nomat:
248		}
249
250
251	<	int
251	>	static int
252	>	transillum(                     /* check if material is transparent illum */
253	>	OBJECT  obj
254	>	)
255	>	{
256	>	OBJREC *m = findmaterial(objptr(obj));
257	>
258	>	if (m == NULL)
259	>	return(1);
260	>	if (m->otype != MAT_ILLUM)
261	>	return(0);
262	>	return(!m->oargs.nsargs || !strcmp(m->oargs.sarg[0], VOIDID));
263	>	}
264	>
265	>
266	>	extern int
267		sourcehit(                      /* check to see if ray hit distant source */
268	<	register RAY  *r
268	>	register RAY  *r
269		)
270		{
271	+	int  glowsrc = -1;
272	+	int  transrc = -1;
273		int  first, last;
274		register int  i;
275
#	Line 263 | Line 278 | register RAY  *r
278		} else {                        /* otherwise check all */
279		first = 0; last = nsources-1;
280		}
281	<	for (i = first; i <= last; i++)
282	<	if ((source[i].sflags & (SDISTANT|SVIRTUAL)) == SDISTANT)
283	<	/*
284	<	* Check to see if ray is within
285	<	* solid angle of source.
286	<	*/
287	<	if (2.0*PI * (1.0 - DOT(source[i].sloc,r->rdir))
288	<	<= source[i].ss2) {
289	<	r->ro = source[i].so;
290	<	if (!(source[i].sflags & SSKIP))
291	<	break;
292	<	}
293	<
294	<	if (r->ro != NULL) {
295	<	r->robj = objndx(r->ro);
296	<	for (i = 0; i < 3; i++)
297	<	r->ron[i] = -r->rdir[i];
298	<	r->rod = 1.0;
299	<	r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
300	<	r->uv[0] = r->uv[1] = 0.0;
301	<	r->rox = NULL;
302	<	return(1);
281	>	for (i = first; i <= last; i++) {
282	>	if ((source[i].sflags & (SDISTANT|SVIRTUAL)) != SDISTANT)
283	>	continue;
284	>	/*
285	>	* Check to see if ray is within
286	>	* solid angle of source.
287	>	*/
288	>	if (2.*PI*(1. - DOT(source[i].sloc,r->rdir)) > source[i].ss2)
289	>	continue;
290	>	/* is it the only possibility? */
291	>	if (first == last) {
292	>	r->ro = source[i].so;
293	>	break;
294	>	}
295	>	/*
296	>	* If it's a glow or transparent illum, just remember it.
297	>	*/
298	>	if (source[i].sflags & SSKIP) {
299	>	glowsrc = i;
300	>	continue;
301	>	}
302	>	if (transillum(source[i].so->omod)) {
303	>	transrc = i;
304	>	continue;
305	>	}
306	>	r->ro = source[i].so;   /* otherwise, use first hit */
307	>	break;
308		}
309	<	return(0);
309	>	/*
310	>	* Do we need fallback?
311	>	*/
312	>	if (r->ro == NULL) {
313	>	if (transrc >= 0 && r->crtype & (AMBIENT|SPECULAR))
314	>	return(0);      /* avoid overcounting */
315	>	if (glowsrc >= 0)
316	>	r->ro = source[glowsrc].so;
317	>	else
318	>	return(0);      /* nothing usable */
319	>	}
320	>	/*
321	>	* Make assignments.
322	>	*/
323	>	r->robj = objndx(r->ro);
324	>	for (i = 0; i < 3; i++)
325	>	r->ron[i] = -r->rdir[i];
326	>	r->rod = 1.0;
327	>	r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
328	>	r->uv[0] = r->uv[1] = 0.0;
329	>	r->rox = NULL;
330	>	return(1);
331		}
332
333
334		static int
335		cntcmp(                         /* contribution compare (descending) */
336	<	const void *p1,
337	<	const void *p2
336	>	const void *p1,
337	>	const void *p2
338		)
339		{
340		register const CNTPTR  *sc1 = (const CNTPTR *)p1;
#	Line 307 | Line 348 | const void *p2
348		}
349
350
351	<	void
351	>	extern void
352		direct(                                 /* add direct component */
353	<	RAY  *r,                        /* ray that hit surface */
354	<	void  (*f)(),                   /* direct component coefficient function */
355	<	char  *p                        /* data for f */
353	>	RAY  *r,                        /* ray that hit surface */
354	>	srcdirf_t *f,                   /* direct component coefficient function */
355	>	void  *p                        /* data for f */
356		)
357		{
317	–	extern void  (*trace)();
358		register int  sn;
359		register CONTRIB  *scp;
360		SRCINDEX  si;
#	Line 353 | Line 393 | char  *p                       /* data for f */
393		}
394		#endif
395		VCOPY(scp->dir, sr.rdir);
396	+	copycolor(sr.rcoef, scp->coef);
397		/* compute potential */
398		sr.revf = srcvalue;
399		rayvalue(&sr);
400	+	multcolor(sr.rcol, sr.rcoef);
401		copycolor(scp->val, sr.rcol);
360	–	multcolor(scp->val, scp->coef);
402		cntord[sn].brt = bright(scp->val);
403		}
404		/* sort contributions */
#	Line 396 | Line 437 | char  *p                       /* data for f */
437		break;
438		scp = srccnt + cntord[sn].sndx;
439		/* test for hit */
440	<	rayorigin(&sr, r, SHADOW, 1.0);
440	>	rayorigin(&sr, SHADOW, r, NULL);
441	>	copycolor(sr.rcoef, scp->coef);
442		VCOPY(sr.rdir, scp->dir);
443		sr.rsrc = scp->sno;
444		/* keep statistics */
#	Line 409 | Line 451 | char  *p                       /* data for f */
451		source[scp->sno].sflags & SFOLLOW )) {
452		/* follow entire path */
453		raycont(&sr);
412	–	rayparticipate(&sr);
454		if (trace != NULL)
455		(*trace)(&sr);  /* trace execution */
456	+	rayparticipate(&sr);
457		if (bright(sr.rcol) <= FTINY) {
458		#if SHADCACHE
459		if ((scp <= srccnt || scp[-1].sno != scp->sno)
#	Line 421 | Line 463 | char  *p                       /* data for f */
463		#endif
464		continue;       /* missed! */
465		}
466	+	multcolor(sr.rcol, sr.rcoef);
467		copycolor(scp->val, sr.rcol);
468	<	multcolor(scp->val, scp->coef);
468	>	} else if (trace != NULL &&
469	>	(source[scp->sno].sflags & (SDISTANT|SVIRTUAL|SFOLLOW))
470	>	== (SDISTANT|SFOLLOW) &&
471	>	sourcehit(&sr) && rayshade(&sr, sr.ro->omod)) {
472	>	(*trace)(&sr);          /* trace execution */
473	>	/* skip call to rayparticipate() & scp->val update */
474		}
475		/* add contribution if hit */
476		addcolor(r->rcol, scp->val);
#	Line 444 | Line 492 | char  *p                       /* data for f */
492		scp = srccnt + cntord[sn].sndx;
493		prob = hwt * (double)source[scp->sno].nhits /
494		(double)source[scp->sno].ntests;
495	<	if (prob > 1.0)
496	<	prob = 1.0;
449	<	scalecolor(scp->val, prob);
495	>	if (prob < 1.0)
496	>	scalecolor(scp->val, prob);
497		addcolor(r->rcol, scp->val);
498		}
499		}
500
501
502	<	void
502	>	extern void
503		srcscatter(                     /* compute source scattering into ray */
504	<	register RAY  *r
504	>	register RAY  *r
505		)
506		{
507		int  oldsampndx;
#	Line 500 | Line 547 | register RAY  *r
547		if (!srcray(&sr, NULL, &si) ||
548		sr.rsrc != r->slights[i])
549		continue;               /* no path */
550	+	#if SHADCACHE
551	+	if (srcblocked(&sr))            /* check shadow cache */
552	+	continue;
553	+	#endif
554		copycolor(sr.cext, r->cext);
555		copycolor(sr.albedo, r->albedo);
556		sr.gecc = r->gecc;
557		sr.slights = r->slights;
558		rayvalue(&sr);                  /* eval. source ray */
559	<	if (bright(sr.rcol) <= FTINY)
559	>	if (bright(sr.rcol) <= FTINY) {
560	>	#if SHADCACHE
561	>	srcblocker(&sr);        /* add blocker to cache */
562	>	#endif
563		continue;
564	+	}
565		if (r->gecc <= FTINY)           /* compute P(theta) */
566		d = 1.;
567		else {
#	Line 544 | Line 599 | register RAY  *r
599		*/
600
601		static int
602	<	weaksrcmat(int obj)             /* identify material */
602	>	weaksrcmat(OBJECT obj)          /* identify material */
603		{
604	<	register OBJREC *o = objptr(obj);
604	>	OBJREC *m = findmaterial(objptr(obj));
605
606	<	while (!ismaterial(o->otype))   /* find material */
607	<	o = objptr(o->omod);
553	<	return((o->otype==MAT_ILLUM)|(o->otype==MAT_GLOW));
606	>	if (m == NULL) return(0);
607	>	return((m->otype==MAT_ILLUM) | (m->otype==MAT_GLOW));
608		}
609
610		#define  illumblock(m, r)       (!(source[r->rsrc].sflags&SVIRTUAL) && \
#	Line 611 | Line 665 | weaksrcmat(int obj)            /* identify material */
665		distglow(m, r, raydist(r,PRIMARY)))
666
667
668	<	int
668	>	extern int
669		m_light(                                /* ray hit a light source */
670	<	register OBJREC  *m,
671	<	register RAY  *r
670	>	register OBJREC  *m,
671	>	register RAY  *r
672		)
673		{
674		/* check for over-counting */
675	<	if (badcomponent(m, r))
675	>	if (badcomponent(m, r)) {
676	>	setcolor(r->rcoef, 0.0, 0.0, 0.0);
677		return(1);
678	<	if (wrongsource(m, r))
678	>	}
679	>	if (wrongsource(m, r)) {
680	>	setcolor(r->rcoef, 0.0, 0.0, 0.0);
681		return(1);
682	+	}
683		/* check for passed illum */
684		if (passillum(m, r)) {
685		if (m->oargs.nsargs && strcmp(m->oargs.sarg[0], VOIDID))
#	Line 629 | Line 687 | register RAY  *r
687		raytrans(r);
688		return(1);
689		}
690	+	/* check for invisibility */
691	+	if (srcignore(m, r)) {
692	+	setcolor(r->rcoef, 0.0, 0.0, 0.0);
693	+	return(1);
694	+	}
695		/* otherwise treat as source */
696		/* check for behind */
697		if (r->rod < 0.0)
635	–	return(1);
636	–	/* check for invisibility */
637	–	if (srcignore(m, r))
698		return(1);
699		/* check for outside spot */
700		if (m->otype==MAT_SPOT && spotout(r, makespot(m)))

Diff Legend

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