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.73 by greg, Fri Jul 3 00:42:20 2020 UTC vs.
Revision 2.86 by greg, Sat Jan 18 03:49:00 2025 UTC

#	Line 27 | Line 27 | static const char RCSid[] = "$Id$";
27		typedef struct {
28		int  sno;               /* source number */
29		FVECT  dir;             /* source direction */
30	<	COLOR  coef;            /* material coefficient */
31	<	COLOR  val;             /* contribution */
30	>	SCOLOR  coef;           /* material coefficient */
31	>	SCOLOR  val;            /* contribution */
32		}  CONTRIB;             /* direct contribution */
33
34		typedef struct {
#	Line 36 | Line 36 | typedef struct {
36		float  brt;             /* brightness (for comparison) */
37		}  CNTPTR;              /* contribution pointer */
38
39	<	static CONTRIB  *srccnt;                /* source contributions in direct() */
40	<	static CNTPTR  *cntord;                 /* source ordering in direct() */
39	>	static CONTRIB  *srccnt = NULL;         /* source contributions in direct() */
40	>	static CNTPTR  *cntord = NULL;          /* source ordering in direct() */
41		static int  maxcntr = 0;                /* size of contribution arrays */
42
43		static int cntcmp(const void *p1, const void *p2);
#	Line 46 | Line 46 | static int cntcmp(const void *p1, const void *p2);
46		void
47		marksources(void)                       /* find and mark source objects */
48		{
49	<	int  foundsource = 0;
49	>	int  indirect = 0;
50		int  i;
51		OBJREC  *o, *m;
52		int  ns;
53	+	/* call us only once! */
54	+	if (nsources)
55	+	error(CONSISTENCY, "Multiple calls to marksources!");
56		/* initialize dispatch table */
57		initstypes();
58		/* find direct sources */
#	Line 60 | Line 63 | marksources(void)                      /* find and mark source objects */
63		if (!issurface(o->otype) || o->omod == OVOID)
64		continue;
65		/* find material */
66	<	m = findmaterial(objptr(o->omod));
66	>	m = findmaterial(o);
67		if (m == NULL)
68		continue;
69		if (m->otype == MAT_CLIP) {
#	Line 80 | Line 83 | marksources(void)                      /* find and mark source objects */
83		if (m->otype == MAT_GLOW &&
84		o->otype != OBJ_SOURCE &&
85		m->oargs.farg[3] <= FTINY) {
86	<	foundsource += (ambounce > 0);
86	>	indirect += (ambounce > 0);
87		continue;                       /* don't track these */
88		}
89		if (sfun[o->otype].of == NULL ||
#	Line 97 | Line 100 | marksources(void)                      /* find and mark source objects */
100		source[ns].sl.prox = m->oargs.farg[3];
101		if (source[ns].sflags & SDISTANT) {
102		source[ns].sflags |= SSKIP;
103	<	foundsource += (ambounce > 0);
103	>	indirect += (ambounce > 0);
104		}
105		} else if (m->otype == MAT_SPOT) {
106		if (source[ns].sflags & SDISTANT)
#	Line 113 | Line 116 | marksources(void)                      /* find and mark source objects */
116		source[ns].sflags |= SSKIP;
117		}
118		}
119	<	foundsource += !(source[ns].sflags & SSKIP);
119	>	maxcntr += !(source[ns].sflags & SSKIP);
120		}
121	<	if (!foundsource) {
122	<	error(WARNING, "no light sources found");
123	<	return;
121	>	if (!maxcntr) {
122	>	if (!indirect)
123	>	error(WARNING, "no light sources found");
124	>	return;         /* no direct calculation, it seems */
125		}
126		#if  SHADCACHE
127		for (ns = 0; ns < nsources; ns++)       /* initialize obstructor cache */
#	Line 128 | Line 132 | marksources(void)                      /* find and mark source objects */
132		markvirtuals();                 /* find and add virtual sources */
133
134		/* allocate our contribution arrays */
135	<	maxcntr = nsources + MAXSPART;  /* start with this many */
135	>	maxcntr += MAXSPART;    /* start with this many */
136		srccnt = (CONTRIB *)malloc(maxcntr*sizeof(CONTRIB));
137		cntord = (CNTPTR *)malloc(maxcntr*sizeof(CNTPTR));
138		if ((srccnt != NULL) & (cntord != NULL))
#	Line 144 | Line 148 | distantsources(void)                   /* only mark distant sources */
148		int  i;
149		OBJREC  *o, *m;
150		int  ns;
151	+	/* call us only once! */
152	+	if (nsources)
153	+	error(CONSISTENCY, "Multiple calls to distantsources!");
154		/* initialize dispatch table */
155		initstypes();
156		/* sources needed for sourcehit() */
#	Line 154 | Line 161 | distantsources(void)                   /* only mark distant sources */
161		if ((o->otype != OBJ_SOURCE) | (o->omod == OVOID))
162		continue;
163		/* find material */
164	<	m = findmaterial(objptr(o->omod));
164	>	m = findmaterial(o);
165		if (m == NULL)
166		continue;
167		if (!islight(m->otype))
#	Line 193 | Line 200 | freesources(void)                      /* free all source structures */
200		while (nsources--)
201		freeobscache(&source[nsources]);
202		#endif
203	<	free((void *)source);
203	>	free(source);
204		source = NULL;
205		nsources = 0;
206		}
207		markclip(NULL);
208		if (maxcntr <= 0)
209		return;
210	<	free((void *)srccnt);
210	>	free(srccnt);
211		srccnt = NULL;
212	<	free((void *)cntord);
212	>	free(cntord);
213		cntord = NULL;
214		maxcntr = 0;
215		}
216
217
218		int
219	<	srcray(                         /* send a ray to a source, return domega */
220	<	RAY  *sr,               /* returned source ray */
221	<	RAY  *r,                        /* ray which hit object */
219	>	srcray(                         /* aim a ray at a source, return domega */
220	>	RAY  *sr,               /* prepared source ray */
221	>	RAY  *r,                        /* originating ray (or NULL) */
222		SRCINDEX  *si                   /* source sample index */
223		)
224		{
#	Line 224 | Line 231 | srcray(                                /* send a ray to a source, return domega */
231		sr->rmax = 0.0;
232
233		while ((d = nextssamp(sr, si)) != 0.0) {
234	<	sr->rsrc = si->sn;                      /* remember source */
234	>	sr->rsrc = si->sn;              /* remember source */
235		srcp = source + si->sn;
236		if (srcp->sflags & SDISTANT) {
237		if (srcp->sflags & SSPOT && spotout(sr, srcp->sl.s))
#	Line 294 | Line 301 | nomat:
301
302		static int
303		transillum(                     /* check if material is transparent illum */
304	<	OBJECT  obj
304	>	OBJREC *m
305		)
306		{
307	<	OBJREC *m = findmaterial(objptr(obj));
301	<
307	>	m = findmaterial(m);
308		if (m == NULL)
309		return(1);
310		if (m->otype != MAT_ILLUM)
#	Line 331 | Line 337 | sourcehit(                     /* check to see if ray hit distant source
337		*/
338		if (2.*PI*(1. - DOT(source[i].sloc,r->rdir)) > source[i].ss2)
339		continue;
340	<	/* is it the only possibility? */
341	<	if (first == last) {
340	>	/* is it what we aimed for? */
341	>	if (i == r->rsrc) {
342		r->ro = source[i].so;
343		break;
344		}
#	Line 344 | Line 350 | sourcehit(                     /* check to see if ray hit distant source
350		glowsrc = i;
351		continue;
352		}
353	<	if (transillum(source[i].so->omod)) {
353	>	if (transillum(source[i].so)) {
354		if (transrc < 0)
355		transrc = i;
356		continue;
#	Line 364 | Line 370 | sourcehit(                     /* check to see if ray hit distant source
370		return(0);      /* nothing usable */
371		}
372		/*
373	<	* Make assignments.
373	>	* Assign object index
374		*/
375		r->robj = objndx(r->ro);
370	–	for (i = 0; i < 3; i++)
371	–	r->ron[i] = -r->rdir[i];
372	–	r->rod = 1.0;
373	–	r->pert[0] = r->pert[1] = r->pert[2] = 0.0;
374	–	r->uv[0] = r->uv[1] = 0.0;
375	–	r->rox = NULL;
376		return(1);
377		}
378
#	Line 415 | Line 415 | direct(                                        /* add direct component */
415		multDirectPmap(r);
416		return;
417		}
418	–
418		/* NOTE: srccnt and cntord global so no recursion */
419	<	if (nsources <= 0)
420	<	return;         /* no sources?! */
421	<	/* potential contributions */
422	<	initsrcindex(&si);
419	>	if (maxcntr <= 0)
420	>	return;         /* no direct?! */
421	>
422	>	initsrcindex(&si);                      /* potential contributions */
423		for (sn = 0; srcray(&sr, r, &si); sn++) {
424		if (sn >= maxcntr) {
425		maxcntr = sn + MAXSPART;
#	Line 436 | Line 435 | direct(                                        /* add direct component */
435		scp->sno = sr.rsrc;
436		#if SHADCACHE                                   /* check shadow cache */
437		if (si.np == 1 && srcblocked(&sr)) {
438	<	cntord[sn].brt = 0.0;
438	>	cntord[sn].brt = 0.0;   /* & count as test */
439	>	if (source[scp->sno].ntests++ > 0xfffffff0) {
440	>	source[scp->sno].ntests >>= 1;
441	>	source[scp->sno].nhits >>= 1;
442	>	}
443		continue;
444		}
445		#endif
446		/* compute coefficient */
447		(*f)(scp->coef, p, sr.rdir, si.dom);
448	<	cntord[sn].brt = intens(scp->coef);
448	>	cntord[sn].brt = sintens(scp->coef);
449		if (cntord[sn].brt <= 0.0)
450		continue;
451		VCOPY(scp->dir, sr.rdir);
452	<	copycolor(sr.rcoef, scp->coef);
452	>	copyscolor(sr.rcoef, scp->coef);
453		/* compute potential */
454		sr.revf = srcvalue;
455		rayvalue(&sr);
456	<	multcolor(sr.rcol, sr.rcoef);
457	<	copycolor(scp->val, sr.rcol);
458	<	cntord[sn].brt = bright(sr.rcol);
456	>	smultscolor(sr.rcol, sr.rcoef);
457	>	copyscolor(scp->val, sr.rcol);
458	>	cntord[sn].brt = pbright(sr.rcol);
459		}
460		/* sort contributions */
461		qsort(cntord, sn, sizeof(CNTPTR), cntcmp);
#	Line 477 | Line 480 | direct(                                        /* add direct component */
480		/* compute number to check */
481		nshadcheck = pow((double)ncnts, shadcert) + .5;
482		/* modify threshold */
483	<	if (ncnts > MINSHADCNT)
481	<	ourthresh = shadthresh / r->rweight;
482	<	else
483	<	ourthresh = 0;
483	>	ourthresh = shadthresh / r->rweight;
484		/* test for shadows */
485		for (nhits = 0, hwt = 0.0, sn = 0; sn < ncnts;
486		hwt += (double)source[scp->sno].nhits /
487		(double)source[scp->sno].ntests,
488		sn++) {
489		/* check threshold */
490	<	if ((sn+nshadcheck>=ncnts ? cntord[sn].brt :
490	>	if (sn >= MINSHADCNT &&
491	>	(sn+nshadcheck>=ncnts ? cntord[sn].brt :
492		cntord[sn].brt-cntord[sn+nshadcheck].brt)
493	<	< ourthresh*bright(r->rcol))
493	>	< ourthresh*pbright(r->rcol))
494		break;
495		scp = srccnt + cntord[sn].sndx;
496		/* test for hit */
497	<	rayorigin(&sr, SHADOW, r, NULL);
498	<	copycolor(sr.rcoef, scp->coef);
497	>	rayorigin(&sr, thrudir(r,scp->dir) ? TSHADOW : RSHADOW, r, NULL);
498	>	copyscolor(sr.rcoef, scp->coef);
499		VCOPY(sr.rdir, scp->dir);
500		sr.rsrc = scp->sno;
501		/* keep statistics */
#	Line 509 | Line 510 | direct(                                        /* add direct component */
510		raycont(&sr);
511		if (trace != NULL)
512		(*trace)(&sr);  /* trace execution */
513	<	if (bright(sr.rcol) <= FTINY) {
513	>	if (scolor_mean(sr.rcol) <= FTINY) {
514		#if SHADCACHE
515		if ((scp <= srccnt || scp[-1].sno != scp->sno)
516		&& (scp >= srccnt+ncnts-1 ||
#	Line 519 | Line 520 | direct(                                        /* add direct component */
520		continue;       /* missed! */
521		}
522		rayparticipate(&sr);
523	<	multcolor(sr.rcol, sr.rcoef);
524	<	copycolor(scp->val, sr.rcol);
523	>	smultscolor(sr.rcol, sr.rcoef);
524	>	copyscolor(scp->val, sr.rcol);
525		} else if (trace != NULL &&
526		(source[scp->sno].sflags & (SDISTANT|SVIRTUAL|SFOLLOW))
527		== (SDISTANT|SFOLLOW) &&
#	Line 529 | Line 530 | direct(                                        /* add direct component */
530		/* skip call to rayparticipate() & scp->val update */
531		}
532		/* add contribution if hit */
533	<	addcolor(r->rcol, scp->val);
533	>	saddscolor(r->rcol, scp->val);
534		nhits++;
535		source[scp->sno].nhits++;
536		}
#	Line 549 | Line 550 | direct(                                        /* add direct component */
550		prob = hwt * (double)source[scp->sno].nhits /
551		(double)source[scp->sno].ntests;
552		if (prob < 1.0)
553	<	scalecolor(scp->val, prob);
554	<	addcolor(r->rcol, scp->val);
553	>	scalescolor(scp->val, prob);
554	>	saddscolor(r->rcol, scp->val);
555		}
556		}
557
#	Line 595 | Line 596 | srcscatter(                    /* compute source scattering into ray */
596		setcolor(cvext, re > 92. ? 0. : exp(-re),
597		ge > 92. ? 0. : exp(-ge),
598		be > 92. ? 0. : exp(-be));
599	<	if (intens(cvext) <= FTINY)
599	>	if (intens(cvext) <= FTINY*FTINY)
600		break;                  /* too far away */
601		sr.rorg[0] = r->rorg[0] + r->rdir[0]*t;
602		sr.rorg[1] = r->rorg[1] + r->rdir[1]*t;
603		sr.rorg[2] = r->rorg[2] + r->rdir[2]*t;
604
605		if (!volumePhotonMapping) {
606	+	sr.parent = r;          /* hack for preemptive test */
607	+	if (srcskip(r->slights[i], &sr))
608	+	continue;
609		initsrcindex(&si);      /* sample ray to this source */
610		si.sn = r->slights[i];
611		nopart(&si, &sr);
#	Line 617 | Line 621 | srcscatter(                    /* compute source scattering into ray */
621		sr.gecc = r->gecc;
622		sr.slights = r->slights;
623		rayvalue(&sr);          /* eval. source ray */
624	<	if (bright(sr.rcol) <= FTINY) {
624	>	if (pbright(sr.rcol) <= FTINY) {
625		#if SHADCACHE
626		srcblocker(&sr); /* add blocker to cache */
627		#endif
#	Line 632 | Line 636 | srcscatter(                    /* compute source scattering into ray */
636		}
637		/* other factors */
638		d *= si.dom * r->rot / (4.*PI*nsamps);
639	<	scalecolor(sr.rcol, d);
639	>	scalescolor(sr.rcol, d);
640		} else {
641		/* PMAP: Add ambient inscattering from
642		* volume photons; note we reverse the
#	Line 643 | Line 647 | srcscatter(                    /* compute source scattering into ray */
647		sr.rdir [2] = -r -> rdir [2];
648		sr.gecc = r -> gecc;
649		inscatterVolumePmap(&sr, sr.rcol);
650	<	scalecolor(sr.rcol, r -> rot / nsamps);
650	>	scalescolor(sr.rcol, r -> rot / nsamps);
651		}
652	<	multcolor(sr.rcol, r->cext);
653	<	multcolor(sr.rcol, r->albedo);
654	<	multcolor(sr.rcol, cvext);
655	<	addcolor(r->rcol, sr.rcol);     /* add it in */
652	>	smultcolor(sr.rcol, r->cext);
653	>	smultcolor(sr.rcol, r->albedo);
654	>	smultcolor(sr.rcol, cvext);
655	>	saddscolor(r->rcol, sr.rcol);   /* add it in */
656		}
657		}
658		samplendx = oldsampndx;
#	Line 672 | Line 676 | srcscatter(                    /* compute source scattering into ray */
676		*/
677
678		static int
679	<	weaksrcmat(OBJECT obj)          /* identify material */
679	>	weaksrcmat(OBJREC *m)           /* identify material */
680		{
681	<	OBJREC *m = findmaterial(objptr(obj));
678	<
681	>	m = findmaterial(m);
682		if (m == NULL) return(0);
683		return((m->otype==MAT_ILLUM) | (m->otype==MAT_GLOW));
684		}
685
686		#define  illumblock(m, r)       (!(source[r->rsrc].sflags&SVIRTUAL) && \
687		r->rod > 0.0 && \
688	<	weaksrcmat(source[r->rsrc].so->omod))
688	>	weaksrcmat(source[r->rsrc].so))
689
690		/* wrongsource *
691		*
#	Line 750 | Line 753 | m_light(                               /* ray hit a light source */
753		{
754		/* check for over-counting */
755		if (badcomponent(m, r)) {
756	<	setcolor(r->rcoef, 0.0, 0.0, 0.0);
756	>	scolorblack(r->rcoef);
757		return(1);
758		}
759		if (wrongsource(m, r)) {
760	<	setcolor(r->rcoef, 0.0, 0.0, 0.0);
760	>	scolorblack(r->rcoef);
761		return(1);
762		}
763		/* check for passed illum */
#	Line 766 | Line 769 | m_light(                               /* ray hit a light source */
769		}
770		/* check for invisibility */
771		if (srcignore(m, r)) {
772	<	setcolor(r->rcoef, 0.0, 0.0, 0.0);
772	>	scolorblack(r->rcoef);
773		return(1);
774		}
775		/* otherwise treat as source */
776	<	/* check for behind */
777	<	if (r->rod < 0.0)
776	>	if (r->rod < 0.0) {                     /* check for behind */
777	>	if (!backvis)
778	>	raytrans(r);            /* used to return black */
779		return(1);
780	+	}
781		/* check for outside spot */
782		if (m->otype==MAT_SPOT && spotout(r, makespot(m)))
783		return(1);
784		/* get distribution pattern */
785		raytexture(r, m->omod);
786		/* get source color */
787	<	setcolor(r->rcol, m->oargs.farg[0],
787	>	setscolor(r->rcol, m->oargs.farg[0],
788		m->oargs.farg[1],
789		m->oargs.farg[2]);
790		/* modify value */
791	<	multcolor(r->rcol, r->pcol);
791	>	smultscolor(r->rcol, r->pcol);
792		return(1);
793		}

Diff Legend

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