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.49 by greg, Fri Apr 15 04:44:51 2005 UTC vs.
Revision 2.62 by greg, Wed May 7 02:08:12 2014 UTC

#	Line 13 | Line 13 | static const char RCSid[] = "$Id$";
13		#include  "source.h"
14		#include  "random.h"
15
16	–	extern double  ssampdist;               /* scatter sampling distance */
17	–
16		#ifndef MAXSSAMP
17		#define MAXSSAMP        16              /* maximum samples per ray */
18		#endif
#	Line 42 | Line 40 | static int  maxcntr = 0;               /* size of contribution arra
40		static int cntcmp(const void *p1, const void *p2);
41
42
43	<	extern OBJREC *                 /* find an object's actual material */
44	<	findmaterial(register OBJREC *o)
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) {
#	Line 55 | 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);
#	Line 64 | Line 66 | findmaterial(register OBJREC *o)
66		}
67
68
69	<	extern void
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 */
#	Line 82 | Line 84 | marksources(void)                      /* find and mark source objects */
84		continue;
85		/* find material */
86		m = findmaterial(objptr(o->omod));
87	<	if (m == NULL || !islight(m->otype))
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
92	–	if (m->otype == MAT_GLOW &&
93	–	o->otype != OBJ_SOURCE &&
94	–	m->oargs.farg[3] <= FTINY)
95	–	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 109 | Line 118 | marksources(void)                      /* 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 136 | marksources(void)                      /* find and mark source objects */
136		#if  SHADCACHE
137		initobscache(ns);
138		#endif
139	<	if (!(source[ns].sflags & SSKIP))
129	<	foundsource++;
139	>	foundsource += !(source[ns].sflags & SSKIP);
140		}
141		if (!foundsource) {
142		error(WARNING, "no light sources found");
#	Line 145 | Line 155 | memerr:
155		}
156
157
158	<	extern void
158	>	void
159		freesources(void)                       /* free all source structures */
160		{
161		if (nsources > 0) {
#	Line 157 | Line 167 | freesources(void)                      /* 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 167 | Line 178 | freesources(void)                      /* free all source structures */
178		}
179
180
181	<	extern int
181	>	int
182		srcray(                         /* send a ray to a source, return domega */
183	<	register RAY  *sr,              /* returned source ray */
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)
193	<	continue;
194	<	/* check angle */
195	<	if (srcp->sflags & SSPOT) {
196	<	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 */
204	<	}
205	<	return(0);                  /* no more samples */
219	>	return(0);                      /* no more samples */
220		}
221
222
223	<	extern void
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 263 | Line 277 | transillum(                    /* check if material is transparent illu
277		}
278
279
280	<	extern int
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;
#	Line 296 | Line 310 | sourcehit(                     /* check to see if ray hit distant source
310		* If it's a glow or transparent illum, just remember it.
311		*/
312		if (source[i].sflags & SSKIP) {
313	<	glowsrc = i;
313	>	if (glowsrc < 0)
314	>	glowsrc = i;
315		continue;
316		}
317		if (transillum(source[i].so->omod)) {
318	<	transrc = i;
318	>	if (transrc < 0)
319	>	transrc = i;
320		continue;
321		}
322		r->ro = source[i].so;   /* otherwise, use first hit */
#	Line 337 | Line 353 | cntcmp(                                /* contribution compare (descending) */
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 348 | Line 364 | cntcmp(                                /* contribution compare (descending) */
364		}
365
366
367	<	extern void
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	<	register int  sn;
375	<	register CONTRIB  *scp;
374	>	int  sn;
375	>	CONTRIB  *scp;
376		SRCINDEX  si;
377		int  nshadcheck, ncnts;
378		int  nhits;
#	Line 382 | Line 398 | direct(                                        /* add direct component */
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 393 | Line 409 | direct(                                        /* add direct component */
409		}
410		#endif
411		VCOPY(scp->dir, sr.rdir);
412	+	copycolor(sr.rcoef, scp->coef);
413		/* compute potential */
414	<	srcvalue(&sr);
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);
400	<	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 435 | Line 453 | direct(                                        /* add direct component */
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 448 | Line 467 | direct(                                        /* add direct component */
467		source[scp->sno].sflags & SFOLLOW )) {
468		/* follow entire path */
469		raycont(&sr);
451	–	rayparticipate(&sr);
470		if (trace != NULL)
471		(*trace)(&sr);  /* trace execution */
472		if (bright(sr.rcol) <= FTINY) {
#	Line 460 | Line 478 | direct(                                        /* add direct component */
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 483 | Line 508 | direct(                                        /* add direct component */
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;
488	<	scalecolor(scp->val, prob);
511	>	if (prob < 1.0)
512	>	scalecolor(scp->val, prob);
513		addcolor(r->rcol, scp->val);
514		}
515		}
516
517
518	<	extern void
518	>	void
519		srcscatter(                     /* compute source scattering into ray */
520	<	register RAY  *r
520	>	RAY  *r
521		)
522		{
523		int  oldsampndx;
#	Line 532 | Line 556 | srcscatter(                    /* compute source scattering into ray */
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;
535	–	sr.rmax = 0.;
559		initsrcindex(&si);      /* sample ray to this source */
560		si.sn = r->slights[i];
561		nopart(&si, &sr);
#	Line 657 | Line 680 | weaksrcmat(OBJECT obj)         /* identify material */
680		distglow(m, r, raydist(r,PRIMARY)))
681
682
683	<	extern int
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 675 | Line 702 | m_light(                               /* ray hit a light source */
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)
681	–	return(1);
682	–	/* check for invisibility */
683	–	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)