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 1.28 by greg, Fri Dec 21 11:32:39 1990 UTC vs.
Revision 2.15 by greg, Thu Jan 13 10:43:36 1994 UTC

#	Line 1 | Line 1
1	<	/* Copyright (c) 1990 Regents of the University of California */
1	>	/* Copyright (c) 1993 Regents of the University of California */
2
3		#ifndef lint
4		static char SCCSid[] = "$SunId$ LBL";
#	Line 14 | Line 14 | static char SCCSid[] = "$SunId$ LBL";
14
15		#include  "octree.h"
16
17	–	#include  "source.h"
18	–
17		#include  "otypes.h"
18
19	<	#include  "cone.h"
19	>	#include  "source.h"
20
21	<	#include  "face.h"
21	>	/*
22	>	* Structures used by direct()
23	>	*/
24
25	<	#include  "random.h"
25	>	typedef struct {
26	>	int  sno;               /* source number */
27	>	FVECT  dir;             /* source direction */
28	>	COLOR  coef;            /* material coefficient */
29	>	COLOR  val;             /* contribution */
30	>	}  CONTRIB;             /* direct contribution */
31
32	+	typedef struct {
33	+	int  sndx;              /* source index (to CONTRIB array) */
34	+	float  brt;             /* brightness (for comparison) */
35	+	}  CNTPTR;              /* contribution pointer */
36
28	–	extern double  dstrsrc;                 /* source distribution amount */
29	–	extern double  shadthresh;              /* relative shadow threshold */
30	–	extern double  shadcert;                /* shadow testing certainty */
31	–
32	–	SRCREC  *source = NULL;                 /* our list of sources */
33	–	int  nsources = 0;                      /* the number of sources */
34	–
37		static CONTRIB  *srccnt;                /* source contributions in direct() */
38		static CNTPTR  *cntord;                 /* source ordering in direct() */
39	+	static int  maxcntr = 0;                /* size of contribution arrays */
40
41
42		marksources()                   /* find and mark source objects */
43		{
44	+	int  foundsource = 0;
45	+	int  i;
46		register OBJREC  *o, *m;
47	<	register int  i;
48	<
47	>	register int  ns;
48	>	/* initialize dispatch table */
49	>	initstypes();
50	>	/* find direct sources */
51		for (i = 0; i < nobjects; i++) {
52
53		o = objptr(i);
54
55	<	if (o->omod == OVOID)
55	>	if (!issurface(o->otype) || o->omod == OVOID)
56		continue;
57
58		m = objptr(o->omod);
#	Line 62 | Line 69 | marksources()                  /* find and mark source objects */
69		m->oargs.farg[3] <= FTINY)
70		continue;                       /* don't bother */
71
72	<	if (source == NULL)
73	<	source = (SRCREC *)malloc(sizeof(SRCREC));
74	<	else
75	<	source = (SRCREC *)realloc((char *)source,
76	<	(unsigned)(nsources+1)*sizeof(SRCREC));
70	<	if (source == NULL)
72	>	if (sfun[o->otype].of == NULL ||
73	>	sfun[o->otype].of->setsrc == NULL)
74	>	objerror(o, USER, "illegal material");
75	>
76	>	if ((ns = newsource()) < 0)
77		goto memerr;
78
79	<	newsource(&source[nsources], o);
79	>	setsource(&source[ns], o);
80
81		if (m->otype == MAT_GLOW) {
82	<	source[nsources].sflags |= SPROX;
83	<	source[nsources].sl.prox = m->oargs.farg[3];
84	<	if (o->otype == OBJ_SOURCE)
85	<	source[nsources].sflags |= SSKIP;
82	>	source[ns].sflags |= SPROX;
83	>	source[ns].sl.prox = m->oargs.farg[3];
84	>	if (source[ns].sflags & SDISTANT)
85	>	source[ns].sflags |= SSKIP;
86		} else if (m->otype == MAT_SPOT) {
87	<	source[nsources].sflags |= SSPOT;
88	<	source[nsources].sl.s = makespot(m);
87	>	source[ns].sflags |= SSPOT;
88	>	if ((source[ns].sl.s = makespot(m)) == NULL)
89	>	goto memerr;
90	>	if (source[ns].sflags & SFLAT &&
91	>	!checkspot(source[ns].sl.s,source[ns].snorm)) {
92	>	objerror(o, WARNING,
93	>	"invalid spotlight direction");
94	>	source[ns].sflags |= SSKIP;
95	>	}
96		}
97	<	nsources++;
97	>	if (!(source[ns].sflags & SSKIP))
98	>	foundsource++;
99		}
100	<	if (nsources <= 0) {
100	>	if (!foundsource) {
101		error(WARNING, "no light sources found");
102		return;
103		}
104	<	srccnt = (CONTRIB *)malloc(nsources*sizeof(CONTRIB));
105	<	cntord = (CNTPTR *)malloc(nsources*sizeof(CNTPTR));
106	<	if (srccnt != NULL && cntord != NULL)
107	<	return;
108	<	/* fall through */
104	>	markvirtuals();                 /* find and add virtual sources */
105	>	/* allocate our contribution arrays */
106	>	maxcntr = nsources + MAXSPART;  /* start with this many */
107	>	srccnt = (CONTRIB *)malloc(maxcntr*sizeof(CONTRIB));
108	>	cntord = (CNTPTR *)malloc(maxcntr*sizeof(CNTPTR));
109	>	if (srccnt == NULL | cntord == NULL)
110	>	goto memerr;
111	>	return;
112		memerr:
113		error(SYSTEM, "out of memory in marksources");
114		}
115
116
117	<	newsource(src, so)                      /* add a source to the array */
101	<	register SRCREC  *src;
102	<	register OBJREC  *so;
103	<	{
104	<	double  cos(), tan(), sqrt();
105	<	double  theta;
106	<	FACE  *f;
107	<	CONE  *co;
108	<	int  j;
109	<	register int  i;
110	<
111	<	src->sflags = 0;
112	<	src->nhits = 1; src->ntests = 2;        /* start probability = 1/2 */
113	<	src->so = so;
114	<
115	<	switch (so->otype) {
116	<	case OBJ_SOURCE:
117	<	if (so->oargs.nfargs != 4)
118	<	objerror(so, USER, "bad arguments");
119	<	src->sflags |= SDISTANT;
120	<	VCOPY(src->sloc, so->oargs.farg);
121	<	if (normalize(src->sloc) == 0.0)
122	<	objerror(so, USER, "zero direction");
123	<	theta = PI/180.0/2.0 * so->oargs.farg[3];
124	<	if (theta <= FTINY)
125	<	objerror(so, USER, "zero size");
126	<	src->ss = theta >= PI/4 ? 1.0 : tan(theta);
127	<	src->ss2 = 2.0*PI * (1.0 - cos(theta));
128	<	break;
129	<	case OBJ_SPHERE:
130	<	VCOPY(src->sloc, so->oargs.farg);
131	<	src->ss = so->oargs.farg[3];
132	<	src->ss2 = PI * src->ss * src->ss;
133	<	break;
134	<	case OBJ_FACE:
135	<	/* get the face */
136	<	f = getface(so);
137	<	/* find the center */
138	<	for (j = 0; j < 3; j++) {
139	<	src->sloc[j] = 0.0;
140	<	for (i = 0; i < f->nv; i++)
141	<	src->sloc[j] += VERTEX(f,i)[j];
142	<	src->sloc[j] /= f->nv;
143	<	}
144	<	if (!inface(src->sloc, f))
145	<	objerror(so, USER, "cannot hit center");
146	<	src->ss = sqrt(f->area / PI);
147	<	src->ss2 = f->area;
148	<	break;
149	<	case OBJ_RING:
150	<	/* get the ring */
151	<	co = getcone(so, 0);
152	<	VCOPY(src->sloc, CO_P0(co));
153	<	if (CO_R0(co) > 0.0)
154	<	objerror(so, USER, "cannot hit center");
155	<	src->ss = CO_R1(co);
156	<	src->ss2 = PI * src->ss * src->ss;
157	<	break;
158	<	default:
159	<	objerror(so, USER, "illegal material");
160	<	}
161	<	}
162	<
163	<
164	<	SPOT *
165	<	makespot(m)                     /* make a spotlight */
166	<	register OBJREC  *m;
167	<	{
168	<	extern double  cos();
169	<	register SPOT  *ns;
170	<
171	<	if ((ns = (SPOT *)malloc(sizeof(SPOT))) == NULL)
172	<	error(SYSTEM, "out of memory in makespot");
173	<	ns->siz = 2.0*PI * (1.0 - cos(PI/180.0/2.0 * m->oargs.farg[3]));
174	<	VCOPY(ns->aim, m->oargs.farg+4);
175	<	if ((ns->flen = normalize(ns->aim)) == 0.0)
176	<	objerror(m, USER, "zero focus vector");
177	<	return(ns);
178	<	}
179	<
180	<
181	<	double
182	<	srcray(sr, r, sn)               /* send a ray to a source, return domega */
117	>	srcray(sr, r, si)               /* send a ray to a source, return domega */
118		register RAY  *sr;              /* returned source ray */
119		RAY  *r;                        /* ray which hit object */
120	<	register int  sn;               /* source number */
120	>	SRCINDEX  *si;                  /* source sample index */
121		{
122	<	register double  *norm = NULL;  /* plane normal */
123	<	double  ddot;                   /* (distance times) cosine */
189	<	FVECT  vd;
190	<	double  d;
191	<	register int  i;
122	>	double  d;                          /* distance to source */
123	>	register SRCREC  *srcp;
124
125	<	if (source[sn].sflags & SSKIP)
194	<	return(0.0);                    /* skip this source */
125	>	rayorigin(sr, r, SHADOW, 1.0);              /* ignore limits */
126
127	<	rayorigin(sr, r, SHADOW, 1.0);          /* ignore limits */
128	<
129	<	sr->rsrc = sn;                          /* remember source */
130	<	/* get source direction */
131	<	if (source[sn].sflags & SDISTANT)
132	<	/* constant direction */
133	<	VCOPY(sr->rdir, source[sn].sloc);
203	<	else {                                  /* compute direction */
204	<	for (i = 0; i < 3; i++)
205	<	sr->rdir[i] = source[sn].sloc[i] - sr->rorg[i];
206	<
207	<	if (source[sn].so->otype == OBJ_FACE)
208	<	norm = getface(source[sn].so)->norm;
209	<	else if (source[sn].so->otype == OBJ_RING)
210	<	norm = getcone(source[sn].so,0)->ad;
211	<
212	<	if (norm != NULL && (ddot = -DOT(sr->rdir, norm)) <= FTINY)
213	<	return(0.0);            /* behind surface! */
127	>	while ((d = nextssamp(sr, si)) != 0.0) {
128	>	sr->rsrc = si->sn;                      /* remember source */
129	>	srcp = source + si->sn;
130	>	if (srcp->sflags & SDISTANT) {
131	>	if (srcp->sflags & SSPOT && spotout(sr, srcp->sl.s, 1))
132	>	continue;
133	>	return(1);              /* sample OK */
134		}
135	<	if (dstrsrc > FTINY) {
136	<	/* distribute source direction */
137	<	for (i = 0; i < 3; i++)
138	<	vd[i] = dstrsrc * source[sn].ss * (1.0 - 2.0*frandom());
135	>	/* local source */
136	>	/* check proximity */
137	>	if (srcp->sflags & SPROX && d > srcp->sl.prox)
138	>	continue;
139	>	/* check angle */
140	>	if (srcp->sflags & SSPOT) {
141	>	if (spotout(sr, srcp->sl.s, 0))
142	>	continue;
143	>	/* adjust solid angle */
144	>	si->dom *= d*d;
145	>	d += srcp->sl.s->flen;
146	>	si->dom /= d*d;
147	>	}
148	>	return(1);                      /* sample OK */
149	>	}
150	>	return(0);                  /* no more samples */
151	>	}
152
220	–	if (norm != NULL) {             /* project offset */
221	–	d = DOT(vd, norm);
222	–	for (i = 0; i < 3; i++)
223	–	vd[i] -= d * norm[i];
224	–	}
225	–	for (i = 0; i < 3; i++)         /* offset source direction */
226	–	sr->rdir[i] += vd[i];
153
154	<	} else if (source[sn].sflags & SDISTANT)
155	<	/* already normalized */
156	<	return(source[sn].ss2);
154	>	srcvalue(r)                     /* punch ray to source and compute value */
155	>	register RAY  *r;
156	>	{
157	>	register SRCREC  *sp;
158
159	<	if ((d = normalize(sr->rdir)) == 0.0)
160	<	/* at source! */
161	<	return(0.0);
162	<
163	<	if (source[sn].sflags & SDISTANT)
164	<	/* domega constant */
165	<	return(source[sn].ss2);
166	<
240	<	/* check proximity */
241	<	if (source[sn].sflags & SPROX &&
242	<	d > source[sn].sl.prox)
243	<	return(0.0);
244	<	/* compute dot product */
245	<	if (norm != NULL)
246	<	ddot /= d;
247	<	else
248	<	ddot = 1.0;
249	<	/* check angle */
250	<	if (source[sn].sflags & SSPOT) {
251	<	if (source[sn].sl.s->siz < 2.0*PI *
252	<	(1.0 + DOT(source[sn].sl.s->aim,sr->rdir)))
253	<	return(0.0);
254	<	d += source[sn].sl.s->flen;     /* adjust length */
159	>	sp = &source[r->rsrc];
160	>	if (sp->sflags & SVIRTUAL) {    /* virtual source */
161	>	/* check intersection */
162	>	if (!(*ofun[sp->so->otype].funp)(sp->so, r))
163	>	return;
164	>	if (!rayshade(r, r->ro->omod))  /* compute contribution */
165	>	goto nomat;
166	>	return;
167		}
168	<	/* compute domega */
169	<	return(ddot*source[sn].ss2/(d*d));
168	>	/* compute intersection */
169	>	if (sp->sflags & SDISTANT ? sourcehit(r) :
170	>	(*ofun[sp->so->otype].funp)(sp->so, r)) {
171	>	if (sp->sa.success >= 0)
172	>	sp->sa.success++;
173	>	if (!rayshade(r, r->ro->omod))  /* compute contribution */
174	>	goto nomat;
175	>	return;
176	>	}
177	>	/* we missed our mark! */
178	>	if (sp->sa.success < 0)
179	>	return;                 /* bitched already */
180	>	sp->sa.success -= AIMREQT;
181	>	if (sp->sa.success >= 0)
182	>	return;                 /* leniency */
183	>	sprintf(errmsg, "aiming failure for light source \"%s\"",
184	>	sp->so->oname);
185	>	error(WARNING, errmsg);         /* issue warning */
186	>	return;
187	>	nomat:
188	>	objerror(r->ro, USER, "material not found");
189		}
190
191
#	Line 270 | Line 201 | register RAY  *r;
201		first = 0; last = nsources-1;
202		}
203		for (i = first; i <= last; i++)
204	<	if (source[i].sflags & SDISTANT)
204	>	if ((source[i].sflags & (SDISTANT|SVIRTUAL)) == SDISTANT)
205		/*
206		* Check to see if ray is within
207		* solid angle of source.
#	Line 310 | Line 241 | RAY  *r;                       /* ray that hit surface */
241		int  (*f)();                    /* direct component coefficient function */
242		char  *p;                       /* data for f */
243		{
244	<	extern double  pow();
244	>	extern int  (*trace)();
245		register int  sn;
246	+	register CONTRIB  *scp;
247	+	SRCINDEX  si;
248		int  nshadcheck, ncnts;
249	<	double  prob, ourthresh, hwt, test2, hit2;
249	>	int  nhits;
250	>	double  prob, ourthresh, hwt;
251		RAY  sr;
252		/* NOTE: srccnt and cntord global so no recursion */
253		if (nsources <= 0)
254		return;         /* no sources?! */
321	–	/* compute number to check */
322	–	nshadcheck = pow((double)nsources, shadcert) + .5;
323	–	/* modify threshold */
324	–	ourthresh = shadthresh / r->rweight;
255		/* potential contributions */
256	<	for (sn = 0; sn < nsources; sn++) {
257	<	cntord[sn].sno = sn;
258	<	cntord[sn].brt = 0.0;
259	<	/* get source ray */
260	<	if ((srccnt[sn].dom = srcray(&sr, r, sn)) == 0.0)
261	<	continue;
262	<	VCOPY(srccnt[sn].dir, sr.rdir);
256	>	initsrcindex(&si);
257	>	for (sn = 0; srcray(&sr, r, &si); sn++) {
258	>	if (sn >= maxcntr) {
259	>	maxcntr = sn + MAXSPART;
260	>	srccnt = (CONTRIB *)realloc((char *)srccnt,
261	>	maxcntr*sizeof(CONTRIB));
262	>	cntord = (CNTPTR *)realloc((char *)cntord,
263	>	maxcntr*sizeof(CNTPTR));
264	>	if (srccnt == NULL | cntord == NULL)
265	>	error(SYSTEM, "out of memory in direct");
266	>	}
267	>	cntord[sn].sndx = sn;
268	>	scp = srccnt + sn;
269	>	scp->sno = sr.rsrc;
270		/* compute coefficient */
271	<	(*f)(srccnt[sn].val, p, srccnt[sn].dir, srccnt[sn].dom);
272	<	cntord[sn].brt = bright(srccnt[sn].val);
271	>	(*f)(scp->coef, p, sr.rdir, si.dom);
272	>	cntord[sn].brt = bright(scp->coef);
273		if (cntord[sn].brt <= 0.0)
274		continue;
275	<	/* compute intersection */
276	<	if (!( source[sn].sflags & SDISTANT ?
277	<	sourcehit(&sr) :
278	<	(*ofun[source[sn].so->otype].funp)
279	<	(source[sn].so, &sr) )) {
280	<	sprintf(errmsg,
281	<	"aiming failure for light source \"%s\"",
345	<	source[sn].so->oname);
346	<	error(WARNING, errmsg);
347	<	cntord[sn].brt = 0.0;
348	<	continue;
349	<	}
350	<	/* compute contribution */
351	<	raycont(&sr);
352	<	multcolor(srccnt[sn].val, sr.rcol);
353	<	cntord[sn].brt = bright(srccnt[sn].val);
275	>	VCOPY(scp->dir, sr.rdir);
276	>	/* compute potential */
277	>	sr.revf = srcvalue;
278	>	rayvalue(&sr);
279	>	copycolor(scp->val, sr.rcol);
280	>	multcolor(scp->val, scp->coef);
281	>	cntord[sn].brt = bright(scp->val);
282		}
283		/* sort contributions */
284	<	qsort(cntord, nsources, sizeof(CNTPTR), cntcmp);
284	>	qsort(cntord, sn, sizeof(CNTPTR), cntcmp);
285		{                                       /* find last */
286		register int  l, m;
287
288	<	sn = 0; ncnts = l = nsources;
288	>	ncnts = l = sn;
289	>	sn = 0;
290		while ((m = (sn + ncnts) >> 1) != l) {
291		if (cntord[m].brt > 0.0)
292		sn = m;
#	Line 366 | Line 295 | char  *p;                      /* data for f */
295		l = m;
296		}
297		}
298	+	if (ncnts == 0)
299	+	return;         /* no contributions! */
300		/* accumulate tail */
301		for (sn = ncnts-1; sn > 0; sn--)
302		cntord[sn-1].brt += cntord[sn].brt;
303	<	/* start with prob=.5 */
304	<	hit2 = 0.5; test2 = 1.0;
303	>	/* compute number to check */
304	>	nshadcheck = pow((double)ncnts, shadcert) + .5;
305	>	/* modify threshold */
306	>	ourthresh = shadthresh / r->rweight;
307		/* test for shadows */
308	<	for (sn = 0; sn < ncnts; sn++) {
308	>	for (nhits = 0, hwt = 0.0, sn = 0; sn < ncnts;
309	>	hwt += (double)source[scp->sno].nhits /
310	>	(double)source[scp->sno].ntests,
311	>	sn++) {
312		/* check threshold */
313		if ((sn+nshadcheck>=ncnts ? cntord[sn].brt :
314		cntord[sn].brt-cntord[sn+nshadcheck].brt)
315		< ourthresh*bright(r->rcol))
316		break;
317	<	/* get statistics */
382	<	hwt = (double)source[cntord[sn].sno].nhits /
383	<	(double)source[cntord[sn].sno].ntests;
384	<	test2 += hwt;
385	<	source[cntord[sn].sno].ntests++;
317	>	scp = srccnt + cntord[sn].sndx;
318		/* test for hit */
319		rayorigin(&sr, r, SHADOW, 1.0);
320	<	VCOPY(sr.rdir, srccnt[cntord[sn].sno].dir);
321	<	sr.rsrc = cntord[sn].sno;
320	>	VCOPY(sr.rdir, scp->dir);
321	>	sr.rsrc = scp->sno;
322	>	source[scp->sno].ntests++;      /* keep statistics */
323		if (localhit(&sr, &thescene) &&
324	<	sr.ro != source[cntord[sn].sno].so) {
325	<	/* check for transmission */
326	<	raycont(&sr);
324	>	( sr.ro != source[scp->sno].so ||
325	>	source[scp->sno].sflags & SFOLLOW )) {
326	>	/* follow entire path */
327	>	if (!raycont(&sr))
328	>	objerror(sr.ro, USER, "material not found");
329	>	if (trace != NULL)
330	>	(*trace)(&sr);  /* trace execution */
331		if (bright(sr.rcol) <= FTINY)
332		continue;       /* missed! */
333	<	(*f)(srccnt[cntord[sn].sno].val, p,
334	<	srccnt[cntord[sn].sno].dir,
398	<	srccnt[cntord[sn].sno].dom);
399	<	multcolor(srccnt[cntord[sn].sno].val, sr.rcol);
333	>	copycolor(scp->val, sr.rcol);
334	>	multcolor(scp->val, scp->coef);
335		}
336		/* add contribution if hit */
337	<	addcolor(r->rcol, srccnt[cntord[sn].sno].val);
338	<	hit2 += hwt;
339	<	source[cntord[sn].sno].nhits++;
337	>	addcolor(r->rcol, scp->val);
338	>	nhits++;
339	>	source[scp->sno].nhits++;
340		}
341	<	/* weighted hit rate */
342	<	hwt = hit2 / test2;
341	>	/* source hit rate */
342	>	if (hwt > FTINY)
343	>	hwt = (double)nhits / hwt;
344	>	else
345	>	hwt = 0.5;
346		#ifdef DEBUG
347	<	sprintf(errmsg, "%d tested, %d untested, %f hit rate\n",
347	>	sprintf(errmsg, "%d tested, %d untested, %f conditional hit rate\n",
348		sn, ncnts-sn, hwt);
349		eputs(errmsg);
350		#endif
351		/* add in untested sources */
352		for ( ; sn < ncnts; sn++) {
353	<	prob = hwt * (double)source[cntord[sn].sno].nhits /
354	<	(double)source[cntord[sn].sno].ntests;
355	<	scalecolor(srccnt[cntord[sn].sno].val, prob);
356	<	addcolor(r->rcol, srccnt[cntord[sn].sno].val);
353	>	scp = srccnt + cntord[sn].sndx;
354	>	prob = hwt * (double)source[scp->sno].nhits /
355	>	(double)source[scp->sno].ntests;
356	>	if (prob > 1.0)
357	>	prob = 1.0;
358	>	scalecolor(scp->val, prob);
359	>	addcolor(r->rcol, scp->val);
360		}
361		}
362
363
364	<	#define  wrongsource(m, r)      (m->otype!=MAT_ILLUM && \
365	<	r->rsrc>=0 && \
366	<	source[r->rsrc].so!=r->ro)
364	>	/****************************************************************
365	>	* The following macros were separated from the m_light() routine
366	>	* because they are very nasty and difficult to understand.
367	>	*/
368
369	<	#define  badambient(m, r)       ((r->crtype&(AMBIENT|SHADOW))==AMBIENT && \
370	<	!(r->rtype&REFLECTED) &&        /* hack! */\
371	<	!(m->otype==MAT_GLOW&&r->rot>m->oargs.farg[3]))
369	>	/* illumblock *
370	>	*
371	>	* We cannot allow an illum to pass to another illum, because that
372	>	* would almost certainly constitute overcounting.
373	>	* However, we do allow an illum to pass to another illum
374	>	* that is actually going to relay to a virtual light source.
375	>	* We also prevent an illum from passing to a glow; this provides a
376	>	* convenient mechanism for defining detailed light source
377	>	* geometry behind (or inside) an effective radiator.
378	>	*/
379
380	+	static int weaksrcmod(obj) int obj;     /* efficiency booster function */
381	+	{register OBJREC *o = objptr(obj);
382	+	return(o->otype==MAT_ILLUM|o->otype==MAT_GLOW);}
383	+
384	+	#define  illumblock(m, r)       (!(source[r->rsrc].sflags&SVIRTUAL) && \
385	+	r->rod > 0.0 && \
386	+	weaksrcmod(source[r->rsrc].so->omod))
387	+
388	+	/* wrongsource *
389	+	*
390	+	* This source is the wrong source (ie. overcounted) if we are
391	+	* aimed to a different source than the one we hit and the one
392	+	* we hit is not an illum that should be passed.
393	+	*/
394	+
395	+	#define  wrongsource(m, r)      (r->rsrc>=0 && source[r->rsrc].so!=r->ro && \
396	+	(m->otype!=MAT_ILLUM || illumblock(m,r)))
397	+
398	+	/* distglow *
399	+	*
400	+	* A distant glow is an object that sometimes acts as a light source,
401	+	* but is too far away from the test point to be one in this case.
402	+	* (Glows with negative radii should NEVER participate in illumination.)
403	+	*/
404	+
405	+	#define  distglow(m, r)         (m->otype==MAT_GLOW && \
406	+	m->oargs.farg[3] >= -FTINY && \
407	+	r->rot > m->oargs.farg[3])
408	+
409	+	/* badcomponent *
410	+	*
411	+	* We must avoid counting light sources in the ambient calculation,
412	+	* since the direct component is handled separately.  Therefore, any
413	+	* ambient ray which hits an active light source must be discarded.
414	+	* The same is true for stray specular samples, since the specular
415	+	* contribution from light sources is calculated separately.
416	+	*/
417	+
418	+	#define  badcomponent(m, r)     (r->crtype&(AMBIENT|SPECULAR) && \
419	+	!(r->crtype&SHADOW || r->rod < 0.0 || \
420	+	distglow(m, r)))
421	+
422	+	/* passillum *
423	+	*
424	+	* An illum passes to another material type when we didn't hit it
425	+	* on purpose (as part of a direct calculation), or it is relaying
426	+	* a virtual light source.
427	+	*/
428	+
429		#define  passillum(m, r)        (m->otype==MAT_ILLUM && \
430	<	!(r->rsrc>=0&&source[r->rsrc].so==r->ro))
430	>	(r->rsrc<0 || source[r->rsrc].so!=r->ro || \
431	>	source[r->rsrc].sflags&SVIRTUAL))
432
433	+	/* srcignore *
434	+	*
435	+	* The -dv flag is normally on for sources to be visible.
436	+	*/
437
438	+	#define  srcignore(m, r)        (!directvis && !(r->crtype&SHADOW) && \
439	+	!distglow(m, r))
440	+
441	+
442		m_light(m, r)                   /* ray hit a light source */
443		register OBJREC  *m;
444		register RAY  *r;
445		{
446		/* check for over-counting */
447	<	if (wrongsource(m, r) || badambient(m, r))
448	<	return;
447	>	if (badcomponent(m, r))
448	>	return(1);
449	>	if (wrongsource(m,r))
450	>	return(1);
451		/* check for passed illum */
452		if (passillum(m, r)) {
453	<
454	<	if (m->oargs.nsargs < 1 || !strcmp(m->oargs.sarg[0], VOIDID))
455	<	raytrans(r);
456	<	else
457	<	rayshade(r, modifier(m->oargs.sarg[0]));
458	<
450	<	/* otherwise treat as source */
451	<	} else {
453	>	if (m->oargs.nsargs && strcmp(m->oargs.sarg[0], VOIDID))
454	>	return(rayshade(r, modifier(m->oargs.sarg[0])));
455	>	raytrans(r);
456	>	return(1);
457	>	}
458	>	/* otherwise treat as source */
459		/* check for behind */
460	<	if (r->rod < 0.0)
461	<	return;
460	>	if (r->rod < 0.0)
461	>	return(1);
462	>	/* check for invisibility */
463	>	if (srcignore(m, r))
464	>	return(1);
465	>	/* check for outside spot */
466	>	if (m->otype==MAT_SPOT && spotout(r, makespot(m), r->rot>=FHUGE))
467	>	return(1);
468		/* get distribution pattern */
469	<	raytexture(r, m->omod);
469	>	raytexture(r, m->omod);
470		/* get source color */
471	<	setcolor(r->rcol, m->oargs.farg[0],
472	<	m->oargs.farg[1],
473	<	m->oargs.farg[2]);
471	>	setcolor(r->rcol, m->oargs.farg[0],
472	>	m->oargs.farg[1],
473	>	m->oargs.farg[2]);
474		/* modify value */
475	<	multcolor(r->rcol, r->pcol);
476	<	/* assign distance */
464	<	r->rt = r->rot;
465	<	}
475	>	multcolor(r->rcol, r->pcol);
476	>	return(1);
477		}

Diff Legend

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