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.29 by greg, Sat Feb 22 02:07:29 2003 UTC vs.
Revision 2.72 by greg, Mon Apr 6 21:09:07 2020 UTC

#	Line 1 | Line 1
1		#ifndef lint
2	<	static const char       RCSid[] = "$Id$";
2	>	static const char RCSid[] = "$Id$";
3		#endif
4		/*
5		*  source.c - routines dealing with illumination sources.
#	Line 7 | Line 7 | static const char      RCSid[] = "$Id$";
7		*  External symbols declared in source.h
8		*/
9
10	–	/* ====================================================================
11	–	* The Radiance Software License, Version 1.0
12	–	*
13	–	* Copyright (c) 1990 - 2002 The Regents of the University of California,
14	–	* through Lawrence Berkeley National Laboratory.   All rights reserved.
15	–	*
16	–	* Redistribution and use in source and binary forms, with or without
17	–	* modification, are permitted provided that the following conditions
18	–	* are met:
19	–	*
20	–	* 1. Redistributions of source code must retain the above copyright
21	–	*         notice, this list of conditions and the following disclaimer.
22	–	*
23	–	* 2. Redistributions in binary form must reproduce the above copyright
24	–	*       notice, this list of conditions and the following disclaimer in
25	–	*       the documentation and/or other materials provided with the
26	–	*       distribution.
27	–	*
28	–	* 3. The end-user documentation included with the redistribution,
29	–	*           if any, must include the following acknowledgment:
30	–	*             "This product includes Radiance software
31	–	*                 (http://radsite.lbl.gov/)
32	–	*                 developed by the Lawrence Berkeley National Laboratory
33	–	*               (http://www.lbl.gov/)."
34	–	*       Alternately, this acknowledgment may appear in the software itself,
35	–	*       if and wherever such third-party acknowledgments normally appear.
36	–	*
37	–	* 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
38	–	*       and "The Regents of the University of California" must
39	–	*       not be used to endorse or promote products derived from this
40	–	*       software without prior written permission. For written
41	–	*       permission, please contact [email protected].
42	–	*
43	–	* 5. Products derived from this software may not be called "Radiance",
44	–	*       nor may "Radiance" appear in their name, without prior written
45	–	*       permission of Lawrence Berkeley National Laboratory.
46	–	*
47	–	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
48	–	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
49	–	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
50	–	* DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
51	–	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
52	–	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
53	–	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
54	–	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
55	–	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
56	–	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
57	–	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58	–	* SUCH DAMAGE.
59	–	* ====================================================================
60	–	*
61	–	* This software consists of voluntary contributions made by many
62	–	* individuals on behalf of Lawrence Berkeley National Laboratory.   For more
63	–	* information on Lawrence Berkeley National Laboratory, please see
64	–	* <http://www.lbl.gov/>.
65	–	*/
66	–
10		#include  "ray.h"
68	–
11		#include  "otypes.h"
12	<
12	>	#include  "otspecial.h"
13	>	#include  "rtotypes.h"
14		#include  "source.h"
72	–
15		#include  "random.h"
16	+	#include  "pmapsrc.h"
17	+	#include  "pmapmat.h"
18
75	–	extern double  ssampdist;               /* scatter sampling distance */
76	–
19		#ifndef MAXSSAMP
20		#define MAXSSAMP        16              /* maximum samples per ray */
21		#endif
#	Line 98 | Line 40 | static CONTRIB  *srccnt;               /* source contributions in d
40		static CNTPTR  *cntord;                 /* source ordering in direct() */
41		static int  maxcntr = 0;                /* size of contribution arrays */
42
43	+	static int cntcmp(const void *p1, const void *p2);
44
45	+
46		void
47	<	marksources()                   /* find and mark source objects */
47	>	marksources(void)                       /* find and mark source objects */
48		{
49		int  foundsource = 0;
50		int  i;
51	<	register OBJREC  *o, *m;
52	<	register int  ns;
51	>	OBJREC  *o, *m;
52	>	int  ns;
53		/* initialize dispatch table */
54		initstypes();
55		/* find direct sources */
56	<	for (i = 0; i < nobjects; i++) {
56	>	for (i = 0; i < nsceneobjs; i++) {
57
58		o = objptr(i);
59
60		if (!issurface(o->otype) || o->omod == OVOID)
61		continue;
62	<
63	<	m = objptr(o->omod);
64	<
121	<	if (!islight(m->otype))
62	>	/* find material */
63	>	m = findmaterial(objptr(o->omod));
64	>	if (m == NULL)
65		continue;
66	+	if (m->otype == MAT_CLIP) {
67	+	markclip(m);    /* special case for antimatter */
68	+	continue;
69	+	}
70	+	if (!islight(m->otype))
71	+	continue;       /* not source modifier */
72
73		if (m->oargs.nfargs != (m->otype == MAT_GLOW ? 4 :
74		m->otype == MAT_SPOT ? 7 : 3))
75		objerror(m, USER, "bad # arguments");
76
77	+	if (m->oargs.farg[0] <= FTINY && (m->oargs.farg[1] <= FTINY) &
78	+	(m->oargs.farg[2] <= FTINY))
79	+	continue;                       /* don't bother */
80		if (m->otype == MAT_GLOW &&
81		o->otype != OBJ_SOURCE &&
82	<	m->oargs.farg[3] <= FTINY)
83	<	continue;                       /* don't bother */
84	<	if (m->oargs.farg[0] <= FTINY && m->oargs.farg[1] <= FTINY &&
85	<	m->oargs.farg[2] <= FTINY)
134	<	continue;                       /* don't bother */
135	<
82	>	m->oargs.farg[3] <= FTINY) {
83	>	foundsource += (ambounce > 0);
84	>	continue;                       /* don't track these */
85	>	}
86		if (sfun[o->otype].of == NULL ||
87		sfun[o->otype].of->setsrc == NULL)
88		objerror(o, USER, "illegal material");
#	Line 145 | Line 95 | marksources()                  /* find and mark source objects */
95		if (m->otype == MAT_GLOW) {
96		source[ns].sflags |= SPROX;
97		source[ns].sl.prox = m->oargs.farg[3];
98	<	if (source[ns].sflags & SDISTANT)
98	>	if (source[ns].sflags & SDISTANT) {
99		source[ns].sflags |= SSKIP;
100	+	foundsource += (ambounce > 0);
101	+	}
102		} else if (m->otype == MAT_SPOT) {
103	+	if (source[ns].sflags & SDISTANT)
104	+	objerror(o, WARNING,
105	+	"distant source is a spotlight");
106		source[ns].sflags |= SSPOT;
107		if ((source[ns].sl.s = makespot(m)) == NULL)
108		goto memerr;
#	Line 158 | Line 113 | marksources()                  /* find and mark source objects */
113		source[ns].sflags |= SSKIP;
114		}
115		}
116	<	if (!(source[ns].sflags & SSKIP))
162	<	foundsource++;
116	>	foundsource += !(source[ns].sflags & SSKIP);
117		}
118		if (!foundsource) {
119		error(WARNING, "no light sources found");
120		return;
121		}
122	<	markvirtuals();                 /* find and add virtual sources */
122	>	#if  SHADCACHE
123	>	for (ns = 0; ns < nsources; ns++)       /* initialize obstructor cache */
124	>	initobscache(ns);
125	>	#endif
126	>	/* PMAP: disable virtual sources */
127	>	if (!photonMapping)
128	>	markvirtuals();                 /* find and add virtual sources */
129	>
130		/* allocate our contribution arrays */
131		maxcntr = nsources + MAXSPART;  /* start with this many */
132		srccnt = (CONTRIB *)malloc(maxcntr*sizeof(CONTRIB));
133		cntord = (CNTPTR *)malloc(maxcntr*sizeof(CNTPTR));
134	<	if (srccnt == NULL | cntord == NULL)
135	<	goto memerr;
175	<	return;
134	>	if ((srccnt != NULL) & (cntord != NULL))
135	>	return;
136		memerr:
137		error(SYSTEM, "out of memory in marksources");
138		}
139
140
141		void
142	<	freesources()                   /* free all source structures */
142	>	distantsources(void)                    /* only mark distant sources */
143		{
144	+	int  i;
145	+	OBJREC  *o, *m;
146	+	int  ns;
147	+	/* initialize dispatch table */
148	+	initstypes();
149	+	/* sources needed for sourcehit() */
150	+	for (i = 0; i < nsceneobjs; i++) {
151	+
152	+	o = objptr(i);
153	+
154	+	if ((o->otype != OBJ_SOURCE) | (o->omod == OVOID))
155	+	continue;
156	+	/* find material */
157	+	m = findmaterial(objptr(o->omod));
158	+	if (m == NULL)
159	+	continue;
160	+	if (!islight(m->otype))
161	+	continue;       /* not source modifier */
162	+
163	+	if (m->oargs.nfargs != (m->otype == MAT_GLOW ? 4 :
164	+	m->otype == MAT_SPOT ? 7 : 3))
165	+	objerror(m, USER, "bad # arguments");
166	+
167	+	if (m->oargs.farg[0] <= FTINY && (m->oargs.farg[1] <= FTINY) &
168	+	(m->oargs.farg[2] <= FTINY))
169	+	continue;                       /* don't bother */
170	+	if (sfun[o->otype].of == NULL ||
171	+	sfun[o->otype].of->setsrc == NULL)
172	+	objerror(o, USER, "illegal material");
173	+
174	+	if ((ns = newsource()) < 0)
175	+	error(SYSTEM, "out of memory in distantsources");
176	+
177	+	setsource(&source[ns], o);
178	+
179	+	if (m->otype == MAT_GLOW) {
180	+	source[ns].sflags |= SPROX|SSKIP;
181	+	source[ns].sl.prox = m->oargs.farg[3];
182	+	} else if (m->otype == MAT_SPOT)
183	+	objerror(o, WARNING, "distant source is a spotlight");
184	+	}
185	+	}
186	+
187	+
188	+	void
189	+	freesources(void)                       /* free all source structures */
190	+	{
191		if (nsources > 0) {
192	+	#if SHADCACHE
193	+	while (nsources--)
194	+	freeobscache(&source[nsources]);
195	+	#endif
196		free((void *)source);
197		source = NULL;
198		nsources = 0;
199		}
200	+	markclip(NULL);
201		if (maxcntr <= 0)
202		return;
203		free((void *)srccnt);
#	Line 197 | Line 209 | freesources()                  /* free all source structures */
209
210
211		int
212	<	srcray(sr, r, si)               /* send a ray to a source, return domega */
213	<	register RAY  *sr;              /* returned source ray */
214	<	RAY  *r;                        /* ray which hit object */
215	<	SRCINDEX  *si;                  /* source sample index */
212	>	srcray(                         /* send a ray to a source, return domega */
213	>	RAY  *sr,               /* returned source ray */
214	>	RAY  *r,                        /* ray which hit object */
215	>	SRCINDEX  *si                   /* source sample index */
216	>	)
217		{
218	<	double  d;                          /* distance to source */
219	<	register SRCREC  *srcp;
218	>	double  d;                              /* distance to source */
219	>	SRCREC  *srcp;
220
221	<	rayorigin(sr, r, SHADOW, 1.0);              /* ignore limits */
221	>	rayorigin(sr, SHADOW, r, NULL);         /* ignore limits */
222
223	<	while ((d = nextssamp(sr, si)) != 0.0) {
224	<	sr->rsrc = si->sn;                      /* remember source */
225	<	srcp = source + si->sn;
226	<	if (srcp->sflags & SDISTANT) {
227	<	if (srcp->sflags & SSPOT && spotout(sr, srcp->sl.s))
228	<	continue;
229	<	return(1);              /* sample OK */
230	<	}
223	>	if (r == NULL)
224	>	sr->rmax = 0.0;
225	>
226	>	while ((d = nextssamp(sr, si)) != 0.0) {
227	>	sr->rsrc = si->sn;                      /* remember source */
228	>	srcp = source + si->sn;
229	>	if (srcp->sflags & SDISTANT) {
230	>	if (srcp->sflags & SSPOT && spotout(sr, srcp->sl.s))
231	>	continue;
232	>	return(1);              /* sample OK */
233	>	}
234		/* local source */
235		/* check proximity */
236	<	if (srcp->sflags & SPROX && d > srcp->sl.prox)
221	<	continue;
222	<	/* check angle */
223	<	if (srcp->sflags & SSPOT) {
224	<	if (spotout(sr, srcp->sl.s))
236	>	if (srcp->sflags & SPROX && d > srcp->sl.prox)
237		continue;
238	+	/* check angle */
239	+	if (srcp->sflags & SSPOT) {
240	+	if (spotout(sr, srcp->sl.s))
241	+	continue;
242		/* adjust solid angle */
243	<	si->dom *= d*d;
244	<	d += srcp->sl.s->flen;
245	<	si->dom /= d*d;
243	>	si->dom *= d*d;
244	>	d += srcp->sl.s->flen;
245	>	si->dom /= d*d;
246	>	}
247	>	return(1);                      /* sample OK */
248		}
249	<	return(1);                      /* sample OK */
232	<	}
233	<	return(0);                  /* no more samples */
249	>	return(0);                      /* no more samples */
250		}
251
252
253		void
254	<	srcvalue(r)                     /* punch ray to source and compute value */
255	<	register RAY  *r;
254	>	srcvalue(                       /* punch ray to source and compute value */
255	>	RAY  *r
256	>	)
257		{
258	<	register SRCREC  *sp;
258	>	SRCREC  *sp;
259
260		sp = &source[r->rsrc];
261		if (sp->sflags & SVIRTUAL) {    /* virtual source */
#	Line 275 | Line 292 | nomat:
292		}
293
294
295	+	static int
296	+	transillum(                     /* check if material is transparent illum */
297	+	OBJECT  obj
298	+	)
299	+	{
300	+	OBJREC *m = findmaterial(objptr(obj));
301	+
302	+	if (m == NULL)
303	+	return(1);
304	+	if (m->otype != MAT_ILLUM)
305	+	return(0);
306	+	return(!m->oargs.nsargs || !strcmp(m->oargs.sarg[0], VOIDID));
307	+	}
308	+
309	+
310		int
311	<	sourcehit(r)                    /* check to see if ray hit distant source */
312	<	register RAY  *r;
311	>	sourcehit(                      /* check to see if ray hit distant source */
312	>	RAY  *r
313	>	)
314		{
315	+	int  glowsrc = -1;
316	+	int  transrc = -1;
317		int  first, last;
318	<	register int  i;
318	>	int  i;
319
320		if (r->rsrc >= 0) {             /* check only one if aimed */
321		first = last = r->rsrc;
322		} else {                        /* otherwise check all */
323		first = 0; last = nsources-1;
324		}
325	<	for (i = first; i <= last; i++)
326	<	if ((source[i].sflags & (SDISTANT|SVIRTUAL)) == SDISTANT)
327	<	/*
328	<	* Check to see if ray is within
329	<	* solid angle of source.
330	<	*/
331	<	if (2.0*PI * (1.0 - DOT(source[i].sloc,r->rdir))
332	<	<= source[i].ss2) {
333	<	r->ro = source[i].so;
334	<	if (!(source[i].sflags & SSKIP))
335	<	break;
336	<	}
337	<
338	<	if (r->ro != NULL) {
339	<	r->robj = objndx(r->ro);
340	<	for (i = 0; i < 3; i++)
341	<	r->ron[i] = -r->rdir[i];
342	<	r->rod = 1.0;
343	<	r->rox = NULL;
344	<	return(1);
325	>	for (i = first; i <= last; i++) {
326	>	if ((source[i].sflags & (SDISTANT|SVIRTUAL)) != SDISTANT)
327	>	continue;
328	>	/*
329	>	* Check to see if ray is within
330	>	* solid angle of source.
331	>	*/
332	>	if (2.*PI*(1. - DOT(source[i].sloc,r->rdir)) > source[i].ss2)
333	>	continue;
334	>	/* is it the only possibility? */
335	>	if (first == last) {
336	>	r->ro = source[i].so;
337	>	break;
338	>	}
339	>	/*
340	>	* If it's a glow or transparent illum, just remember it.
341	>	*/
342	>	if (source[i].sflags & SSKIP) {
343	>	if (glowsrc < 0)
344	>	glowsrc = i;
345	>	continue;
346	>	}
347	>	if (transillum(source[i].so->omod)) {
348	>	if (transrc < 0)
349	>	transrc = i;
350	>	continue;
351	>	}
352	>	r->ro = source[i].so;   /* otherwise, use first hit */
353	>	break;
354		}
355	<	return(0);
355	>	/*
356	>	* Do we need fallback?
357	>	*/
358	>	if (r->ro == NULL) {
359	>	if (transrc >= 0 && r->crtype & (AMBIENT|SPECULAR))
360	>	return(0);      /* avoid overcounting */
361	>	if (glowsrc >= 0)
362	>	r->ro = source[glowsrc].so;
363	>	else
364	>	return(0);      /* nothing usable */
365	>	}
366	>	/*
367	>	* Make assignments.
368	>	*/
369	>	r->robj = objndx(r->ro);
370	>	for (i = 0; i < 3; i++)
371	>	r->ron[i] = -r->rdir[i];
372	>	r->rod = 1.0;
373	>	r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
374	>	r->uv[0] = r->uv[1] = 0.0;
375	>	r->rox = NULL;
376	>	return(1);
377		}
378
379
380		static int
381	<	cntcmp(sc1, sc2)                        /* contribution compare (descending) */
382	<	register CNTPTR  *sc1, *sc2;
381	>	cntcmp(                         /* contribution compare (descending) */
382	>	const void *p1,
383	>	const void *p2
384	>	)
385		{
386	+	const CNTPTR  *sc1 = (const CNTPTR *)p1;
387	+	const CNTPTR  *sc2 = (const CNTPTR *)p2;
388	+
389		if (sc1->brt > sc2->brt)
390		return(-1);
391		if (sc1->brt < sc2->brt)
#	Line 325 | Line 395 | register CNTPTR  *sc1, *sc2;
395
396
397		void
398	<	direct(r, f, p)                         /* add direct component */
399	<	RAY  *r;                        /* ray that hit surface */
400	<	void  (*f)();                   /* direct component coefficient function */
401	<	char  *p;                       /* data for f */
398	>	direct(                                 /* add direct component */
399	>	RAY  *r,                        /* ray that hit surface */
400	>	srcdirf_t *f,                   /* direct component coefficient function */
401	>	void  *p                        /* data for f */
402	>	)
403		{
404	<	extern void  (*trace)();
405	<	register int  sn;
335	<	register CONTRIB  *scp;
404	>	int  sn;
405	>	CONTRIB  *scp;
406		SRCINDEX  si;
407		int  nshadcheck, ncnts;
408		int  nhits;
409		double  prob, ourthresh, hwt;
410		RAY  sr;
411	+
412	+	/* PMAP: Factor in direct photons (primarily for debugging/validation) */
413	+	if (directPhotonMapping) {
414	+	(*f)(r -> rcol, p, r -> ron, PI);
415	+	multDirectPmap(r);
416	+	return;
417	+	}
418	+
419		/* NOTE: srccnt and cntord global so no recursion */
420		if (nsources <= 0)
421		return;         /* no sources?! */
#	Line 346 | Line 424 | char  *p;                      /* data for f */
424		for (sn = 0; srcray(&sr, r, &si); sn++) {
425		if (sn >= maxcntr) {
426		maxcntr = sn + MAXSPART;
427	<	srccnt = (CONTRIB *)realloc((char *)srccnt,
427	>	srccnt = (CONTRIB *)realloc((void *)srccnt,
428		maxcntr*sizeof(CONTRIB));
429	<	cntord = (CNTPTR *)realloc((char *)cntord,
429	>	cntord = (CNTPTR *)realloc((void *)cntord,
430		maxcntr*sizeof(CNTPTR));
431	<	if (srccnt == NULL | cntord == NULL)
431	>	if ((srccnt == NULL) | (cntord == NULL))
432		error(SYSTEM, "out of memory in direct");
433		}
434		cntord[sn].sndx = sn;
#	Line 358 | Line 436 | char  *p;                      /* data for f */
436		scp->sno = sr.rsrc;
437		/* compute coefficient */
438		(*f)(scp->coef, p, sr.rdir, si.dom);
439	<	cntord[sn].brt = bright(scp->coef);
439	>	cntord[sn].brt = intens(scp->coef);
440		if (cntord[sn].brt <= 0.0)
441		continue;
442	+	#if SHADCACHE
443	+	/* check shadow cache */
444	+	if (si.np == 1 && srcblocked(&sr)) {
445	+	cntord[sn].brt = 0.0;
446	+	continue;
447	+	}
448	+	#endif
449		VCOPY(scp->dir, sr.rdir);
450	+	copycolor(sr.rcoef, scp->coef);
451		/* compute potential */
452		sr.revf = srcvalue;
453		rayvalue(&sr);
454	+	multcolor(sr.rcol, sr.rcoef);
455		copycolor(scp->val, sr.rcol);
456	<	multcolor(scp->val, scp->coef);
370	<	cntord[sn].brt = bright(scp->val);
456	>	cntord[sn].brt = bright(sr.rcol);
457		}
458		/* sort contributions */
459		qsort(cntord, sn, sizeof(CNTPTR), cntcmp);
460		{                                       /* find last */
461	<	register int  l, m;
461	>	int  l, m;
462
463		ncnts = l = sn;
464		sn = 0;
#	Line 392 | Line 478 | char  *p;                      /* data for f */
478		/* compute number to check */
479		nshadcheck = pow((double)ncnts, shadcert) + .5;
480		/* modify threshold */
481	<	ourthresh = shadthresh / r->rweight;
481	>	if (ncnts > MINSHADCNT)
482	>	ourthresh = shadthresh / r->rweight;
483	>	else
484	>	ourthresh = 0;
485		/* test for shadows */
486		for (nhits = 0, hwt = 0.0, sn = 0; sn < ncnts;
487		hwt += (double)source[scp->sno].nhits /
#	Line 405 | Line 494 | char  *p;                      /* data for f */
494		break;
495		scp = srccnt + cntord[sn].sndx;
496		/* test for hit */
497	<	rayorigin(&sr, r, SHADOW, 1.0);
497	>	rayorigin(&sr, SHADOW, r, NULL);
498	>	copycolor(sr.rcoef, scp->coef);
499		VCOPY(sr.rdir, scp->dir);
500		sr.rsrc = scp->sno;
501	<	source[scp->sno].ntests++;      /* keep statistics */
501	>	/* keep statistics */
502	>	if (source[scp->sno].ntests++ > 0xfffffff0) {
503	>	source[scp->sno].ntests >>= 1;
504	>	source[scp->sno].nhits >>= 1;
505	>	}
506		if (localhit(&sr, &thescene) &&
507		( sr.ro != source[scp->sno].so ||
508		source[scp->sno].sflags & SFOLLOW )) {
509		/* follow entire path */
510		raycont(&sr);
417	–	rayparticipate(&sr);
511		if (trace != NULL)
512		(*trace)(&sr);  /* trace execution */
513	<	if (bright(sr.rcol) <= FTINY)
513	>	if (bright(sr.rcol) <= FTINY) {
514	>	#if SHADCACHE
515	>	if ((scp <= srccnt || scp[-1].sno != scp->sno)
516	>	&& (scp >= srccnt+ncnts-1 ||
517	>	scp[1].sno != scp->sno))
518	>	srcblocker(&sr);
519	>	#endif
520		continue;       /* missed! */
521	+	}
522	+	rayparticipate(&sr);
523	+	multcolor(sr.rcol, sr.rcoef);
524		copycolor(scp->val, sr.rcol);
525	<	multcolor(scp->val, scp->coef);
525	>	} else if (trace != NULL &&
526	>	(source[scp->sno].sflags & (SDISTANT|SVIRTUAL|SFOLLOW))
527	>	== (SDISTANT|SFOLLOW) &&
528	>	sourcehit(&sr) && rayshade(&sr, sr.ro->omod)) {
529	>	(*trace)(&sr);          /* trace execution */
530	>	/* skip call to rayparticipate() & scp->val update */
531		}
532		/* add contribution if hit */
533		addcolor(r->rcol, scp->val);
#	Line 442 | Line 549 | char  *p;                      /* data for f */
549		scp = srccnt + cntord[sn].sndx;
550		prob = hwt * (double)source[scp->sno].nhits /
551		(double)source[scp->sno].ntests;
552	<	if (prob > 1.0)
553	<	prob = 1.0;
447	<	scalecolor(scp->val, prob);
552	>	if (prob < 1.0)
553	>	scalecolor(scp->val, prob);
554		addcolor(r->rcol, scp->val);
555		}
556		}
557
558
559		void
560	<	srcscatter(r)                   /* compute source scattering into ray */
561	<	register RAY  *r;
560	>	srcscatter(                     /* compute source scattering into ray */
561	>	RAY  *r
562	>	)
563		{
564		int  oldsampndx;
565		int  nsamps;
#	Line 463 | Line 570 | register RAY  *r;
570		COLOR  cvext;
571		int  i, j;
572
573	<	if (r->slights == NULL || r->slights[0] == 0
574	<	|| r->gecc >= 1.-FTINY || r->rot >= FHUGE)
573	>	if (r->rot >= FHUGE*.99 || r->gecc >= 1.-FTINY)
574	>	return;         /* this can never work */
575	>	/* PMAP: do unconditional inscattering for volume photons */
576	>	if (!volumePhotonMapping && (r->slights == NULL || r->slights[0] == 0))
577		return;
578	+
579		if (ssampdist <= FTINY || (nsamps = r->rot/ssampdist + .5) < 1)
580		nsamps = 1;
581		#if MAXSSAMP
#	Line 474 | Line 584 | register RAY  *r;
584		#endif
585		oldsampndx = samplendx;
586		samplendx = random()&0x7fff;            /* randomize */
587	<	for (i = r->slights[0]; i > 0; i--) {   /* for each source */
587	>	for (i = volumePhotonMapping ? 1 : r->slights[0]; i > 0; i--) {
588	>	/* for each source OR once if volume photon map enabled */
589		for (j = 0; j < nsamps; j++) {  /* for each sample position */
590		samplendx++;
591		t = r->rot * (j+frandom())/nsamps;
#	Line 490 | Line 601 | register RAY  *r;
601		sr.rorg[0] = r->rorg[0] + r->rdir[0]*t;
602		sr.rorg[1] = r->rorg[1] + r->rdir[1]*t;
603		sr.rorg[2] = r->rorg[2] + r->rdir[2]*t;
604	<	sr.rmax = 0.;
605	<	initsrcindex(&si);      /* sample ray to this source */
606	<	si.sn = r->slights[i];
607	<	nopart(&si, &sr);
608	<	if (!srcray(&sr, NULL, &si) ||
609	<	sr.rsrc != r->slights[i])
610	<	continue;               /* no path */
611	<	copycolor(sr.cext, r->cext);
612	<	copycolor(sr.albedo, r->albedo);
613	<	sr.gecc = r->gecc;
614	<	sr.slights = r->slights;
615	<	rayvalue(&sr);                  /* eval. source ray */
616	<	if (bright(sr.rcol) <= FTINY)
617	<	continue;
618	<	if (r->gecc <= FTINY)           /* compute P(theta) */
619	<	d = 1.;
620	<	else {
621	<	d = DOT(r->rdir, sr.rdir);
622	<	d = 1. + r->gecc*r->gecc - 2.*r->gecc*d;
623	<	d = (1. - r->gecc*r->gecc) / (d*sqrt(d));
624	<	}
604	>
605	>	if (!volumePhotonMapping) {
606	>	initsrcindex(&si);      /* sample ray to this source */
607	>	si.sn = r->slights[i];
608	>	nopart(&si, &sr);
609	>	if (!srcray(&sr, NULL, &si) ||
610	>	sr.rsrc != r->slights[i])
611	>	continue;       /* no path */
612	>	#if SHADCACHE
613	>	if (srcblocked(&sr))    /* check shadow cache */
614	>	continue;
615	>	#endif
616	>	copycolor(sr.cext, r->cext);
617	>	copycolor(sr.albedo, r->albedo);
618	>	sr.gecc = r->gecc;
619	>	sr.slights = r->slights;
620	>	rayvalue(&sr);          /* eval. source ray */
621	>	if (bright(sr.rcol) <= FTINY) {
622	>	#if SHADCACHE
623	>	srcblocker(&sr); /* add blocker to cache */
624	>	#endif
625	>	continue;
626	>	}
627	>	if (r->gecc <= FTINY)   /* compute P(theta) */
628	>	d = 1.;
629	>	else {
630	>	d = DOT(r->rdir, sr.rdir);
631	>	d = 1. + r->gecc*r->gecc - 2.*r->gecc*d;
632	>	d = (1. - r->gecc*r->gecc) / (d*sqrt(d));
633	>	}
634		/* other factors */
635	<	d *= si.dom * r->rot / (4.*PI*nsamps);
635	>	d *= si.dom * r->rot / (4.*PI*nsamps);
636	>	scalecolor(sr.rcol, d);
637	>	} else {
638	>	/* PMAP: Add ambient inscattering from
639	>	* volume photons; note we reverse the
640	>	* incident ray direction since we're
641	>	* now in *backward* raytracing mode! */
642	>	sr.rdir [0] = -r -> rdir [0];
643	>	sr.rdir [1] = -r -> rdir [1];
644	>	sr.rdir [2] = -r -> rdir [2];
645	>	sr.gecc = r -> gecc;
646	>	inscatterVolumePmap(&sr, sr.rcol);
647	>	scalecolor(sr.rcol, r -> rot / nsamps);
648	>	}
649		multcolor(sr.rcol, r->cext);
650		multcolor(sr.rcol, r->albedo);
518	–	scalecolor(sr.rcol, d);
651		multcolor(sr.rcol, cvext);
652		addcolor(r->rcol, sr.rcol);     /* add it in */
653		}
#	Line 540 | Line 672 | register RAY  *r;
672		* geometry behind (or inside) an effective radiator.
673		*/
674
675	<	static int weaksrcmod(obj) int obj;     /* efficiency booster function */
676	<	{register OBJREC *o = objptr(obj);
677	<	return(o->otype==MAT_ILLUM|o->otype==MAT_GLOW);}
675	>	static int
676	>	weaksrcmat(OBJECT obj)          /* identify material */
677	>	{
678	>	OBJREC *m = findmaterial(objptr(obj));
679	>
680	>	if (m == NULL) return(0);
681	>	return((m->otype==MAT_ILLUM) | (m->otype==MAT_GLOW));
682	>	}
683
684		#define  illumblock(m, r)       (!(source[r->rsrc].sflags&SVIRTUAL) && \
685		r->rod > 0.0 && \
686	<	weaksrcmod(source[r->rsrc].so->omod))
686	>	weaksrcmat(source[r->rsrc].so->omod))
687
688		/* wrongsource *
689		*
#	Line 577 | Line 714 | return(o->otype==MAT_ILLUM|o->otype==MAT_GLOW);}
714		* The same is true for stray specular samples, since the specular
715		* contribution from light sources is calculated separately.
716		*/
717	<
718	<	#define  badcomponent(m, r)     (r->crtype&(AMBIENT|SPECULAR) && \
717	>	/* PMAP: Also avoid counting sources via transferred ambient rays (e.g.
718	>	* through glass) when photon mapping is enabled, as these indirect
719	>	* components are already accounted for.
720	>	*/
721	>	#define  badcomponent(m, r)   (srcRayInPmap(r) || \
722	>	(r->crtype&(AMBIENT|SPECULAR) && \
723		!(r->crtype&SHADOW || r->rod < 0.0 || \
724	<	/* not 100% correct */  distglow(m, r, r->rot)))
724	>	/* not 100% correct */  distglow(m, r, r->rot))))
725
726		/* passillum *
727		*
#	Line 603 | Line 744 | return(o->otype==MAT_ILLUM|o->otype==MAT_GLOW);}
744
745
746		int
747	<	m_light(m, r)                   /* ray hit a light source */
748	<	register OBJREC  *m;
749	<	register RAY  *r;
747	>	m_light(                                /* ray hit a light source */
748	>	OBJREC  *m,
749	>	RAY  *r
750	>	)
751		{
752		/* check for over-counting */
753	<	if (badcomponent(m, r))
753	>	if (badcomponent(m, r)) {
754	>	setcolor(r->rcoef, 0.0, 0.0, 0.0);
755		return(1);
756	<	if (wrongsource(m, r))
756	>	}
757	>	if (wrongsource(m, r)) {
758	>	setcolor(r->rcoef, 0.0, 0.0, 0.0);
759		return(1);
760	+	}
761		/* check for passed illum */
762		if (passillum(m, r)) {
763		if (m->oargs.nsargs && strcmp(m->oargs.sarg[0], VOIDID))
#	Line 619 | Line 765 | register RAY  *r;
765		raytrans(r);
766		return(1);
767		}
768	+	/* check for invisibility */
769	+	if (srcignore(m, r)) {
770	+	setcolor(r->rcoef, 0.0, 0.0, 0.0);
771	+	return(1);
772	+	}
773		/* otherwise treat as source */
774		/* check for behind */
775		if (r->rod < 0.0)
625	–	return(1);
626	–	/* check for invisibility */
627	–	if (srcignore(m, r))
776		return(1);
777		/* check for outside spot */
778		if (m->otype==MAT_SPOT && spotout(r, makespot(m)))

Diff Legend

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