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.37 by greg, Fri Sep 12 22:35:54 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 56 | Line 54 | marksources()                  /* find and mark source objects */
54		/* initialize dispatch table */
55		initstypes();
56		/* find direct sources */
57	<	for (i = 0; i < nobjects; i++) {
57	>	for (i = 0; i < nsceneobjs; i++) {
58
59		o = objptr(i);
60
61		if (!issurface(o->otype) || o->omod == OVOID)
62		continue;
63	<
63	>	/* find material */
64		m = objptr(o->omod);
65	<
66	<	if (!islight(m->otype))
67	<	continue;
65	>	while (!ismaterial(m->otype))
66	>	if (ismixture(m->otype) || m->omod == OVOID) {
67	>	m = NULL;
68	>	break;
69	>	} else
70	>	m = objptr(m->omod);
71	>	if (m == NULL || !islight(m->otype))
72	>	continue;       /* not source modifier */
73
74		if (m->oargs.nfargs != (m->otype == MAT_GLOW ? 4 :
75		m->otype == MAT_SPOT ? 7 : 3))
#	Line 117 | Line 120 | marksources()                  /* find and mark source objects */
120		maxcntr = nsources + MAXSPART;  /* start with this many */
121		srccnt = (CONTRIB *)malloc(maxcntr*sizeof(CONTRIB));
122		cntord = (CNTPTR *)malloc(maxcntr*sizeof(CNTPTR));
123	<	if (srccnt == NULL | cntord == NULL)
123	>	if ((srccnt == NULL) | (cntord == NULL))
124		goto memerr;
125		return;
126		memerr:
#	Line 125 | Line 128 | memerr:
128		}
129
130
131	+	void
132	+	freesources()                   /* free all source structures */
133	+	{
134	+	if (nsources > 0) {
135	+	free((void *)source);
136	+	source = NULL;
137	+	nsources = 0;
138	+	}
139	+	if (maxcntr <= 0)
140	+	return;
141	+	free((void *)srccnt);
142	+	srccnt = NULL;
143	+	free((void *)cntord);
144	+	cntord = NULL;
145	+	maxcntr = 0;
146	+	}
147	+
148	+
149	+	int
150		srcray(sr, r, si)               /* send a ray to a source, return domega */
151		register RAY  *sr;              /* returned source ray */
152		RAY  *r;                        /* ray which hit object */
#	Line 162 | Line 184 | SRCINDEX  *si;                 /* source sample index */
184		}
185
186
187	+	void
188		srcvalue(r)                     /* punch ray to source and compute value */
189		register RAY  *r;
190		{
#	Line 202 | Line 225 | nomat:
225		}
226
227
228	+	int
229		sourcehit(r)                    /* check to see if ray hit distant source */
230		register RAY  *r;
231		{
#	Line 227 | Line 251 | register RAY  *r;
251		}
252
253		if (r->ro != NULL) {
254	+	r->robj = objndx(r->ro);
255		for (i = 0; i < 3; i++)
256		r->ron[i] = -r->rdir[i];
257		r->rod = 1.0;
258	+	r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
259	+	r->uv[0] = r->uv[1] = 0.0;
260		r->rox = NULL;
261		return(1);
262		}
#	Line 249 | Line 276 | register CNTPTR  *sc1, *sc2;
276		}
277
278
279	+	void
280		direct(r, f, p)                         /* add direct component */
281		RAY  *r;                        /* ray that hit surface */
282	<	int  (*f)();                    /* direct component coefficient function */
282	>	void  (*f)();                   /* direct component coefficient function */
283		char  *p;                       /* data for f */
284		{
285	<	extern int  (*trace)();
285	>	extern void  (*trace)();
286		register int  sn;
287		register CONTRIB  *scp;
288		SRCINDEX  si;
#	Line 270 | Line 298 | char  *p;                      /* data for f */
298		for (sn = 0; srcray(&sr, r, &si); sn++) {
299		if (sn >= maxcntr) {
300		maxcntr = sn + MAXSPART;
301	<	srccnt = (CONTRIB *)realloc((char *)srccnt,
301	>	srccnt = (CONTRIB *)realloc((void *)srccnt,
302		maxcntr*sizeof(CONTRIB));
303	<	cntord = (CNTPTR *)realloc((char *)cntord,
303	>	cntord = (CNTPTR *)realloc((void *)cntord,
304		maxcntr*sizeof(CNTPTR));
305	<	if (srccnt == NULL | cntord == NULL)
305	>	if ((srccnt == NULL) | (cntord == NULL))
306		error(SYSTEM, "out of memory in direct");
307		}
308		cntord[sn].sndx = sn;
#	Line 332 | Line 360 | char  *p;                      /* data for f */
360		rayorigin(&sr, r, SHADOW, 1.0);
361		VCOPY(sr.rdir, scp->dir);
362		sr.rsrc = scp->sno;
363	<	source[scp->sno].ntests++;      /* keep statistics */
363	>	/* keep statistics */
364	>	if (source[scp->sno].ntests++ > 0xfffffff0) {
365	>	source[scp->sno].ntests >>= 1;
366	>	source[scp->sno].nhits >>= 1;
367	>	}
368		if (localhit(&sr, &thescene) &&
369		( sr.ro != source[scp->sno].so ||
370		source[scp->sno].sflags & SFOLLOW )) {
#	Line 374 | Line 406 | char  *p;                      /* data for f */
406		}
407
408
409	+	void
410		srcscatter(r)                   /* compute source scattering into ray */
411		register RAY  *r;
412		{
#	Line 381 | Line 414 | register RAY  *r;
414		int  nsamps;
415		RAY  sr;
416		SRCINDEX  si;
417	<	double  t, lastt, d;
418	<	COLOR  cumval, ctmp;
417	>	double  t, d;
418	>	double  re, ge, be;
419	>	COLOR  cvext;
420		int  i, j;
421
422		if (r->slights == NULL || r->slights[0] == 0
#	Line 397 | Line 431 | register RAY  *r;
431		oldsampndx = samplendx;
432		samplendx = random()&0x7fff;            /* randomize */
433		for (i = r->slights[0]; i > 0; i--) {   /* for each source */
434	<	setcolor(cumval, 0., 0., 0.);
401	<	lastt = r->rot;
402	<	for (j = nsamps; j-- > 0; ) {   /* for each sample position */
434	>	for (j = 0; j < nsamps; j++) {  /* for each sample position */
435		samplendx++;
436		t = r->rot * (j+frandom())/nsamps;
437	+	/* extinction */
438	+	re = t*colval(r->cext,RED);
439	+	ge = t*colval(r->cext,GRN);
440	+	be = t*colval(r->cext,BLU);
441	+	setcolor(cvext, re > 92. ? 0. : exp(-re),
442	+	ge > 92. ? 0. : exp(-ge),
443	+	be > 92. ? 0. : exp(-be));
444	+	if (intens(cvext) <= FTINY)
445	+	break;                  /* too far away */
446		sr.rorg[0] = r->rorg[0] + r->rdir[0]*t;
447		sr.rorg[1] = r->rorg[1] + r->rdir[1]*t;
448		sr.rorg[2] = r->rorg[2] + r->rdir[2]*t;
#	Line 413 | Line 454 | register RAY  *r;
454		sr.rsrc != r->slights[i])
455		continue;               /* no path */
456		copycolor(sr.cext, r->cext);
457	<	sr.albedo = r->albedo;
457	>	copycolor(sr.albedo, r->albedo);
458		sr.gecc = r->gecc;
459	+	sr.slights = r->slights;
460		rayvalue(&sr);                  /* eval. source ray */
461		if (bright(sr.rcol) <= FTINY)
462		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;
463		if (r->gecc <= FTINY)           /* compute P(theta) */
464		d = 1.;
465		else {
466		d = DOT(r->rdir, sr.rdir);
467	<	d = sqrt(1. + r->gecc*r->gecc - 2.*r->gecc*d);
468	<	d = (1. - r->gecc*r->gecc) / (d*d*d);
467	>	d = 1. + r->gecc*r->gecc - 2.*r->gecc*d;
468	>	d = (1. - r->gecc*r->gecc) / (d*sqrt(d));
469		}
470		/* other factors */
471	<	d *= si.dom * r->albedo * r->rot / (4.*PI*nsamps);
471	>	d *= si.dom * r->rot / (4.*PI*nsamps);
472		multcolor(sr.rcol, r->cext);
473	+	multcolor(sr.rcol, r->albedo);
474		scalecolor(sr.rcol, d);
475	<	addcolor(cumval, sr.rcol);
475	>	multcolor(sr.rcol, cvext);
476	>	addcolor(r->rcol, sr.rcol);     /* add it in */
477		}
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 */
478		}
479		samplendx = oldsampndx;
480		}
#	Line 465 | Line 496 | register RAY  *r;
496		* geometry behind (or inside) an effective radiator.
497		*/
498
499	<	static int weaksrcmod(obj) int obj;     /* efficiency booster function */
500	<	{register OBJREC *o = objptr(obj);
501	<	return(o->otype==MAT_ILLUM|o->otype==MAT_GLOW);}
499	>	static int
500	>	weaksrcmat(int obj)             /* identify material */
501	>	{
502	>	register OBJREC *o = objptr(obj);
503	>
504	>	while (!ismaterial(o->otype))   /* find material */
505	>	o = objptr(o->omod);
506	>	return((o->otype==MAT_ILLUM)|(o->otype==MAT_GLOW));
507	>	}
508
509		#define  illumblock(m, r)       (!(source[r->rsrc].sflags&SVIRTUAL) && \
510		r->rod > 0.0 && \
511	<	weaksrcmod(source[r->rsrc].so->omod))
511	>	weaksrcmat(source[r->rsrc].so->omod))
512
513		/* wrongsource *
514		*
#	Line 527 | Line 564 | return(o->otype==MAT_ILLUM|o->otype==MAT_GLOW);}
564		distglow(m, r, raydist(r,PRIMARY)))
565
566
567	+	int
568		m_light(m, r)                   /* ray hit a light source */
569		register OBJREC  *m;
570		register RAY  *r;
#	Line 539 | Line 577 | register RAY  *r;
577		/* check for passed illum */
578		if (passillum(m, r)) {
579		if (m->oargs.nsargs && strcmp(m->oargs.sarg[0], VOIDID))
580	<	return(rayshade(r, modifier(m->oargs.sarg[0])));
580	>	return(rayshade(r,lastmod(objndx(m),m->oargs.sarg[0])));
581		raytrans(r);
582		return(1);
583		}

Diff Legend

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