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.21 by greg, Mon Dec 11 15:00:24 1995 UTC vs.
Revision 2.63 by greg, Mon Sep 15 00:54:39 2014 UTC

#	Line 1 | Line 1
1	–	/* Copyright (c) 1995 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		*  source.c - routines dealing with illumination sources.
6		*
7	<	*     8/20/85
7	>	*  External symbols declared in source.h
8		*/
9
10		#include  "ray.h"
14	–
15	–	#include  "octree.h"
16	–
11		#include  "otypes.h"
12	<
12	>	#include  "rtotypes.h"
13		#include  "source.h"
20	–
14		#include  "random.h"
15
16	<	extern double  ssampdist;               /* scatter sampling distance */
16	>	#ifndef MAXSSAMP
17	>	#define MAXSSAMP        16              /* maximum samples per ray */
18	>	#endif
19
20		/*
21		* Structures used by direct()
#	Line 42 | Line 37 | static CONTRIB  *srccnt;               /* source contributions in d
37		static CNTPTR  *cntord;                 /* source ordering in direct() */
38		static int  maxcntr = 0;                /* size of contribution arrays */
39
40	+	static int cntcmp(const void *p1, const void *p2);
41
42	<	marksources()                   /* find and mark source objects */
42	>
43	>	OBJREC *                        /* find an object's actual material */
44	>	findmaterial(OBJREC *o)
45		{
46	+	while (!ismaterial(o->otype)) {
47	+	if (o->otype == MOD_ALIAS && o->oargs.nsargs) {
48	+	OBJECT  aobj;
49	+	OBJREC  *ao;
50	+	aobj = lastmod(objndx(o), o->oargs.sarg[0]);
51	+	if (aobj < 0)
52	+	objerror(o, USER, "bad reference");
53	+	ao = objptr(aobj);
54	+	if (ismaterial(ao->otype))
55	+	return(ao);
56	+	if (ao->otype == MOD_ALIAS) {
57	+	o = ao;
58	+	continue;
59	+	}
60	+	}
61	+	if (o->omod == OVOID)
62	+	return(NULL);
63	+	o = objptr(o->omod);
64	+	}
65	+	return(o);              /* mixtures will return NULL */
66	+	}
67	+
68	+
69	+	void
70	+	marksources(void)                       /* find and mark source objects */
71	+	{
72		int  foundsource = 0;
73		int  i;
74	<	register OBJREC  *o, *m;
75	<	register int  ns;
74	>	OBJREC  *o, *m;
75	>	int  ns;
76		/* initialize dispatch table */
77		initstypes();
78		/* find direct sources */
79	<	for (i = 0; i < nobjects; i++) {
79	>	for (i = 0; i < nsceneobjs; i++) {
80
81		o = objptr(i);
82
83		if (!issurface(o->otype) || o->omod == OVOID)
84		continue;
85	<
86	<	m = objptr(o->omod);
87	<
64	<	if (!islight(m->otype))
85	>	/* find material */
86	>	m = findmaterial(objptr(o->omod));
87	>	if (m == NULL)
88		continue;
89	+	if (m->otype == MAT_CLIP) {
90	+	markclip(m);    /* special case for antimatter */
91	+	continue;
92	+	}
93	+	if (!islight(m->otype))
94	+	continue;       /* not source modifier */
95
96		if (m->oargs.nfargs != (m->otype == MAT_GLOW ? 4 :
97		m->otype == MAT_SPOT ? 7 : 3))
98		objerror(m, USER, "bad # arguments");
99
71	–	if (m->otype == MAT_GLOW &&
72	–	o->otype != OBJ_SOURCE &&
73	–	m->oargs.farg[3] <= FTINY)
74	–	continue;                       /* don't bother */
100		if (m->oargs.farg[0] <= FTINY && m->oargs.farg[1] <= FTINY &&
101		m->oargs.farg[2] <= FTINY)
102		continue;                       /* don't bother */
103	<
103	>	if (m->otype == MAT_GLOW &&
104	>	o->otype != OBJ_SOURCE &&
105	>	m->oargs.farg[3] <= FTINY) {
106	>	foundsource += (ambounce > 0);
107	>	continue;                       /* don't track these */
108	>	}
109		if (sfun[o->otype].of == NULL ||
110		sfun[o->otype].of->setsrc == NULL)
111		objerror(o, USER, "illegal material");
#	Line 88 | Line 118 | marksources()                  /* find and mark source objects */
118		if (m->otype == MAT_GLOW) {
119		source[ns].sflags |= SPROX;
120		source[ns].sl.prox = m->oargs.farg[3];
121	<	if (source[ns].sflags & SDISTANT)
121	>	if (source[ns].sflags & SDISTANT) {
122		source[ns].sflags |= SSKIP;
123	+	foundsource += (ambounce > 0);
124	+	}
125		} else if (m->otype == MAT_SPOT) {
126		source[ns].sflags |= SSPOT;
127		if ((source[ns].sl.s = makespot(m)) == NULL)
#	Line 101 | Line 133 | marksources()                  /* find and mark source objects */
133		source[ns].sflags |= SSKIP;
134		}
135		}
136	<	if (!(source[ns].sflags & SSKIP))
137	<	foundsource++;
136	>	#if  SHADCACHE
137	>	initobscache(ns);
138	>	#endif
139	>	foundsource += !(source[ns].sflags & SSKIP);
140		}
141		if (!foundsource) {
142		error(WARNING, "no light sources found");
#	Line 113 | Line 147 | marksources()                  /* find and mark source objects */
147		maxcntr = nsources + MAXSPART;  /* start with this many */
148		srccnt = (CONTRIB *)malloc(maxcntr*sizeof(CONTRIB));
149		cntord = (CNTPTR *)malloc(maxcntr*sizeof(CNTPTR));
150	<	if (srccnt == NULL | cntord == NULL)
150	>	if ((srccnt == NULL) | (cntord == NULL))
151		goto memerr;
152		return;
153		memerr:
#	Line 121 | Line 155 | memerr:
155		}
156
157
158	<	srcray(sr, r, si)               /* send a ray to a source, return domega */
159	<	register RAY  *sr;              /* returned source ray */
126	<	RAY  *r;                        /* ray which hit object */
127	<	SRCINDEX  *si;                  /* source sample index */
158	>	void
159	>	freesources(void)                       /* free all source structures */
160		{
161	<	double  d;                          /* distance to source */
162	<	register SRCREC  *srcp;
161	>	if (nsources > 0) {
162	>	#if SHADCACHE
163	>	while (nsources--)
164	>	freeobscache(&source[nsources]);
165	>	#endif
166	>	free((void *)source);
167	>	source = NULL;
168	>	nsources = 0;
169	>	}
170	>	markclip(NULL);
171	>	if (maxcntr <= 0)
172	>	return;
173	>	free((void *)srccnt);
174	>	srccnt = NULL;
175	>	free((void *)cntord);
176	>	cntord = NULL;
177	>	maxcntr = 0;
178	>	}
179
132	–	rayorigin(sr, r, SHADOW, 1.0);              /* ignore limits */
180
181	<	while ((d = nextssamp(sr, si)) != 0.0) {
182	<	sr->rsrc = si->sn;                      /* remember source */
183	<	srcp = source + si->sn;
184	<	if (srcp->sflags & SDISTANT) {
185	<	if (srcp->sflags & SSPOT && spotout(sr, srcp->sl.s))
186	<	continue;
187	<	return(1);              /* sample OK */
188	<	}
181	>	int
182	>	srcray(                         /* send a ray to a source, return domega */
183	>	RAY  *sr,               /* returned source ray */
184	>	RAY  *r,                        /* ray which hit object */
185	>	SRCINDEX  *si                   /* source sample index */
186	>	)
187	>	{
188	>	double  d;                              /* distance to source */
189	>	SRCREC  *srcp;
190	>
191	>	rayorigin(sr, SHADOW, r, NULL);         /* ignore limits */
192	>
193	>	if (r == NULL)
194	>	sr->rmax = 0.0;
195	>
196	>	while ((d = nextssamp(sr, si)) != 0.0) {
197	>	sr->rsrc = si->sn;                      /* remember source */
198	>	srcp = source + si->sn;
199	>	if (srcp->sflags & SDISTANT) {
200	>	if (srcp->sflags & SSPOT && spotout(sr, srcp->sl.s))
201	>	continue;
202	>	return(1);              /* sample OK */
203	>	}
204		/* local source */
205		/* check proximity */
206	<	if (srcp->sflags & SPROX && d > srcp->sl.prox)
145	<	continue;
146	<	/* check angle */
147	<	if (srcp->sflags & SSPOT) {
148	<	if (spotout(sr, srcp->sl.s))
206	>	if (srcp->sflags & SPROX && d > srcp->sl.prox)
207		continue;
208	+	/* check angle */
209	+	if (srcp->sflags & SSPOT) {
210	+	if (spotout(sr, srcp->sl.s))
211	+	continue;
212		/* adjust solid angle */
213	<	si->dom *= d*d;
214	<	d += srcp->sl.s->flen;
215	<	si->dom /= d*d;
213	>	si->dom *= d*d;
214	>	d += srcp->sl.s->flen;
215	>	si->dom /= d*d;
216	>	}
217	>	return(1);                      /* sample OK */
218		}
219	<	return(1);                      /* sample OK */
156	<	}
157	<	return(0);                  /* no more samples */
219	>	return(0);                      /* no more samples */
220		}
221
222
223	<	srcvalue(r)                     /* punch ray to source and compute value */
224	<	register RAY  *r;
223	>	void
224	>	srcvalue(                       /* punch ray to source and compute value */
225	>	RAY  *r
226	>	)
227		{
228	<	register SRCREC  *sp;
228	>	SRCREC  *sp;
229
230		sp = &source[r->rsrc];
231		if (sp->sflags & SVIRTUAL) {    /* virtual source */
#	Line 198 | Line 262 | nomat:
262		}
263
264
265	<	sourcehit(r)                    /* check to see if ray hit distant source */
266	<	register RAY  *r;
265	>	static int
266	>	transillum(                     /* check if material is transparent illum */
267	>	OBJECT  obj
268	>	)
269		{
270	+	OBJREC *m = findmaterial(objptr(obj));
271	+
272	+	if (m == NULL)
273	+	return(1);
274	+	if (m->otype != MAT_ILLUM)
275	+	return(0);
276	+	return(!m->oargs.nsargs || !strcmp(m->oargs.sarg[0], VOIDID));
277	+	}
278	+
279	+
280	+	int
281	+	sourcehit(                      /* check to see if ray hit distant source */
282	+	RAY  *r
283	+	)
284	+	{
285	+	int  glowsrc = -1;
286	+	int  transrc = -1;
287		int  first, last;
288	<	register int  i;
288	>	int  i;
289
290		if (r->rsrc >= 0) {             /* check only one if aimed */
291		first = last = r->rsrc;
292		} else {                        /* otherwise check all */
293		first = 0; last = nsources-1;
294		}
295	<	for (i = first; i <= last; i++)
296	<	if ((source[i].sflags & (SDISTANT|SVIRTUAL)) == SDISTANT)
297	<	/*
298	<	* Check to see if ray is within
299	<	* solid angle of source.
300	<	*/
301	<	if (2.0*PI * (1.0 - DOT(source[i].sloc,r->rdir))
302	<	<= source[i].ss2) {
303	<	r->ro = source[i].so;
304	<	if (!(source[i].sflags & SSKIP))
305	<	break;
306	<	}
307	<
308	<	if (r->ro != NULL) {
309	<	for (i = 0; i < 3; i++)
310	<	r->ron[i] = -r->rdir[i];
311	<	r->rod = 1.0;
312	<	r->rox = NULL;
313	<	return(1);
295	>	for (i = first; i <= last; i++) {
296	>	if ((source[i].sflags & (SDISTANT|SVIRTUAL)) != SDISTANT)
297	>	continue;
298	>	/*
299	>	* Check to see if ray is within
300	>	* solid angle of source.
301	>	*/
302	>	if (2.*PI*(1. - DOT(source[i].sloc,r->rdir)) > source[i].ss2)
303	>	continue;
304	>	/* is it the only possibility? */
305	>	if (first == last) {
306	>	r->ro = source[i].so;
307	>	break;
308	>	}
309	>	/*
310	>	* If it's a glow or transparent illum, just remember it.
311	>	*/
312	>	if (source[i].sflags & SSKIP) {
313	>	if (glowsrc < 0)
314	>	glowsrc = i;
315	>	continue;
316	>	}
317	>	if (transillum(source[i].so->omod)) {
318	>	if (transrc < 0)
319	>	transrc = i;
320	>	continue;
321	>	}
322	>	r->ro = source[i].so;   /* otherwise, use first hit */
323	>	break;
324		}
325	<	return(0);
325	>	/*
326	>	* Do we need fallback?
327	>	*/
328	>	if (r->ro == NULL) {
329	>	if (transrc >= 0 && r->crtype & (AMBIENT|SPECULAR))
330	>	return(0);      /* avoid overcounting */
331	>	if (glowsrc >= 0)
332	>	r->ro = source[glowsrc].so;
333	>	else
334	>	return(0);      /* nothing usable */
335	>	}
336	>	/*
337	>	* Make assignments.
338	>	*/
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->pert[0] = r->pert[1] = r->pert[2] = 0.0;
344	>	r->uv[0] = r->uv[1] = 0.0;
345	>	r->rox = NULL;
346	>	return(1);
347		}
348
349
350		static int
351	<	cntcmp(sc1, sc2)                        /* contribution compare (descending) */
352	<	register CNTPTR  *sc1, *sc2;
351	>	cntcmp(                         /* contribution compare (descending) */
352	>	const void *p1,
353	>	const void *p2
354	>	)
355		{
356	+	const CNTPTR  *sc1 = (const CNTPTR *)p1;
357	+	const CNTPTR  *sc2 = (const CNTPTR *)p2;
358	+
359		if (sc1->brt > sc2->brt)
360		return(-1);
361		if (sc1->brt < sc2->brt)
#	Line 245 | Line 364 | register CNTPTR  *sc1, *sc2;
364		}
365
366
367	<	direct(r, f, p)                         /* add direct component */
368	<	RAY  *r;                        /* ray that hit surface */
369	<	int  (*f)();                    /* direct component coefficient function */
370	<	char  *p;                       /* data for f */
367	>	void
368	>	direct(                                 /* add direct component */
369	>	RAY  *r,                        /* ray that hit surface */
370	>	srcdirf_t *f,                   /* direct component coefficient function */
371	>	void  *p                        /* data for f */
372	>	)
373		{
374	<	extern int  (*trace)();
375	<	register int  sn;
255	<	register CONTRIB  *scp;
374	>	int  sn;
375	>	CONTRIB  *scp;
376		SRCINDEX  si;
377		int  nshadcheck, ncnts;
378		int  nhits;
#	Line 266 | Line 386 | char  *p;                      /* data for f */
386		for (sn = 0; srcray(&sr, r, &si); sn++) {
387		if (sn >= maxcntr) {
388		maxcntr = sn + MAXSPART;
389	<	srccnt = (CONTRIB *)realloc((char *)srccnt,
389	>	srccnt = (CONTRIB *)realloc((void *)srccnt,
390		maxcntr*sizeof(CONTRIB));
391	<	cntord = (CNTPTR *)realloc((char *)cntord,
391	>	cntord = (CNTPTR *)realloc((void *)cntord,
392		maxcntr*sizeof(CNTPTR));
393	<	if (srccnt == NULL | cntord == NULL)
393	>	if ((srccnt == NULL) | (cntord == NULL))
394		error(SYSTEM, "out of memory in direct");
395		}
396		cntord[sn].sndx = sn;
#	Line 278 | Line 398 | char  *p;                      /* data for f */
398		scp->sno = sr.rsrc;
399		/* compute coefficient */
400		(*f)(scp->coef, p, sr.rdir, si.dom);
401	<	cntord[sn].brt = bright(scp->coef);
401	>	cntord[sn].brt = intens(scp->coef);
402		if (cntord[sn].brt <= 0.0)
403		continue;
404	+	#if SHADCACHE
405	+	/* check shadow cache */
406	+	if (si.np == 1 && srcblocked(&sr)) {
407	+	cntord[sn].brt = 0.0;
408	+	continue;
409	+	}
410	+	#endif
411		VCOPY(scp->dir, sr.rdir);
412	+	copycolor(sr.rcoef, scp->coef);
413		/* compute potential */
414		sr.revf = srcvalue;
415		rayvalue(&sr);
416	+	multcolor(sr.rcol, sr.rcoef);
417		copycolor(scp->val, sr.rcol);
418	<	multcolor(scp->val, scp->coef);
290	<	cntord[sn].brt = bright(scp->val);
418	>	cntord[sn].brt = bright(sr.rcol);
419		}
420		/* sort contributions */
421		qsort(cntord, sn, sizeof(CNTPTR), cntcmp);
422		{                                       /* find last */
423	<	register int  l, m;
423	>	int  l, m;
424
425		ncnts = l = sn;
426		sn = 0;
#	Line 312 | Line 440 | char  *p;                      /* data for f */
440		/* compute number to check */
441		nshadcheck = pow((double)ncnts, shadcert) + .5;
442		/* modify threshold */
443	<	ourthresh = shadthresh / r->rweight;
443	>	if (ncnts > MINSHADCNT)
444	>	ourthresh = shadthresh / r->rweight;
445	>	else
446	>	ourthresh = 0;
447		/* test for shadows */
448		for (nhits = 0, hwt = 0.0, sn = 0; sn < ncnts;
449		hwt += (double)source[scp->sno].nhits /
#	Line 325 | Line 456 | char  *p;                      /* data for f */
456		break;
457		scp = srccnt + cntord[sn].sndx;
458		/* test for hit */
459	<	rayorigin(&sr, r, SHADOW, 1.0);
459	>	rayorigin(&sr, SHADOW, r, NULL);
460	>	copycolor(sr.rcoef, scp->coef);
461		VCOPY(sr.rdir, scp->dir);
462		sr.rsrc = scp->sno;
463	<	source[scp->sno].ntests++;      /* keep statistics */
463	>	/* keep statistics */
464	>	if (source[scp->sno].ntests++ > 0xfffffff0) {
465	>	source[scp->sno].ntests >>= 1;
466	>	source[scp->sno].nhits >>= 1;
467	>	}
468		if (localhit(&sr, &thescene) &&
469		( sr.ro != source[scp->sno].so ||
470		source[scp->sno].sflags & SFOLLOW )) {
471		/* follow entire path */
472	<	if (!raycont(&sr))
337	<	objerror(sr.ro, USER, "material not found");
338	<	rayparticipate(&sr);
472	>	raycont(&sr);
473		if (trace != NULL)
474		(*trace)(&sr);  /* trace execution */
475	<	if (bright(sr.rcol) <= FTINY)
475	>	if (bright(sr.rcol) <= FTINY) {
476	>	#if SHADCACHE
477	>	if ((scp <= srccnt || scp[-1].sno != scp->sno)
478	>	&& (scp >= srccnt+ncnts-1 ||
479	>	scp[1].sno != scp->sno))
480	>	srcblocker(&sr);
481	>	#endif
482		continue;       /* missed! */
483	+	}
484	+	rayparticipate(&sr);
485	+	multcolor(sr.rcol, sr.rcoef);
486		copycolor(scp->val, sr.rcol);
487	<	multcolor(scp->val, scp->coef);
487	>	} else if (trace != NULL &&
488	>	(source[scp->sno].sflags & (SDISTANT|SVIRTUAL|SFOLLOW))
489	>	== (SDISTANT|SFOLLOW) &&
490	>	sourcehit(&sr) && rayshade(&sr, sr.ro->omod)) {
491	>	(*trace)(&sr);          /* trace execution */
492	>	/* skip call to rayparticipate() & scp->val update */
493		}
494		/* add contribution if hit */
495		addcolor(r->rcol, scp->val);
#	Line 363 | Line 511 | char  *p;                      /* data for f */
511		scp = srccnt + cntord[sn].sndx;
512		prob = hwt * (double)source[scp->sno].nhits /
513		(double)source[scp->sno].ntests;
514	<	if (prob > 1.0)
515	<	prob = 1.0;
368	<	scalecolor(scp->val, prob);
514	>	if (prob < 1.0)
515	>	scalecolor(scp->val, prob);
516		addcolor(r->rcol, scp->val);
517		}
518		}
519
520
521	<	srcscatter(r)                   /* compute source scattering into ray */
522	<	register RAY  *r;
521	>	void
522	>	srcscatter(                     /* compute source scattering into ray */
523	>	RAY  *r
524	>	)
525		{
526		int  oldsampndx;
527		int  nsamps;
528		RAY  sr;
529		SRCINDEX  si;
530	<	double  t, lastt, d;
531	<	COLOR  cumval, ctmp;
530	>	double  t, d;
531	>	double  re, ge, be;
532	>	COLOR  cvext;
533		int  i, j;
534
535	<	if (r->slights == NULL || r->slights[0] == 0 || r->gecc >= 1.-FTINY)
535	>	if (r->slights == NULL || r->slights[0] == 0
536	>	|| r->gecc >= 1.-FTINY || r->rot >= FHUGE)
537		return;
538		if (ssampdist <= FTINY || (nsamps = r->rot/ssampdist + .5) < 1)
539		nsamps = 1;
540	+	#if MAXSSAMP
541	+	else if (nsamps > MAXSSAMP)
542	+	nsamps = MAXSSAMP;
543	+	#endif
544		oldsampndx = samplendx;
545		samplendx = random()&0x7fff;            /* randomize */
546		for (i = r->slights[0]; i > 0; i--) {   /* for each source */
547	<	setcolor(cumval, 0., 0., 0.);
393	<	lastt = r->rot;
394	<	for (j = nsamps; j-- > 0; ) {   /* for each sample position */
547	>	for (j = 0; j < nsamps; j++) {  /* for each sample position */
548		samplendx++;
549		t = r->rot * (j+frandom())/nsamps;
550	+	/* extinction */
551	+	re = t*colval(r->cext,RED);
552	+	ge = t*colval(r->cext,GRN);
553	+	be = t*colval(r->cext,BLU);
554	+	setcolor(cvext, re > 92. ? 0. : exp(-re),
555	+	ge > 92. ? 0. : exp(-ge),
556	+	be > 92. ? 0. : exp(-be));
557	+	if (intens(cvext) <= FTINY)
558	+	break;                  /* too far away */
559		sr.rorg[0] = r->rorg[0] + r->rdir[0]*t;
560		sr.rorg[1] = r->rorg[1] + r->rdir[1]*t;
561		sr.rorg[2] = r->rorg[2] + r->rdir[2]*t;
400	–	sr.rmax = 0.;
562		initsrcindex(&si);      /* sample ray to this source */
563		si.sn = r->slights[i];
564		nopart(&si, &sr);
565		if (!srcray(&sr, NULL, &si) ||
566		sr.rsrc != r->slights[i])
567		continue;               /* no path */
568	+	#if SHADCACHE
569	+	if (srcblocked(&sr))            /* check shadow cache */
570	+	continue;
571	+	#endif
572		copycolor(sr.cext, r->cext);
573	<	sr.albedo = r->albedo;
573	>	copycolor(sr.albedo, r->albedo);
574		sr.gecc = r->gecc;
575	+	sr.slights = r->slights;
576		rayvalue(&sr);                  /* eval. source ray */
577	<	if (bright(sr.rcol) <= FTINY)
577	>	if (bright(sr.rcol) <= FTINY) {
578	>	#if SHADCACHE
579	>	srcblocker(&sr);        /* add blocker to cache */
580	>	#endif
581		continue;
582	<	/* compute fall-off */
414	<	d = lastt - t;
415	<	setcolor(ctmp,  1.-d*colval(r->cext,RED),
416	<	1.-d*colval(r->cext,GRN),
417	<	1.-d*colval(r->cext,BLU));
418	<	multcolor(cumval, ctmp);
419	<	lastt = t;
582	>	}
583		if (r->gecc <= FTINY)           /* compute P(theta) */
584		d = 1.;
585		else {
586		d = DOT(r->rdir, sr.rdir);
587	<	d = sqrt(1. + r->gecc*r->gecc - 2.*r->gecc*d);
588	<	d = (1. - r->gecc*r->gecc) / (d*d*d);
587	>	d = 1. + r->gecc*r->gecc - 2.*r->gecc*d;
588	>	d = (1. - r->gecc*r->gecc) / (d*sqrt(d));
589		}
590		/* other factors */
591	<	d *= si.dom * r->albedo * r->rot / (4.*PI*nsamps);
591	>	d *= si.dom * r->rot / (4.*PI*nsamps);
592		multcolor(sr.rcol, r->cext);
593	+	multcolor(sr.rcol, r->albedo);
594		scalecolor(sr.rcol, d);
595	<	addcolor(cumval, sr.rcol);
595	>	multcolor(sr.rcol, cvext);
596	>	addcolor(r->rcol, sr.rcol);     /* add it in */
597		}
433	–	/* final fall-off */
434	–	setcolor(ctmp,  1.-lastt*colval(r->cext,RED),
435	–	1.-lastt*colval(r->cext,GRN),
436	–	1.-lastt*colval(r->cext,BLU));
437	–	multcolor(cumval, ctmp);
438	–	addcolor(r->rcol, cumval);      /* sum into ray result */
598		}
599		samplendx = oldsampndx;
600		}
#	Line 457 | Line 616 | register RAY  *r;
616		* geometry behind (or inside) an effective radiator.
617		*/
618
619	<	static int weaksrcmod(obj) int obj;     /* efficiency booster function */
620	<	{register OBJREC *o = objptr(obj);
621	<	return(o->otype==MAT_ILLUM|o->otype==MAT_GLOW);}
619	>	static int
620	>	weaksrcmat(OBJECT obj)          /* identify material */
621	>	{
622	>	OBJREC *m = findmaterial(objptr(obj));
623	>
624	>	if (m == NULL) return(0);
625	>	return((m->otype==MAT_ILLUM) | (m->otype==MAT_GLOW));
626	>	}
627
628		#define  illumblock(m, r)       (!(source[r->rsrc].sflags&SVIRTUAL) && \
629		r->rod > 0.0 && \
630	<	weaksrcmod(source[r->rsrc].so->omod))
630	>	weaksrcmat(source[r->rsrc].so->omod))
631
632		/* wrongsource *
633		*
#	Line 519 | Line 683 | return(o->otype==MAT_ILLUM|o->otype==MAT_GLOW);}
683		distglow(m, r, raydist(r,PRIMARY)))
684
685
686	<	m_light(m, r)                   /* ray hit a light source */
687	<	register OBJREC  *m;
688	<	register RAY  *r;
686	>	int
687	>	m_light(                                /* ray hit a light source */
688	>	OBJREC  *m,
689	>	RAY  *r
690	>	)
691		{
692		/* check for over-counting */
693	<	if (badcomponent(m, r))
693	>	if (badcomponent(m, r)) {
694	>	setcolor(r->rcoef, 0.0, 0.0, 0.0);
695		return(1);
696	<	if (wrongsource(m, r))
696	>	}
697	>	if (wrongsource(m, r)) {
698	>	setcolor(r->rcoef, 0.0, 0.0, 0.0);
699		return(1);
700	+	}
701		/* check for passed illum */
702		if (passillum(m, r)) {
703		if (m->oargs.nsargs && strcmp(m->oargs.sarg[0], VOIDID))
704	<	return(rayshade(r, modifier(m->oargs.sarg[0])));
704	>	return(rayshade(r,lastmod(objndx(m),m->oargs.sarg[0])));
705		raytrans(r);
706		return(1);
707		}
708	+	/* check for invisibility */
709	+	if (srcignore(m, r)) {
710	+	setcolor(r->rcoef, 0.0, 0.0, 0.0);
711	+	return(1);
712	+	}
713		/* otherwise treat as source */
714		/* check for behind */
715		if (r->rod < 0.0)
541	–	return(1);
542	–	/* check for invisibility */
543	–	if (srcignore(m, r))
716		return(1);
717		/* check for outside spot */
718		if (m->otype==MAT_SPOT && spotout(r, makespot(m)))

Diff Legend

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