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.24 by greg, Wed Apr 17 14:02:18 1996 UTC vs.
Revision 2.30 by greg, Tue Feb 25 02:47:23 2003 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 "copyright.h"
11	+
12		#include  "ray.h"
13
15	–	#include  "octree.h"
16	–
14		#include  "otypes.h"
15
16		#include  "source.h"
#	Line 47 | Line 44 | static CNTPTR  *cntord;                        /* source ordering in direct
44		static int  maxcntr = 0;                /* size of contribution arrays */
45
46
47	+	void
48		marksources()                   /* find and mark source objects */
49		{
50		int  foundsource = 0;
#	Line 125 | Line 123 | memerr:
123		}
124
125
126	+	void
127	+	freesources()                   /* free all source structures */
128	+	{
129	+	if (nsources > 0) {
130	+	free((void *)source);
131	+	source = NULL;
132	+	nsources = 0;
133	+	}
134	+	if (maxcntr <= 0)
135	+	return;
136	+	free((void *)srccnt);
137	+	srccnt = NULL;
138	+	free((void *)cntord);
139	+	cntord = NULL;
140	+	maxcntr = 0;
141	+	}
142	+
143	+
144	+	int
145		srcray(sr, r, si)               /* send a ray to a source, return domega */
146		register RAY  *sr;              /* returned source ray */
147		RAY  *r;                        /* ray which hit object */
#	Line 162 | Line 179 | SRCINDEX  *si;                 /* source sample index */
179		}
180
181
182	+	void
183		srcvalue(r)                     /* punch ray to source and compute value */
184		register RAY  *r;
185		{
#	Line 202 | Line 220 | nomat:
220		}
221
222
223	+	int
224		sourcehit(r)                    /* check to see if ray hit distant source */
225		register RAY  *r;
226		{
#	Line 227 | Line 246 | register RAY  *r;
246		}
247
248		if (r->ro != NULL) {
249	+	r->robj = objndx(r->ro);
250		for (i = 0; i < 3; i++)
251		r->ron[i] = -r->rdir[i];
252		r->rod = 1.0;
#	Line 249 | Line 269 | register CNTPTR  *sc1, *sc2;
269		}
270
271
272	+	void
273		direct(r, f, p)                         /* add direct component */
274		RAY  *r;                        /* ray that hit surface */
275	<	int  (*f)();                    /* direct component coefficient function */
275	>	void  (*f)();                   /* direct component coefficient function */
276		char  *p;                       /* data for f */
277		{
278	<	extern int  (*trace)();
278	>	extern void  (*trace)();
279		register int  sn;
280		register CONTRIB  *scp;
281		SRCINDEX  si;
#	Line 374 | Line 395 | char  *p;                      /* data for f */
395		}
396
397
398	+	void
399		srcscatter(r)                   /* compute source scattering into ray */
400		register RAY  *r;
401		{
#	Line 381 | Line 403 | register RAY  *r;
403		int  nsamps;
404		RAY  sr;
405		SRCINDEX  si;
406	<	double  t, lastt, d;
407	<	COLOR  cumval, ctmp;
406	>	double  t, d;
407	>	double  re, ge, be;
408	>	COLOR  cvext;
409		int  i, j;
410
411		if (r->slights == NULL || r->slights[0] == 0
#	Line 397 | Line 420 | register RAY  *r;
420		oldsampndx = samplendx;
421		samplendx = random()&0x7fff;            /* randomize */
422		for (i = r->slights[0]; i > 0; i--) {   /* for each source */
423	<	setcolor(cumval, 0., 0., 0.);
401	<	lastt = r->rot;
402	<	for (j = nsamps; j-- > 0; ) {   /* for each sample position */
423	>	for (j = 0; j < nsamps; j++) {  /* for each sample position */
424		samplendx++;
425		t = r->rot * (j+frandom())/nsamps;
426	+	/* extinction */
427	+	re = t*colval(r->cext,RED);
428	+	ge = t*colval(r->cext,GRN);
429	+	be = t*colval(r->cext,BLU);
430	+	setcolor(cvext, re > 92. ? 0. : exp(-re),
431	+	ge > 92. ? 0. : exp(-ge),
432	+	be > 92. ? 0. : exp(-be));
433	+	if (intens(cvext) <= FTINY)
434	+	break;                  /* too far away */
435		sr.rorg[0] = r->rorg[0] + r->rdir[0]*t;
436		sr.rorg[1] = r->rorg[1] + r->rdir[1]*t;
437		sr.rorg[2] = r->rorg[2] + r->rdir[2]*t;
#	Line 415 | Line 445 | register RAY  *r;
445		copycolor(sr.cext, r->cext);
446		copycolor(sr.albedo, r->albedo);
447		sr.gecc = r->gecc;
448	+	sr.slights = r->slights;
449		rayvalue(&sr);                  /* eval. source ray */
450		if (bright(sr.rcol) <= FTINY)
451		continue;
421	–	/* 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;
452		if (r->gecc <= FTINY)           /* compute P(theta) */
453		d = 1.;
454		else {
455		d = DOT(r->rdir, sr.rdir);
456	<	d = sqrt(1. + r->gecc*r->gecc - 2.*r->gecc*d);
457	<	d = (1. - r->gecc*r->gecc) / (d*d*d);
456	>	d = 1. + r->gecc*r->gecc - 2.*r->gecc*d;
457	>	d = (1. - r->gecc*r->gecc) / (d*sqrt(d));
458		}
459		/* other factors */
460		d *= si.dom * r->rot / (4.*PI*nsamps);
461		multcolor(sr.rcol, r->cext);
462		multcolor(sr.rcol, r->albedo);
463		scalecolor(sr.rcol, d);
464	<	addcolor(cumval, sr.rcol);
464	>	multcolor(sr.rcol, cvext);
465	>	addcolor(r->rcol, sr.rcol);     /* add it in */
466		}
442	–	/* final fall-off */
443	–	setcolor(ctmp,  1.-lastt*colval(r->cext,RED),
444	–	1.-lastt*colval(r->cext,GRN),
445	–	1.-lastt*colval(r->cext,BLU));
446	–	multcolor(cumval, ctmp);
447	–	addcolor(r->rcol, cumval);      /* sum into ray result */
467		}
468		samplendx = oldsampndx;
469		}
#	Line 528 | Line 547 | return(o->otype==MAT_ILLUM|o->otype==MAT_GLOW);}
547		distglow(m, r, raydist(r,PRIMARY)))
548
549
550	+	int
551		m_light(m, r)                   /* ray hit a light source */
552		register OBJREC  *m;
553		register RAY  *r;
#	Line 540 | Line 560 | register RAY  *r;
560		/* check for passed illum */
561		if (passillum(m, r)) {
562		if (m->oargs.nsargs && strcmp(m->oargs.sarg[0], VOIDID))
563	<	return(rayshade(r, modifier(m->oargs.sarg[0])));
563	>	return(rayshade(r,lastmod(objndx(m),m->oargs.sarg[0])));
564		raytrans(r);
565		return(1);
566		}

Diff Legend

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