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.1 by greg, Thu Feb 2 10:41:41 1989 UTC vs.
Revision 1.29 by greg, Fri Dec 28 20:37:08 1990 UTC

#	Line 1 | Line 1
1	<	/* Copyright (c) 1986 Regents of the University of California */
1	>	/* Copyright (c) 1990 Regents of the University of California */
2
3		#ifndef lint
4		static char SCCSid[] = "$SunId$ LBL";
#	Line 12 | Line 12 | static char SCCSid[] = "$SunId$ LBL";
12
13		#include  "ray.h"
14
15	+	#include  "octree.h"
16	+
17		#include  "source.h"
18
19		#include  "otypes.h"
#	Line 24 | Line 26 | static char SCCSid[] = "$SunId$ LBL";
26
27
28		extern double  dstrsrc;                 /* source distribution amount */
29	+	extern double  shadthresh;              /* relative shadow threshold */
30	+	extern double  shadcert;                /* shadow testing certainty */
31
32	<	SOURCE  srcval[MAXSOURCE];              /* our array of sources */
32	>	SRCREC  *source = NULL;                 /* our list of sources */
33		int  nsources = 0;                      /* the number of sources */
34
35	+	static CONTRIB  *srccnt;                /* source contributions in direct() */
36	+	static CNTPTR  *cntord;                 /* source ordering in direct() */
37
38	+
39		marksources()                   /* find and mark source objects */
40		{
41		register OBJREC  *o, *m;
#	Line 43 | Line 50 | marksources()                  /* find and mark source objects */
50
51		m = objptr(o->omod);
52
53	<	if (m->otype != MAT_LIGHT &&
47	<	m->otype != MAT_ILLUM &&
48	<	m->otype != MAT_GLOW &&
49	<	m->otype != MAT_SPOT)
53	>	if (!islight(m->otype))
54		continue;
55
56		if (m->oargs.nfargs != (m->otype == MAT_GLOW ? 4 :
#	Line 58 | Line 62 | marksources()                  /* find and mark source objects */
62		m->oargs.farg[3] <= FTINY)
63		continue;                       /* don't bother */
64
65	<	if (nsources >= MAXSOURCE)
66	<	error(INTERNAL, "too many sources in marksources");
65	>	if (source == NULL)
66	>	source = (SRCREC *)malloc(sizeof(SRCREC));
67	>	else
68	>	source = (SRCREC *)realloc((char *)source,
69	>	(unsigned)(nsources+1)*sizeof(SRCREC));
70	>	if (source == NULL)
71	>	goto memerr;
72
73	<	newsource(&srcval[nsources], o);
73	>	newsource(&source[nsources], o);
74
75		if (m->otype == MAT_GLOW) {
76	<	srcval[nsources].sflags |= SPROX;
77	<	srcval[nsources].sl.prox = m->oargs.farg[3];
76	>	source[nsources].sflags |= SPROX;
77	>	source[nsources].sl.prox = m->oargs.farg[3];
78		if (o->otype == OBJ_SOURCE)
79	<	srcval[nsources].sflags |= SSKIP;
79	>	source[nsources].sflags |= SSKIP;
80		} else if (m->otype == MAT_SPOT) {
81	<	srcval[nsources].sflags |= SSPOT;
82	<	srcval[nsources].sl.s = makespot(m);
81	>	source[nsources].sflags |= SSPOT;
82	>	source[nsources].sl.s = makespot(m);
83		}
84		nsources++;
85		}
86	+	if (nsources <= 0) {
87	+	error(WARNING, "no light sources found");
88	+	return;
89	+	}
90	+	srccnt = (CONTRIB *)malloc(nsources*sizeof(CONTRIB));
91	+	cntord = (CNTPTR *)malloc(nsources*sizeof(CNTPTR));
92	+	if (srccnt != NULL && cntord != NULL)
93	+	return;
94	+	/* fall through */
95	+	memerr:
96	+	error(SYSTEM, "out of memory in marksources");
97		}
98
99
100		newsource(src, so)                      /* add a source to the array */
101	<	register SOURCE  *src;
101	>	register SRCREC  *src;
102		register OBJREC  *so;
103		{
104		double  cos(), tan(), sqrt();
#	Line 89 | Line 109 | register OBJREC  *so;
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) {
#	Line 169 | Line 190 | register int  sn;              /* source number */
190		double  d;
191		register int  i;
192
193	<	if (srcval[sn].sflags & SSKIP)
193	>	if (source[sn].sflags & SSKIP)
194		return(0.0);                    /* skip this source */
195
196		rayorigin(sr, r, SHADOW, 1.0);          /* ignore limits */
197
198		sr->rsrc = sn;                          /* remember source */
199		/* get source direction */
200	<	if (srcval[sn].sflags & SDISTANT)
200	>	if (source[sn].sflags & SDISTANT)
201		/* constant direction */
202	<	VCOPY(sr->rdir, srcval[sn].sloc);
202	>	VCOPY(sr->rdir, source[sn].sloc);
203		else {                                  /* compute direction */
204		for (i = 0; i < 3; i++)
205	<	sr->rdir[i] = srcval[sn].sloc[i] - sr->rorg[i];
205	>	sr->rdir[i] = source[sn].sloc[i] - sr->rorg[i];
206
207	<	if (srcval[sn].so->otype == OBJ_FACE)
208	<	norm = getface(srcval[sn].so)->norm;
209	<	else if (srcval[sn].so->otype == OBJ_RING)
210	<	norm = getcone(srcval[sn].so,0)->ad;
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)) <= 0.0)
212	>	if (norm != NULL && (ddot = -DOT(sr->rdir, norm)) <= FTINY)
213		return(0.0);            /* behind surface! */
214		}
215		if (dstrsrc > FTINY) {
216		/* distribute source direction */
217		for (i = 0; i < 3; i++)
218	<	vd[i] = dstrsrc * srcval[sn].ss * (1.0 - 2.0*frandom());
218	>	vd[i] = dstrsrc * source[sn].ss * (1.0 - 2.0*frandom());
219
220		if (norm != NULL) {             /* project offset */
221		d = DOT(vd, norm);
#	Line 204 | Line 225 | register int  sn;              /* source number */
225		for (i = 0; i < 3; i++)         /* offset source direction */
226		sr->rdir[i] += vd[i];
227
228	<	} else if (srcval[sn].sflags & SDISTANT)
228	>	} else if (source[sn].sflags & SDISTANT)
229		/* already normalized */
230	<	return(srcval[sn].ss2);
230	>	return(source[sn].ss2);
231
232		if ((d = normalize(sr->rdir)) == 0.0)
233		/* at source! */
234		return(0.0);
235
236	<	if (srcval[sn].sflags & SDISTANT)
236	>	if (source[sn].sflags & SDISTANT)
237		/* domega constant */
238	<	return(srcval[sn].ss2);
238	>	return(source[sn].ss2);
239
219	–	else {
240		/* check proximity */
241	<	if (srcval[sn].sflags & SPROX &&
242	<	d > srcval[sn].sl.prox)
243	<	return(0.0);
244	<
245	<	if (norm != NULL)
246	<	ddot /= d;
247	<	else
248	<	ddot = 1.0;
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 (srcval[sn].sflags & SSPOT) {
251	<	if (srcval[sn].sl.s->siz < 2.0*PI *
252	<	(1.0 + DOT(srcval[sn].sl.s->aim,sr->rdir)))
253	<	return(0.0);
254	<	d += srcval[sn].sl.s->flen;
235	<	}
236	<	/* return domega */
237	<	return(ddot*srcval[sn].ss2/(d*d));
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 */
255		}
256	+	/* compute domega */
257	+	return(ddot*source[sn].ss2/(d*d));
258		}
259
260
#	Line 251 | Line 270 | register RAY  *r;
270		first = 0; last = nsources-1;
271		}
272		for (i = first; i <= last; i++)
273	<	if (srcval[i].sflags & SDISTANT)
273	>	if (source[i].sflags & SDISTANT)
274		/*
275		* Check to see if ray is within
276		* solid angle of source.
277		*/
278	<	if (2.0*PI * (1.0 - DOT(srcval[i].sloc,r->rdir))
279	<	<= srcval[i].ss2) {
280	<	r->ro = srcval[i].so;
281	<	if (!(srcval[i].sflags & SSKIP))
278	>	if (2.0*PI * (1.0 - DOT(source[i].sloc,r->rdir))
279	>	<= source[i].ss2) {
280	>	r->ro = source[i].so;
281	>	if (!(source[i].sflags & SSKIP))
282		break;
283		}
284
#	Line 267 | Line 286 | register RAY  *r;
286		for (i = 0; i < 3; i++)
287		r->ron[i] = -r->rdir[i];
288		r->rod = 1.0;
289	+	r->rox = NULL;
290		return(1);
291		}
292		return(0);
293		}
294
295
296	+	static int
297	+	cntcmp(sc1, sc2)                        /* contribution compare (descending) */
298	+	register CNTPTR  *sc1, *sc2;
299	+	{
300	+	if (sc1->brt > sc2->brt)
301	+	return(-1);
302	+	if (sc1->brt < sc2->brt)
303	+	return(1);
304	+	return(0);
305	+	}
306	+
307	+
308	+	direct(r, f, p)                         /* add direct component */
309	+	RAY  *r;                        /* ray that hit surface */
310	+	int  (*f)();                    /* direct component coefficient function */
311	+	char  *p;                       /* data for f */
312	+	{
313	+	extern double  pow();
314	+	register int  sn;
315	+	int  nshadcheck, ncnts;
316	+	int  nhits;
317	+	double  prob, ourthresh, hwt;
318	+	RAY  sr;
319	+	/* NOTE: srccnt and cntord global so no recursion */
320	+	if (nsources <= 0)
321	+	return;         /* no sources?! */
322	+	/* compute number to check */
323	+	nshadcheck = pow((double)nsources, shadcert) + .5;
324	+	/* modify threshold */
325	+	ourthresh = shadthresh / r->rweight;
326	+	/* potential contributions */
327	+	for (sn = 0; sn < nsources; sn++) {
328	+	cntord[sn].sno = sn;
329	+	cntord[sn].brt = 0.0;
330	+	/* get source ray */
331	+	if ((srccnt[sn].dom = srcray(&sr, r, sn)) == 0.0)
332	+	continue;
333	+	VCOPY(srccnt[sn].dir, sr.rdir);
334	+	/* compute coefficient */
335	+	(*f)(srccnt[sn].val, p, srccnt[sn].dir, srccnt[sn].dom);
336	+	cntord[sn].brt = bright(srccnt[sn].val);
337	+	if (cntord[sn].brt <= 0.0)
338	+	continue;
339	+	/* compute intersection */
340	+	if (!( source[sn].sflags & SDISTANT ?
341	+	sourcehit(&sr) :
342	+	(*ofun[source[sn].so->otype].funp)
343	+	(source[sn].so, &sr) )) {
344	+	sprintf(errmsg,
345	+	"aiming failure for light source \"%s\"",
346	+	source[sn].so->oname);
347	+	error(WARNING, errmsg);
348	+	cntord[sn].brt = 0.0;
349	+	continue;
350	+	}
351	+	/* compute contribution */
352	+	raycont(&sr);
353	+	multcolor(srccnt[sn].val, sr.rcol);
354	+	cntord[sn].brt = bright(srccnt[sn].val);
355	+	}
356	+	/* sort contributions */
357	+	qsort(cntord, nsources, sizeof(CNTPTR), cntcmp);
358	+	{                                       /* find last */
359	+	register int  l, m;
360	+
361	+	sn = 0; ncnts = l = nsources;
362	+	while ((m = (sn + ncnts) >> 1) != l) {
363	+	if (cntord[m].brt > 0.0)
364	+	sn = m;
365	+	else
366	+	ncnts = m;
367	+	l = m;
368	+	}
369	+	}
370	+	/* accumulate tail */
371	+	for (sn = ncnts-1; sn > 0; sn--)
372	+	cntord[sn-1].brt += cntord[sn].brt;
373	+	/* test for shadows */
374	+	nhits = 0;
375	+	for (sn = 0; sn < ncnts; sn++) {
376	+	/* check threshold */
377	+	if ((sn+nshadcheck>=ncnts ? cntord[sn].brt :
378	+	cntord[sn].brt-cntord[sn+nshadcheck].brt)
379	+	< ourthresh*bright(r->rcol))
380	+	break;
381	+	/* get statistics */
382	+	source[cntord[sn].sno].ntests++;
383	+	/* test for hit */
384	+	rayorigin(&sr, r, SHADOW, 1.0);
385	+	VCOPY(sr.rdir, srccnt[cntord[sn].sno].dir);
386	+	sr.rsrc = cntord[sn].sno;
387	+	if (localhit(&sr, &thescene) &&
388	+	sr.ro != source[cntord[sn].sno].so) {
389	+	/* check for transmission */
390	+	raycont(&sr);
391	+	if (bright(sr.rcol) <= FTINY)
392	+	continue;       /* missed! */
393	+	(*f)(srccnt[cntord[sn].sno].val, p,
394	+	srccnt[cntord[sn].sno].dir,
395	+	srccnt[cntord[sn].sno].dom);
396	+	multcolor(srccnt[cntord[sn].sno].val, sr.rcol);
397	+	}
398	+	/* add contribution if hit */
399	+	addcolor(r->rcol, srccnt[cntord[sn].sno].val);
400	+	nhits++;
401	+	source[cntord[sn].sno].nhits++;
402	+	}
403	+	/* surface hit rate */
404	+	if (sn > 0)
405	+	hwt = (double)nhits / (double)sn;
406	+	else
407	+	hwt = 0.5;
408	+	#ifdef DEBUG
409	+	sprintf(errmsg, "%d tested, %d untested, %f hit rate\n",
410	+	sn, ncnts-sn, hwt);
411	+	eputs(errmsg);
412	+	#endif
413	+	/* add in untested sources */
414	+	for ( ; sn < ncnts; sn++) {
415	+	prob = hwt * (double)source[cntord[sn].sno].nhits /
416	+	(double)source[cntord[sn].sno].ntests;
417	+	scalecolor(srccnt[cntord[sn].sno].val, prob);
418	+	addcolor(r->rcol, srccnt[cntord[sn].sno].val);
419	+	}
420	+	}
421	+
422	+
423		#define  wrongsource(m, r)      (m->otype!=MAT_ILLUM && \
424		r->rsrc>=0 && \
425	<	srcval[r->rsrc].so!=r->ro)
425	>	source[r->rsrc].so!=r->ro)
426
427		#define  badambient(m, r)       ((r->crtype&(AMBIENT|SHADOW))==AMBIENT && \
428		!(r->rtype&REFLECTED) &&        /* hack! */\
429		!(m->otype==MAT_GLOW&&r->rot>m->oargs.farg[3]))
430
431		#define  passillum(m, r)        (m->otype==MAT_ILLUM && \
432	<	!(r->rsrc>=0&&srcval[r->rsrc].so==r->ro))
432	>	!(r->rsrc>=0&&source[r->rsrc].so==r->ro))
433
434
435		m_light(m, r)                   /* ray hit a light source */
436		register OBJREC  *m;
437		register RAY  *r;
438		{
292	–	/* check for behind */
293	–	if (r->rod < 0.0)
294	–	return;
439		/* check for over-counting */
440		if (wrongsource(m, r) || badambient(m, r))
441		return;
#	Line 305 | Line 449 | register RAY  *r;
449
450		/* otherwise treat as source */
451		} else {
452	+	/* check for behind */
453	+	if (r->rod < 0.0)
454	+	return;
455		/* get distribution pattern */
456		raytexture(r, m->omod);
457		/* get source color */
#	Line 313 | Line 460 | register RAY  *r;
460		m->oargs.farg[2]);
461		/* modify value */
462		multcolor(r->rcol, r->pcol);
463	+	/* assign distance */
464	+	r->rt = r->rot;
465		}
466		}
318	–
319	–
320	–	o_source() {}           /* intersection with a source is done elsewhere */

Diff Legend

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