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.42 by greg, Sun Jan 18 17:03:12 2004 UTC vs.
Revision 2.62 by greg, Wed May 7 02:08:12 2014 UTC

#	Line 8 | Line 8 | static const char RCSid[] = "$Id$";
8		*/
9
10		#include  "ray.h"
11	–
11		#include  "otypes.h"
12	<
12	>	#include  "rtotypes.h"
13		#include  "source.h"
15	–
14		#include  "random.h"
15
18	–	extern double  ssampdist;               /* scatter sampling distance */
19	–
16		#ifndef MAXSSAMP
17		#define MAXSSAMP        16              /* maximum samples per ray */
18		#endif
#	Line 41 | 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	+
43		OBJREC *                        /* find an object's actual material */
44	<	findmaterial(register OBJREC *o)
44	>	findmaterial(OBJREC *o)
45		{
46		while (!ismaterial(o->otype)) {
49	–	if (ismixture(o->otype))
50	–	return(NULL);   /* reject mixed materials */
47		if (o->otype == MOD_ALIAS && o->oargs.nsargs) {
48		OBJECT  aobj;
49		OBJREC  *ao;
#	Line 57 | Line 53 | findmaterial(register OBJREC *o)
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);
65	>	return(o);              /* mixtures will return NULL */
66		}
67
68
69		void
70	<	marksources()                   /* find and mark source objects */
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 */
#	Line 83 | Line 83 | marksources()                  /* find and mark source objects */
83		if (!issurface(o->otype) || o->omod == OVOID)
84		continue;
85		/* find material */
86	<	m = findmaterial(o);
87	<	if (m == NULL || !islight(m->otype))
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
94	–	if (m->otype == MAT_GLOW &&
95	–	o->otype != OBJ_SOURCE &&
96	–	m->oargs.farg[3] <= FTINY)
97	–	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 111 | 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 125 | Line 134 | marksources()                  /* find and mark source objects */
134		}
135		}
136		#if  SHADCACHE
137	<	source[ns].obscache = NULL;
137	>	initobscache(ns);
138		#endif
139	<	if (!(source[ns].sflags & SSKIP))
131	<	foundsource++;
139	>	foundsource += !(source[ns].sflags & SSKIP);
140		}
141		if (!foundsource) {
142		error(WARNING, "no light sources found");
#	Line 148 | Line 156 | memerr:
156
157
158		void
159	<	freesources()                   /* free all source structures */
159	>	freesources(void)                       /* free all source structures */
160		{
161		if (nsources > 0) {
162		#if SHADCACHE
#	Line 159 | Line 167 | freesources()                  /* free all source structures */
167		source = NULL;
168		nsources = 0;
169		}
170	+	markclip(NULL);
171		if (maxcntr <= 0)
172		return;
173		free((void *)srccnt);
#	Line 171 | Line 180 | freesources()                  /* free all source structures */
180
181		int
182		srcray(                         /* send a ray to a source, return domega */
183	<	register RAY  *sr,              /* returned source ray */
184	<	RAY  *r,                        /* ray which hit object */
185	<	SRCINDEX  *si                   /* source sample index */
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	<	register SRCREC  *srcp;
188	>	double  d;                              /* distance to source */
189	>	SRCREC  *srcp;
190
191	<	rayorigin(sr, r, SHADOW, 1.0);              /* ignore limits */
191	>	rayorigin(sr, SHADOW, r, NULL);         /* ignore limits */
192
193	<	while ((d = nextssamp(sr, si)) != 0.0) {
194	<	sr->rsrc = si->sn;                      /* remember source */
195	<	srcp = source + si->sn;
196	<	if (srcp->sflags & SDISTANT) {
197	<	if (srcp->sflags & SSPOT && spotout(sr, srcp->sl.s))
198	<	continue;
199	<	return(1);              /* sample OK */
200	<	}
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)
195	<	continue;
196	<	/* check angle */
197	<	if (srcp->sflags & SSPOT) {
198	<	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 */
206	<	}
207	<	return(0);                  /* no more samples */
219	>	return(0);                      /* no more samples */
220		}
221
222
223		void
224		srcvalue(                       /* punch ray to source and compute value */
225	<	register RAY  *r
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 250 | Line 262 | nomat:
262		}
263
264
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	<	register RAY  *r
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	<	r->robj = objndx(r->ro);
310	<	for (i = 0; i < 3; i++)
311	<	r->ron[i] = -r->rdir[i];
312	<	r->rod = 1.0;
313	<	r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
314	<	r->uv[0] = r->uv[1] = 0.0;
315	<	r->rox = NULL;
316	<	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(                         /* contribution compare (descending) */
352	<	const void *p1,
353	<	const void *p2
352	>	const void *p1,
353	>	const void *p2
354		)
355		{
356	<	register const CNTPTR  *sc1 = (const CNTPTR *)p1;
357	<	register const CNTPTR  *sc2 = (const CNTPTR *)p2;
356	>	const CNTPTR  *sc1 = (const CNTPTR *)p1;
357	>	const CNTPTR  *sc2 = (const CNTPTR *)p2;
358
359		if (sc1->brt > sc2->brt)
360		return(-1);
#	Line 309 | Line 366 | const void *p2
366
367		void
368		direct(                                 /* add direct component */
369	<	RAY  *r,                        /* ray that hit surface */
370	<	void  (*f)(),                   /* direct component coefficient function */
371	<	char  *p                        /* data for f */
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 void  (*trace)();
375	<	register int  sn;
319	<	register CONTRIB  *scp;
374	>	int  sn;
375	>	CONTRIB  *scp;
376		SRCINDEX  si;
377		int  nshadcheck, ncnts;
378		int  nhits;
#	Line 342 | 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
#	Line 353 | Line 409 | char  *p                       /* data for f */
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);
361	<	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 396 | Line 453 | char  *p                       /* data for f */
453		break;
454		scp = srccnt + cntord[sn].sndx;
455		/* test for hit */
456	<	rayorigin(&sr, r, SHADOW, 1.0);
456	>	rayorigin(&sr, SHADOW, r, NULL);
457	>	copycolor(sr.rcoef, scp->coef);
458		VCOPY(sr.rdir, scp->dir);
459		sr.rsrc = scp->sno;
460		/* keep statistics */
#	Line 409 | Line 467 | char  *p                       /* data for f */
467		source[scp->sno].sflags & SFOLLOW )) {
468		/* follow entire path */
469		raycont(&sr);
412	–	rayparticipate(&sr);
470		if (trace != NULL)
471		(*trace)(&sr);  /* trace execution */
472		if (bright(sr.rcol) <= FTINY) {
#	Line 421 | Line 478 | char  *p                       /* data for f */
478		#endif
479		continue;       /* missed! */
480		}
481	+	rayparticipate(&sr);
482	+	multcolor(sr.rcol, sr.rcoef);
483		copycolor(scp->val, sr.rcol);
484	<	multcolor(scp->val, scp->coef);
484	>	} else if (trace != NULL &&
485	>	(source[scp->sno].sflags & (SDISTANT|SVIRTUAL|SFOLLOW))
486	>	== (SDISTANT|SFOLLOW) &&
487	>	sourcehit(&sr) && rayshade(&sr, sr.ro->omod)) {
488	>	(*trace)(&sr);          /* trace execution */
489	>	/* skip call to rayparticipate() & scp->val update */
490		}
491		/* add contribution if hit */
492		addcolor(r->rcol, scp->val);
#	Line 444 | Line 508 | char  *p                       /* data for f */
508		scp = srccnt + cntord[sn].sndx;
509		prob = hwt * (double)source[scp->sno].nhits /
510		(double)source[scp->sno].ntests;
511	<	if (prob > 1.0)
512	<	prob = 1.0;
449	<	scalecolor(scp->val, prob);
511	>	if (prob < 1.0)
512	>	scalecolor(scp->val, prob);
513		addcolor(r->rcol, scp->val);
514		}
515		}
#	Line 454 | Line 517 | char  *p                       /* data for f */
517
518		void
519		srcscatter(                     /* compute source scattering into ray */
520	<	register RAY  *r
520	>	RAY  *r
521		)
522		{
523		int  oldsampndx;
#	Line 493 | Line 556 | register RAY  *r
556		sr.rorg[0] = r->rorg[0] + r->rdir[0]*t;
557		sr.rorg[1] = r->rorg[1] + r->rdir[1]*t;
558		sr.rorg[2] = r->rorg[2] + r->rdir[2]*t;
496	–	sr.rmax = 0.;
559		initsrcindex(&si);      /* sample ray to this source */
560		si.sn = r->slights[i];
561		nopart(&si, &sr);
562		if (!srcray(&sr, NULL, &si) ||
563		sr.rsrc != r->slights[i])
564		continue;               /* no path */
565	+	#if SHADCACHE
566	+	if (srcblocked(&sr))            /* check shadow cache */
567	+	continue;
568	+	#endif
569		copycolor(sr.cext, r->cext);
570		copycolor(sr.albedo, r->albedo);
571		sr.gecc = r->gecc;
572		sr.slights = r->slights;
573		rayvalue(&sr);                  /* eval. source ray */
574	<	if (bright(sr.rcol) <= FTINY)
574	>	if (bright(sr.rcol) <= FTINY) {
575	>	#if SHADCACHE
576	>	srcblocker(&sr);        /* add blocker to cache */
577	>	#endif
578		continue;
579	+	}
580		if (r->gecc <= FTINY)           /* compute P(theta) */
581		d = 1.;
582		else {
#	Line 546 | Line 616 | register RAY  *r
616		static int
617		weaksrcmat(OBJECT obj)          /* identify material */
618		{
619	<	OBJREC *o = findmaterial(objptr(obj));
619	>	OBJREC *m = findmaterial(objptr(obj));
620
621	<	if (o == NULL) return 0;
622	<	return((o->otype==MAT_ILLUM)|(o->otype==MAT_GLOW));
621	>	if (m == NULL) return(0);
622	>	return((m->otype==MAT_ILLUM) | (m->otype==MAT_GLOW));
623		}
624
625		#define  illumblock(m, r)       (!(source[r->rsrc].sflags&SVIRTUAL) && \
#	Line 612 | Line 682 | weaksrcmat(OBJECT obj)         /* identify material */
682
683		int
684		m_light(                                /* ray hit a light source */
685	<	register OBJREC  *m,
686	<	register RAY  *r
685	>	OBJREC  *m,
686	>	RAY  *r
687		)
688		{
689		/* check for over-counting */
690	<	if (badcomponent(m, r))
690	>	if (badcomponent(m, r)) {
691	>	setcolor(r->rcoef, 0.0, 0.0, 0.0);
692		return(1);
693	<	if (wrongsource(m, r))
693	>	}
694	>	if (wrongsource(m, r)) {
695	>	setcolor(r->rcoef, 0.0, 0.0, 0.0);
696		return(1);
697	+	}
698		/* check for passed illum */
699		if (passillum(m, r)) {
700		if (m->oargs.nsargs && strcmp(m->oargs.sarg[0], VOIDID))
#	Line 628 | Line 702 | register RAY  *r
702		raytrans(r);
703		return(1);
704		}
705	+	/* check for invisibility */
706	+	if (srcignore(m, r)) {
707	+	setcolor(r->rcoef, 0.0, 0.0, 0.0);
708	+	return(1);
709	+	}
710		/* otherwise treat as source */
711		/* check for behind */
712		if (r->rod < 0.0)
634	–	return(1);
635	–	/* check for invisibility */
636	–	if (srcignore(m, r))
713		return(1);
714		/* check for outside spot */
715		if (m->otype==MAT_SPOT && spotout(r, makespot(m)))

Diff Legend

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