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.79 by greg, Wed Jun 8 17:18:41 2022 UTC vs.
Revision 2.84 by greg, Fri Nov 15 20:47:42 2024 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 200 | Line 200 | freesources(void)                      /* free all source structures */
200		while (nsources--)
201		freeobscache(&source[nsources]);
202		#endif
203	<	free((void *)source);
203	>	#ifdef SSKIPOPT
204	>	sskip_rsi(NULL);
205	>	#endif
206	>	free(source);
207		source = NULL;
208		nsources = 0;
209		}
210		markclip(NULL);
211		if (maxcntr <= 0)
212		return;
213	<	free((void *)srccnt);
213	>	free(srccnt);
214		srccnt = NULL;
215	<	free((void *)cntord);
215	>	free(cntord);
216		cntord = NULL;
217		maxcntr = 0;
218		}
#	Line 435 | Line 438 | direct(                                        /* add direct component */
438		scp->sno = sr.rsrc;
439		#if SHADCACHE                                   /* check shadow cache */
440		if (si.np == 1 && srcblocked(&sr)) {
441	<	cntord[sn].brt = 0.0;
441	>	cntord[sn].brt = 0.0;   /* & count as test */
442	>	if (source[scp->sno].ntests++ > 0xfffffff0) {
443	>	source[scp->sno].ntests >>= 1;
444	>	source[scp->sno].nhits >>= 1;
445	>	}
446		continue;
447		}
448		#endif
449		/* compute coefficient */
450		(*f)(scp->coef, p, sr.rdir, si.dom);
451	<	cntord[sn].brt = intens(scp->coef);
451	>	cntord[sn].brt = sintens(scp->coef);
452		if (cntord[sn].brt <= 0.0)
453		continue;
454	+	#ifdef SSKIPOPT
455	+	if (ssf_select != NULL && sskip_chk(ssf_select, scp->sno))
456	+	scalescolor(scp->coef, r->scorr);
457	+	#endif
458		VCOPY(scp->dir, sr.rdir);
459	<	copycolor(sr.rcoef, scp->coef);
459	>	copyscolor(sr.rcoef, scp->coef);
460		/* compute potential */
461		sr.revf = srcvalue;
462		rayvalue(&sr);
463	<	multcolor(sr.rcol, sr.rcoef);
464	<	copycolor(scp->val, sr.rcol);
465	<	cntord[sn].brt = bright(sr.rcol);
463	>	smultscolor(sr.rcol, sr.rcoef);
464	>	copyscolor(scp->val, sr.rcol);
465	>	cntord[sn].brt = pbright(sr.rcol);
466		}
467		/* sort contributions */
468		qsort(cntord, sn, sizeof(CNTPTR), cntcmp);
#	Line 486 | Line 497 | direct(                                        /* add direct component */
497		if (sn >= MINSHADCNT &&
498		(sn+nshadcheck>=ncnts ? cntord[sn].brt :
499		cntord[sn].brt-cntord[sn+nshadcheck].brt)
500	<	< ourthresh*bright(r->rcol))
500	>	< ourthresh*pbright(r->rcol))
501		break;
502		scp = srccnt + cntord[sn].sndx;
503		/* test for hit */
504	<	rayorigin(&sr, SHADOW, r, NULL);
505	<	copycolor(sr.rcoef, scp->coef);
504	>	rayorigin(&sr, thrudir(r,scp->dir) ? TSHADOW : RSHADOW, r, NULL);
505	>	copyscolor(sr.rcoef, scp->coef);
506		VCOPY(sr.rdir, scp->dir);
507		sr.rsrc = scp->sno;
508		/* keep statistics */
#	Line 506 | Line 517 | direct(                                        /* add direct component */
517		raycont(&sr);
518		if (trace != NULL)
519		(*trace)(&sr);  /* trace execution */
520	<	if (bright(sr.rcol) <= FTINY) {
520	>	if (scolor_mean(sr.rcol) <= FTINY) {
521		#if SHADCACHE
522		if ((scp <= srccnt || scp[-1].sno != scp->sno)
523		&& (scp >= srccnt+ncnts-1 ||
#	Line 516 | Line 527 | direct(                                        /* add direct component */
527		continue;       /* missed! */
528		}
529		rayparticipate(&sr);
530	<	multcolor(sr.rcol, sr.rcoef);
531	<	copycolor(scp->val, sr.rcol);
530	>	smultscolor(sr.rcol, sr.rcoef);
531	>	copyscolor(scp->val, sr.rcol);
532		} else if (trace != NULL &&
533		(source[scp->sno].sflags & (SDISTANT|SVIRTUAL|SFOLLOW))
534		== (SDISTANT|SFOLLOW) &&
#	Line 526 | Line 537 | direct(                                        /* add direct component */
537		/* skip call to rayparticipate() & scp->val update */
538		}
539		/* add contribution if hit */
540	<	addcolor(r->rcol, scp->val);
540	>	saddscolor(r->rcol, scp->val);
541		nhits++;
542		source[scp->sno].nhits++;
543		}
#	Line 546 | Line 557 | direct(                                        /* add direct component */
557		prob = hwt * (double)source[scp->sno].nhits /
558		(double)source[scp->sno].ntests;
559		if (prob < 1.0)
560	<	scalecolor(scp->val, prob);
561	<	addcolor(r->rcol, scp->val);
560	>	scalescolor(scp->val, prob);
561	>	saddscolor(r->rcol, scp->val);
562		}
563		}
564
#	Line 592 | Line 603 | srcscatter(                    /* compute source scattering into ray */
603		setcolor(cvext, re > 92. ? 0. : exp(-re),
604		ge > 92. ? 0. : exp(-ge),
605		be > 92. ? 0. : exp(-be));
606	<	if (intens(cvext) <= FTINY)
606	>	if (intens(cvext) <= FTINY*FTINY)
607		break;                  /* too far away */
608		sr.rorg[0] = r->rorg[0] + r->rdir[0]*t;
609		sr.rorg[1] = r->rorg[1] + r->rdir[1]*t;
610		sr.rorg[2] = r->rorg[2] + r->rdir[2]*t;
611
612		if (!volumePhotonMapping) {
613	+	if (srcskip(r->slights[i], r))
614	+	continue;
615		initsrcindex(&si);      /* sample ray to this source */
616		si.sn = r->slights[i];
617		nopart(&si, &sr);
#	Line 614 | Line 627 | srcscatter(                    /* compute source scattering into ray */
627		sr.gecc = r->gecc;
628		sr.slights = r->slights;
629		rayvalue(&sr);          /* eval. source ray */
630	<	if (bright(sr.rcol) <= FTINY) {
630	>	if (pbright(sr.rcol) <= FTINY) {
631		#if SHADCACHE
632		srcblocker(&sr); /* add blocker to cache */
633		#endif
#	Line 629 | Line 642 | srcscatter(                    /* compute source scattering into ray */
642		}
643		/* other factors */
644		d *= si.dom * r->rot / (4.*PI*nsamps);
645	<	scalecolor(sr.rcol, d);
645	>	#ifdef SSKIPOPT
646	>	if (ssf_select != NULL && sskip_chk(ssf_select, sr.rsrc))
647	>	d *= r->scorr;
648	>	#endif
649	>	scalescolor(sr.rcol, d);
650		} else {
651		/* PMAP: Add ambient inscattering from
652		* volume photons; note we reverse the
#	Line 640 | Line 657 | srcscatter(                    /* compute source scattering into ray */
657		sr.rdir [2] = -r -> rdir [2];
658		sr.gecc = r -> gecc;
659		inscatterVolumePmap(&sr, sr.rcol);
660	<	scalecolor(sr.rcol, r -> rot / nsamps);
660	>	scalescolor(sr.rcol, r -> rot / nsamps);
661		}
662	<	multcolor(sr.rcol, r->cext);
663	<	multcolor(sr.rcol, r->albedo);
664	<	multcolor(sr.rcol, cvext);
665	<	addcolor(r->rcol, sr.rcol);     /* add it in */
662	>	smultcolor(sr.rcol, r->cext);
663	>	smultcolor(sr.rcol, r->albedo);
664	>	smultcolor(sr.rcol, cvext);
665	>	saddscolor(r->rcol, sr.rcol);   /* add it in */
666		}
667		}
668		samplendx = oldsampndx;
#	Line 746 | Line 763 | m_light(                               /* ray hit a light source */
763		{
764		/* check for over-counting */
765		if (badcomponent(m, r)) {
766	<	setcolor(r->rcoef, 0.0, 0.0, 0.0);
766	>	scolorblack(r->rcoef);
767		return(1);
768		}
769		if (wrongsource(m, r)) {
770	<	setcolor(r->rcoef, 0.0, 0.0, 0.0);
770	>	scolorblack(r->rcoef);
771		return(1);
772		}
773		/* check for passed illum */
#	Line 762 | Line 779 | m_light(                               /* ray hit a light source */
779		}
780		/* check for invisibility */
781		if (srcignore(m, r)) {
782	<	setcolor(r->rcoef, 0.0, 0.0, 0.0);
782	>	scolorblack(r->rcoef);
783		return(1);
784		}
785		/* otherwise treat as source */
#	Line 777 | Line 794 | m_light(                               /* ray hit a light source */
794		/* get distribution pattern */
795		raytexture(r, m->omod);
796		/* get source color */
797	<	setcolor(r->rcol, m->oargs.farg[0],
797	>	setscolor(r->rcol, m->oargs.farg[0],
798		m->oargs.farg[1],
799		m->oargs.farg[2]);
800		/* modify value */
801	<	multcolor(r->rcol, r->pcol);
801	>	smultscolor(r->rcol, r->pcol);
802		return(1);
803		}

Diff Legend

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