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.23 by greg, Thu Mar 21 15:33:09 1996 UTC vs.
Revision 2.51 by greg, Thu May 26 06:55:22 2005 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 */
#	Line 46 | 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	<	marksources()                   /* find and mark source objects */
44	>
45	>	extern OBJREC *                 /* find an object's actual material */
46	>	findmaterial(register OBJREC *o)
47		{
48	+	while (!ismaterial(o->otype)) {
49	+	if (o->otype == MOD_ALIAS && o->oargs.nsargs) {
50	+	OBJECT  aobj;
51	+	OBJREC  *ao;
52	+	aobj = lastmod(objndx(o), o->oargs.sarg[0]);
53	+	if (aobj < 0)
54	+	objerror(o, USER, "bad reference");
55	+	ao = objptr(aobj);
56	+	if (ismaterial(ao->otype))
57	+	return(ao);
58	+	}
59	+	if (o->omod == OVOID)
60	+	return(NULL);
61	+	o = objptr(o->omod);
62	+	}
63	+	return(o);              /* mixtures will return NULL */
64	+	}
65	+
66	+
67	+	extern void
68	+	marksources(void)                       /* find and mark source objects */
69	+	{
70		int  foundsource = 0;
71		int  i;
72		register OBJREC  *o, *m;
#	Line 56 | Line 74 | marksources()                  /* find and mark source objects */
74		/* initialize dispatch table */
75		initstypes();
76		/* find direct sources */
77	<	for (i = 0; i < nobjects; i++) {
77	>	for (i = 0; i < nsceneobjs; i++) {
78
79		o = objptr(i);
80
81		if (!issurface(o->otype) || o->omod == OVOID)
82		continue;
83	<
84	<	m = objptr(o->omod);
85	<
86	<	if (!islight(m->otype))
69	<	continue;
83	>	/* find material */
84	>	m = findmaterial(objptr(o->omod));
85	>	if (m == NULL || !islight(m->otype))
86	>	continue;       /* not source modifier */
87
88		if (m->oargs.nfargs != (m->otype == MAT_GLOW ? 4 :
89		m->otype == MAT_SPOT ? 7 : 3))
#	Line 105 | Line 122 | marksources()                  /* find and mark source objects */
122		source[ns].sflags |= SSKIP;
123		}
124		}
125	+	#if  SHADCACHE
126	+	initobscache(ns);
127	+	#endif
128		if (!(source[ns].sflags & SSKIP))
129		foundsource++;
130		}
#	Line 117 | Line 137 | marksources()                  /* find and mark source objects */
137		maxcntr = nsources + MAXSPART;  /* start with this many */
138		srccnt = (CONTRIB *)malloc(maxcntr*sizeof(CONTRIB));
139		cntord = (CNTPTR *)malloc(maxcntr*sizeof(CNTPTR));
140	<	if (srccnt == NULL | cntord == NULL)
140	>	if ((srccnt == NULL) | (cntord == NULL))
141		goto memerr;
142		return;
143		memerr:
#	Line 125 | Line 145 | memerr:
145		}
146
147
148	<	srcray(sr, r, si)               /* send a ray to a source, return domega */
149	<	register RAY  *sr;              /* returned source ray */
130	<	RAY  *r;                        /* ray which hit object */
131	<	SRCINDEX  *si;                  /* source sample index */
148	>	extern void
149	>	freesources(void)                       /* free all source structures */
150		{
151	+	if (nsources > 0) {
152	+	#if SHADCACHE
153	+	while (nsources--)
154	+	freeobscache(&source[nsources]);
155	+	#endif
156	+	free((void *)source);
157	+	source = NULL;
158	+	nsources = 0;
159	+	}
160	+	if (maxcntr <= 0)
161	+	return;
162	+	free((void *)srccnt);
163	+	srccnt = NULL;
164	+	free((void *)cntord);
165	+	cntord = NULL;
166	+	maxcntr = 0;
167	+	}
168	+
169	+
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 */
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 162 | Line 206 | SRCINDEX  *si;                 /* source sample index */
206		}
207
208
209	<	srcvalue(r)                     /* punch ray to source and compute value */
210	<	register RAY  *r;
209	>	extern void
210	>	srcvalue(                       /* punch ray to source and compute value */
211	>	register RAY  *r
212	>	)
213		{
214		register SRCREC  *sp;
215
#	Line 202 | Line 248 | nomat:
248		}
249
250
251	<	sourcehit(r)                    /* check to see if ray hit distant source */
252	<	register RAY  *r;
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
269	+	)
270	+	{
271	+	int  glowsrc = -1;
272	+	int  transrc = -1;
273		int  first, last;
274		register int  i;
275
#	Line 213 | 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	<	for (i = 0; i < 3; i++)
296	<	r->ron[i] = -r->rdir[i];
297	<	r->rod = 1.0;
298	<	r->rox = NULL;
299	<	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(sc1, sc2)                        /* contribution compare (descending) */
336	<	register CNTPTR  *sc1, *sc2;
335	>	cntcmp(                         /* contribution compare (descending) */
336	>	const void *p1,
337	>	const void *p2
338	>	)
339		{
340	+	register const CNTPTR  *sc1 = (const CNTPTR *)p1;
341	+	register const CNTPTR  *sc2 = (const CNTPTR *)p2;
342	+
343		if (sc1->brt > sc2->brt)
344		return(-1);
345		if (sc1->brt < sc2->brt)
#	Line 249 | Line 348 | register CNTPTR  *sc1, *sc2;
348		}
349
350
351	<	direct(r, f, p)                         /* add direct component */
352	<	RAY  *r;                        /* ray that hit surface */
353	<	int  (*f)();                    /* direct component coefficient function */
354	<	char  *p;                       /* data for f */
351	>	extern void
352	>	direct(                                 /* add direct component */
353	>	RAY  *r,                        /* ray that hit surface */
354	>	srcdirf_t *f,                   /* direct component coefficient function */
355	>	void  *p                        /* data for f */
356	>	)
357		{
257	–	extern int  (*trace)();
358		register int  sn;
359		register CONTRIB  *scp;
360		SRCINDEX  si;
#	Line 270 | Line 370 | char  *p;                      /* data for f */
370		for (sn = 0; srcray(&sr, r, &si); sn++) {
371		if (sn >= maxcntr) {
372		maxcntr = sn + MAXSPART;
373	<	srccnt = (CONTRIB *)realloc((char *)srccnt,
373	>	srccnt = (CONTRIB *)realloc((void *)srccnt,
374		maxcntr*sizeof(CONTRIB));
375	<	cntord = (CNTPTR *)realloc((char *)cntord,
375	>	cntord = (CNTPTR *)realloc((void *)cntord,
376		maxcntr*sizeof(CNTPTR));
377	<	if (srccnt == NULL | cntord == NULL)
377	>	if ((srccnt == NULL) | (cntord == NULL))
378		error(SYSTEM, "out of memory in direct");
379		}
380		cntord[sn].sndx = sn;
#	Line 285 | Line 385 | char  *p;                      /* data for f */
385		cntord[sn].brt = bright(scp->coef);
386		if (cntord[sn].brt <= 0.0)
387		continue;
388	+	#if SHADCACHE
389	+	/* check shadow cache */
390	+	if (si.np == 1 && srcblocked(&sr)) {
391	+	cntord[sn].brt = 0.0;
392	+	continue;
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);
293	–	multcolor(scp->val, scp->coef);
402		cntord[sn].brt = bright(scp->val);
403		}
404		/* sort contributions */
#	Line 329 | 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, scp->coef);
441		VCOPY(sr.rdir, scp->dir);
442		sr.rsrc = scp->sno;
443	<	source[scp->sno].ntests++;      /* keep statistics */
443	>	/* keep statistics */
444	>	if (source[scp->sno].ntests++ > 0xfffffff0) {
445	>	source[scp->sno].ntests >>= 1;
446	>	source[scp->sno].nhits >>= 1;
447	>	}
448		if (localhit(&sr, &thescene) &&
449		( sr.ro != source[scp->sno].so ||
450		source[scp->sno].sflags & SFOLLOW )) {
451		/* follow entire path */
452		raycont(&sr);
341	–	rayparticipate(&sr);
453		if (trace != NULL)
454		(*trace)(&sr);  /* trace execution */
455	<	if (bright(sr.rcol) <= FTINY)
455	>	rayparticipate(&sr);
456	>	if (bright(sr.rcol) <= FTINY) {
457	>	#if SHADCACHE
458	>	if ((scp <= srccnt || scp[-1].sno != scp->sno)
459	>	&& (scp >= srccnt+ncnts-1 ||
460	>	scp[1].sno != scp->sno))
461	>	srcblocker(&sr);
462	>	#endif
463		continue;       /* missed! */
464	+	}
465	+	multcolor(sr.rcol, sr.rcoef);
466		copycolor(scp->val, sr.rcol);
467	<	multcolor(scp->val, scp->coef);
467	>	} else if (trace != NULL &&
468	>	(source[scp->sno].sflags & (SDISTANT|SVIRTUAL|SFOLLOW))
469	>	== (SDISTANT|SFOLLOW) &&
470	>	sourcehit(&sr) && rayshade(&sr, sr.ro->omod)) {
471	>	(*trace)(&sr);          /* trace execution */
472	>	/* skip call to rayparticipate() & scp->val update */
473		}
474		/* add contribution if hit */
475		addcolor(r->rcol, scp->val);
#	Line 366 | Line 491 | char  *p;                      /* data for f */
491		scp = srccnt + cntord[sn].sndx;
492		prob = hwt * (double)source[scp->sno].nhits /
493		(double)source[scp->sno].ntests;
494	<	if (prob > 1.0)
495	<	prob = 1.0;
371	<	scalecolor(scp->val, prob);
494	>	if (prob < 1.0)
495	>	scalecolor(scp->val, prob);
496		addcolor(r->rcol, scp->val);
497		}
498		}
499
500
501	<	srcscatter(r)                   /* compute source scattering into ray */
502	<	register RAY  *r;
501	>	extern void
502	>	srcscatter(                     /* compute source scattering into ray */
503	>	register RAY  *r
504	>	)
505		{
506		int  oldsampndx;
507		int  nsamps;
508		RAY  sr;
509		SRCINDEX  si;
510	<	double  t, lastt, d;
511	<	COLOR  cumval, ctmp;
510	>	double  t, d;
511	>	double  re, ge, be;
512	>	COLOR  cvext;
513		int  i, j;
514
515		if (r->slights == NULL || r->slights[0] == 0
#	Line 397 | Line 524 | register RAY  *r;
524		oldsampndx = samplendx;
525		samplendx = random()&0x7fff;            /* randomize */
526		for (i = r->slights[0]; i > 0; i--) {   /* for each source */
527	<	setcolor(cumval, 0., 0., 0.);
401	<	lastt = r->rot;
402	<	for (j = nsamps; j-- > 0; ) {   /* for each sample position */
527	>	for (j = 0; j < nsamps; j++) {  /* for each sample position */
528		samplendx++;
529		t = r->rot * (j+frandom())/nsamps;
530	+	/* extinction */
531	+	re = t*colval(r->cext,RED);
532	+	ge = t*colval(r->cext,GRN);
533	+	be = t*colval(r->cext,BLU);
534	+	setcolor(cvext, re > 92. ? 0. : exp(-re),
535	+	ge > 92. ? 0. : exp(-ge),
536	+	be > 92. ? 0. : exp(-be));
537	+	if (intens(cvext) <= FTINY)
538	+	break;                  /* too far away */
539		sr.rorg[0] = r->rorg[0] + r->rdir[0]*t;
540		sr.rorg[1] = r->rorg[1] + r->rdir[1]*t;
541		sr.rorg[2] = r->rorg[2] + r->rdir[2]*t;
#	Line 412 | Line 546 | register RAY  *r;
546		if (!srcray(&sr, NULL, &si) ||
547		sr.rsrc != r->slights[i])
548		continue;               /* no path */
549	+	#if SHADCACHE
550	+	if (srcblocked(&sr))            /* check shadow cache */
551	+	continue;
552	+	#endif
553		copycolor(sr.cext, r->cext);
554	<	sr.albedo = r->albedo;
554	>	copycolor(sr.albedo, r->albedo);
555		sr.gecc = r->gecc;
556	+	sr.slights = r->slights;
557		rayvalue(&sr);                  /* eval. source ray */
558	<	if (bright(sr.rcol) <= FTINY)
558	>	if (bright(sr.rcol) <= FTINY) {
559	>	#if SHADCACHE
560	>	srcblocker(&sr);        /* add blocker to cache */
561	>	#endif
562		continue;
563	<	/* compute fall-off */
422	<	d = lastt - t;
423	<	setcolor(ctmp,  1.-d*colval(r->cext,RED),
424	<	1.-d*colval(r->cext,GRN),
425	<	1.-d*colval(r->cext,BLU));
426	<	multcolor(cumval, ctmp);
427	<	lastt = t;
563	>	}
564		if (r->gecc <= FTINY)           /* compute P(theta) */
565		d = 1.;
566		else {
567		d = DOT(r->rdir, sr.rdir);
568	<	d = sqrt(1. + r->gecc*r->gecc - 2.*r->gecc*d);
569	<	d = (1. - r->gecc*r->gecc) / (d*d*d);
568	>	d = 1. + r->gecc*r->gecc - 2.*r->gecc*d;
569	>	d = (1. - r->gecc*r->gecc) / (d*sqrt(d));
570		}
571		/* other factors */
572	<	d *= si.dom * r->albedo * r->rot / (4.*PI*nsamps);
572	>	d *= si.dom * r->rot / (4.*PI*nsamps);
573		multcolor(sr.rcol, r->cext);
574	+	multcolor(sr.rcol, r->albedo);
575		scalecolor(sr.rcol, d);
576	<	addcolor(cumval, sr.rcol);
576	>	multcolor(sr.rcol, cvext);
577	>	addcolor(r->rcol, sr.rcol);     /* add it in */
578		}
441	–	/* final fall-off */
442	–	setcolor(ctmp,  1.-lastt*colval(r->cext,RED),
443	–	1.-lastt*colval(r->cext,GRN),
444	–	1.-lastt*colval(r->cext,BLU));
445	–	multcolor(cumval, ctmp);
446	–	addcolor(r->rcol, cumval);      /* sum into ray result */
579		}
580		samplendx = oldsampndx;
581		}
#	Line 465 | Line 597 | register RAY  *r;
597		* geometry behind (or inside) an effective radiator.
598		*/
599
600	<	static int weaksrcmod(obj) int obj;     /* efficiency booster function */
601	<	{register OBJREC *o = objptr(obj);
602	<	return(o->otype==MAT_ILLUM|o->otype==MAT_GLOW);}
600	>	static int
601	>	weaksrcmat(OBJECT obj)          /* identify material */
602	>	{
603	>	OBJREC *m = findmaterial(objptr(obj));
604	>
605	>	if (m == NULL) return(0);
606	>	return((m->otype==MAT_ILLUM) | (m->otype==MAT_GLOW));
607	>	}
608
609		#define  illumblock(m, r)       (!(source[r->rsrc].sflags&SVIRTUAL) && \
610		r->rod > 0.0 && \
611	<	weaksrcmod(source[r->rsrc].so->omod))
611	>	weaksrcmat(source[r->rsrc].so->omod))
612
613		/* wrongsource *
614		*
#	Line 527 | Line 664 | return(o->otype==MAT_ILLUM|o->otype==MAT_GLOW);}
664		distglow(m, r, raydist(r,PRIMARY)))
665
666
667	<	m_light(m, r)                   /* ray hit a light source */
668	<	register OBJREC  *m;
669	<	register RAY  *r;
667	>	extern int
668	>	m_light(                                /* ray hit a light source */
669	>	register OBJREC  *m,
670	>	register RAY  *r
671	>	)
672		{
673		/* check for over-counting */
674	<	if (badcomponent(m, r))
674	>	if (badcomponent(m, r)) {
675	>	setcolor(r->rcoef, 0.0, 0.0, 0.0);
676		return(1);
677	<	if (wrongsource(m, r))
677	>	}
678	>	if (wrongsource(m, r)) {
679	>	setcolor(r->rcoef, 0.0, 0.0, 0.0);
680		return(1);
681	+	}
682		/* check for passed illum */
683		if (passillum(m, r)) {
684		if (m->oargs.nsargs && strcmp(m->oargs.sarg[0], VOIDID))
685	<	return(rayshade(r, modifier(m->oargs.sarg[0])));
685	>	return(rayshade(r,lastmod(objndx(m),m->oargs.sarg[0])));
686		raytrans(r);
687		return(1);
688		}
689	+	/* check for invisibility */
690	+	if (srcignore(m, r)) {
691	+	setcolor(r->rcoef, 0.0, 0.0, 0.0);
692	+	return(1);
693	+	}
694		/* otherwise treat as source */
695		/* check for behind */
696		if (r->rod < 0.0)
549	–	return(1);
550	–	/* check for invisibility */
551	–	if (srcignore(m, r))
697		return(1);
698		/* check for outside spot */
699		if (m->otype==MAT_SPOT && spotout(r, makespot(m)))

Diff Legend

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