ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/rt/m_bsdf.c

Comparing ray/src/rt/m_bsdf.c (file contents):
Revision 2.49 by greg, Sat May 12 02:32:10 2018 UTC vs.
Revision 2.60 by greg, Wed Jun 10 16:00:32 2020 UTC

#	Line 8 | Line 8 | static const char RCSid[] = "$Id$";
8		#include "copyright.h"
9
10		#include  "ray.h"
11	+	#include  "otypes.h"
12		#include  "ambient.h"
13		#include  "source.h"
14		#include  "func.h"
#	Line 16 | Line 17 | static const char RCSid[] = "$Id$";
17		#include  "pmapmat.h"
18
19		/*
20	<	*      Arguments to this material include optional diffuse colors.
20	>	*     Arguments to this material include optional diffuse colors.
21		*  String arguments include the BSDF and function files.
22	<	*      A non-zero thickness causes the strange but useful behavior
22	>	*      For the MAT_BSDF type, a non-zero thickness causes the useful behavior
23		*  of translating transmitted rays this distance beneath the surface
24		*  (opposite the surface normal) to bypass any intervening geometry.
25		*  Translation only affects scattered, non-source-directed samples.
#	Line 35 | Line 36 | static const char RCSid[] = "$Id$";
36		*  hides geometry in front of the surface when rays hit from behind,
37		*  and applies only the transmission and backside reflectance properties.
38		*  Reflection is ignored on the hidden side, as those rays pass through.
39	<	*      When thickness is set to zero, shadow rays will be blocked unless
40	<	*  a BTDF has a strong "through" component in the source direction.
39	>	*      For the MAT_ABSDF type, we check for a strong "through" component.
40	>	*  Such a component will cause direct rays to pass through unscattered.
41		*  A separate test prevents over-counting by dropping samples that are
42		*  too close to this "through" direction.  BSDFs with such a through direction
43		*  will also have a view component, meaning they are somewhat see-through.
44	+	*  A MAT_BSDF type with zero thickness behaves the same as a MAT_ABSDF
45	+	*  type with no strong through component.
46		*      The "up" vector for the BSDF is given by three variables, defined
47		*  (along with the thickness) by the named function file, or '.' if none.
48		*  Together with the surface normal, this defines the local coordinate
#	Line 52 | Line 55 | static const char RCSid[] = "$Id$";
55		*  not multiplied.  However, patterns affect this material as a multiplier
56		*  on everything except non-diffuse reflection.
57		*
58	+	*  Arguments for MAT_ABSDF are:
59	+	*      5+      BSDFfile        ux uy uz        funcfile        transform
60	+	*      0
61	+	*      0|3|6|9 rdf     gdf     bdf
62	+	*              rdb     gdb     bdb
63	+	*              rdt     gdt     bdt
64	+	*
65		*  Arguments for MAT_BSDF are:
66		*      6+      thick   BSDFfile        ux uy uz        funcfile        transform
67		*      0
#	Line 76 | Line 86 | typedef struct {
86		RREAL   toloc[3][3];    /* world to local BSDF coords */
87		RREAL   fromloc[3][3];  /* local BSDF coords to world */
88		double  thick;          /* surface thickness */
89	<	COLOR   cthru;          /* "through" component multiplier */
89	>	COLOR   cthru;          /* "through" component for MAT_ABSDF */
90		SDData  *sd;            /* loaded BSDF data */
91		COLOR   rdiff;          /* diffuse reflection */
92		COLOR   runsamp;        /* BSDF hemispherical reflection */
#	Line 86 | Line 96 | typedef struct {
96
97		#define cvt_sdcolor(cv, svp)    ccy2rgb(&(svp)->spec, (svp)->cieY, cv)
98
99	<	/* Compute "through" component color */
99	>	typedef struct {
100	>	double  vy;             /* brightness (for sorting) */
101	>	FVECT   tdir;           /* through sample direction (normalized) */
102	>	COLOR   vcol;           /* BTDF color */
103	>	}  PEAKSAMP;            /* BTDF peak sample */
104	>
105	>	/* Comparison function to put near-peak values in descending order */
106	>	static int
107	>	cmp_psamp(const void *p1, const void *p2)
108	>	{
109	>	double  diff = (*(const PEAKSAMP *)p1).vy - (*(const PEAKSAMP *)p2).vy;
110	>	if (diff > 0) return(-1);
111	>	if (diff < 0) return(1);
112	>	return(0);
113	>	}
114	>
115	>	/* Compute "through" component color for MAT_ABSDF */
116		static void
117		compute_through(BSDFDAT *ndp)
118		{
119	<	#define NDIR2CHECK      13
119	>	#define NDIR2CHECK      29
120		static const float      dir2check[NDIR2CHECK][2] = {
121	<	{0, 0},
122	<	{-0.8, 0},
123	<	{0, 0.8},
124	<	{0, -0.8},
125	<	{0.8, 0},
126	<	{-0.8, 0.8},
127	<	{-0.8, -0.8},
128	<	{0.8, 0.8},
129	<	{0.8, -0.8},
130	<	{-1.6, 0},
105	<	{0, 1.6},
106	<	{0, -1.6},
107	<	{1.6, 0},
121	>	{0, 0}, {-0.6, 0}, {0, 0.6},
122	>	{0, -0.6}, {0.6, 0}, {-0.6, 0.6},
123	>	{-0.6, -0.6}, {0.6, 0.6}, {0.6, -0.6},
124	>	{-1.2, 0}, {0, 1.2}, {0, -1.2},
125	>	{1.2, 0}, {-1.2, 1.2}, {-1.2, -1.2},
126	>	{1.2, 1.2}, {1.2, -1.2}, {-1.8, 0},
127	>	{0, 1.8}, {0, -1.8}, {1.8, 0},
128	>	{-1.8, 1.8}, {-1.8, -1.8}, {1.8, 1.8},
129	>	{1.8, -1.8}, {-2.4, 0}, {0, 2.4},
130	>	{0, -2.4}, {2.4, 0},
131		};
132		const double    peak_over = 1.5;
133	+	PEAKSAMP        psamp[NDIR2CHECK];
134		SDSpectralDF    *dfp;
135		FVECT           pdir;
136		double          tomega, srchrad;
137	<	COLOR           vpeak, vsum;
138	<	int             i;
137	>	double          tomsum;
138	>	COLOR           vpeak;
139	>	double          vypeak, vysum;
140	>	int             i, ns, ntot;
141		SDError         ec;
142
117	–	setcolor(ndp->cthru, 0, 0, 0);          /* starting assumption */
118	–
143		if (ndp->pr->rod > 0)
144		dfp = (ndp->sd->tf != NULL) ? ndp->sd->tf : ndp->sd->tb;
145		else
#	Line 125 | Line 149 | compute_through(BSDFDAT *ndp)
149		return;                         /* no specular transmission */
150		if (bright(ndp->pr->pcol) <= FTINY)
151		return;                         /* pattern is black, here */
152	<	srchrad = sqrt(dfp->minProjSA);         /* else search for peak */
153	<	setcolor(vpeak, 0, 0, 0);
130	<	setcolor(vsum, 0, 0, 0);
131	<	pdir[2] = 0.0;
152	>	srchrad = sqrt(dfp->minProjSA);         /* else evaluate peak */
153	>	vysum = 0;
154		for (i = 0; i < NDIR2CHECK; i++) {
133	–	FVECT   tdir;
155		SDValue sv;
156	<	COLOR   vcol;
157	<	tdir[0] = -ndp->vray[0] + dir2check[i][0]*srchrad;
158	<	tdir[1] = -ndp->vray[1] + dir2check[i][1]*srchrad;
159	<	tdir[2] = -ndp->vray[2];
160	<	normalize(tdir);
140	<	ec = SDevalBSDF(&sv, tdir, ndp->vray, ndp->sd);
156	>	psamp[i].tdir[0] = -ndp->vray[0] + dir2check[i][0]*srchrad;
157	>	psamp[i].tdir[1] = -ndp->vray[1] + dir2check[i][1]*srchrad;
158	>	psamp[i].tdir[2] = -ndp->vray[2];
159	>	normalize(psamp[i].tdir);
160	>	ec = SDevalBSDF(&sv, psamp[i].tdir, ndp->vray, ndp->sd);
161		if (ec)
162		goto baderror;
163	<	cvt_sdcolor(vcol, &sv);
164	<	addcolor(vsum, vcol);
165	<	if (sv.cieY > bright(vpeak)) {
166	<	copycolor(vpeak, vcol);
167	<	VCOPY(pdir, tdir);
163	>	cvt_sdcolor(psamp[i].vcol, &sv);
164	>	vysum += psamp[i].vy = sv.cieY;
165	>	}
166	>	if (vysum <= FTINY)                     /* zero neighborhood? */
167	>	return;
168	>	qsort(psamp, NDIR2CHECK, sizeof(PEAKSAMP), cmp_psamp);
169	>	setcolor(vpeak, 0, 0, 0);
170	>	vypeak = tomsum = 0;                    /* combine top unique values */
171	>	ns = 0; ntot = NDIR2CHECK;
172	>	for (i = 0; i < NDIR2CHECK; i++) {
173	>	if (i) {
174	>	if (psamp[i].vy == psamp[i-1].vy) {
175	>	vysum -= psamp[i].vy;
176	>	--ntot;
177	>	continue;       /* assume duplicate sample */
178	>	}
179	>	if (vypeak > 8.*psamp[i].vy*ns)
180	>	continue;       /* peak cut-off */
181		}
182	+	ec = SDsizeBSDF(&tomega, psamp[i].tdir, ndp->vray,
183	+	SDqueryMin, ndp->sd);
184	+	if (ec)
185	+	goto baderror;
186	+	if (tomega > 1.5*dfp->minProjSA) {
187	+	if (!i) return;         /* not really a peak? */
188	+	continue;
189	+	}
190	+	scalecolor(psamp[i].vcol, tomega);
191	+	addcolor(vpeak, psamp[i].vcol);
192	+	tomsum += tomega;
193	+	vypeak += psamp[i].vy;
194	+	++ns;
195		}
196	<	if (pdir[2] == 0.0)
197	<	return;                         /* zero neighborhood */
198	<	ec = SDsizeBSDF(&tomega, pdir, ndp->vray, SDqueryMin, ndp->sd);
153	<	if (ec)
154	<	goto baderror;
155	<	if (tomega > 1.5*dfp->minProjSA)
156	<	return;                         /* not really a peak? */
157	<	tomega /= fabs(pdir[2]);                /* remove cosine factor */
158	<	if ((bright(vpeak) - ndp->sd->tLamb.cieY*(1./PI))*tomega <= .001)
196	>	if (vypeak*(ntot-ns) < peak_over*(vysum-vypeak)*ns)
197	>	return;                         /* peak not peaky enough */
198	>	if ((vypeak/ns - ndp->sd->tLamb.cieY*(1./PI))*tomsum <= .001)
199		return;                         /* < 0.1% transmission */
200	<	for (i = 3; i--; )                      /* remove peak from average */
161	<	colval(vsum,i) -= colval(vpeak,i);
162	<	if (peak_over*bright(vsum) >= (NDIR2CHECK-1)*bright(vpeak))
163	<	return;                         /* not peaky enough */
164	<	copycolor(ndp->cthru, vpeak);           /* else use it */
165	<	scalecolor(ndp->cthru, tomega);
200	>	copycolor(ndp->cthru, vpeak);           /* already scaled by omega */
201		multcolor(ndp->cthru, ndp->pr->pcol);   /* modify by pattern */
202		return;
203		baderror:
#	Line 228 | Line 263 | direct_specular_OK(COLOR cval, FVECT ldir, double omeg
263		diffY = 0;
264		setcolor(cdiff,  0, 0, 0);
265		}
266	<	/* need projected solid angles */
266	>	/* need projected solid angle */
267		omega *= fabs(vsrc[2]);
233	–	ec = SDsizeBSDF(&tomega, ndp->vray, vsrc, SDqueryMin, ndp->sd);
234	–	if (ec)
235	–	goto baderror;
268		/* check indirect over-counting */
269		if ((vsrc[2] > 0) ^ (ndp->vray[2] > 0) && bright(ndp->cthru) > FTINY) {
270	<	double  dx = vsrc[0] + ndp->vray[0];
271	<	double  dy = vsrc[1] + ndp->vray[1];
272	<	if (dx*dx + dy*dy <= (1.5*4./PI)*(omega + tomega +
273	<	2.*sqrt(omega*tomega)))
270	>	double          dx = vsrc[0] + ndp->vray[0];
271	>	double          dy = vsrc[1] + ndp->vray[1];
272	>	SDSpectralDF    *dfp = (ndp->pr->rod > 0) ?
273	>	((ndp->sd->tf != NULL) ? ndp->sd->tf : ndp->sd->tb) :
274	>	((ndp->sd->tb != NULL) ? ndp->sd->tb : ndp->sd->tf) ;
275	>
276	>	if (dx*dx + dy*dy <= (2.5*4./PI)*(omega + dfp->minProjSA +
277	>	2.*sqrt(omega*dfp->minProjSA)))
278		return(0);
279		}
280	+	ec = SDsizeBSDF(&tomega, ndp->vray, vsrc, SDqueryMin, ndp->sd);
281	+	if (ec)
282	+	goto baderror;
283		/* assign number of samples */
284		sf = specjitter * ndp->pr->rweight;
285		if (tomega <= 0)
#	Line 274 | Line 313 | direct_specular_OK(COLOR cval, FVECT ldir, double omeg
313		if (tomega2 < .12*tomega)
314		continue;       /* not safe to include */
315		cvt_sdcolor(csmp, &sv);
316	<
317	<	if (sf < 2.5*tsr) {     /* weight by Y for small sources */
316	>	#if 0
317	>	if (sf < 2.5*tsr) {     /* weight by BSDF for small sources */
318		scalecolor(csmp, sv.cieY);
319		wtot += sv.cieY;
320		} else
321	<	wtot += 1.;
321	>	#endif
322	>	wtot += 1.;
323		addcolor(cval, csmp);
324		}
325		if (wtot <= FTINY)              /* no valid specular samples? */
#	Line 544 | Line 584 | sample_sdf(BSDFDAT *ndp, int sflags)
584		rayvalue(&tr);
585		multcolor(tr.rcol, tr.rcoef);
586		addcolor(ndp->pr->rcol, tr.rcol);
587	+	ndp->pr->rxt = ndp->pr->rot + raydistance(&tr);
588		++ntotal;
589		b = bright(ndp->cthru);
590		} else
#	Line 581 | Line 622 | sample_sdf(BSDFDAT *ndp, int sflags)
622		int
623		m_bsdf(OBJREC *m, RAY *r)
624		{
625	+	int     hasthick = (m->otype == MAT_BSDF);
626		int     hitfront;
627		COLOR   ctmp;
628		SDError ec;
#	Line 588 | Line 630 | m_bsdf(OBJREC *m, RAY *r)
630		MFUNC   *mf;
631		BSDFDAT nd;
632		/* check arguments */
633	<	if ((m->oargs.nsargs < 6) | (m->oargs.nfargs > 9) |
633	>	if ((m->oargs.nsargs < hasthick+5) | (m->oargs.nfargs > 9) |
634		(m->oargs.nfargs % 3))
635		objerror(m, USER, "bad # arguments");
636		/* record surface struck */
637		hitfront = (r->rod > 0);
638		/* load cal file */
639	<	mf = getfunc(m, 5, 0x1d, 1);
639	>	mf = hasthick   ? getfunc(m, 5, 0x1d, 1)
640	>	: getfunc(m, 4, 0xe, 1) ;
641		setfunc(m, r);
642	<	/* get thickness */
643	<	nd.thick = evalue(mf->ep[0]);
644	<	if ((-FTINY <= nd.thick) & (nd.thick <= FTINY))
645	<	nd.thick = 0;
642	>	nd.thick = 0;                           /* set thickness */
643	>	if (hasthick) {
644	>	nd.thick = evalue(mf->ep[0]);
645	>	if ((-FTINY <= nd.thick) & (nd.thick <= FTINY))
646	>	nd.thick = 0;
647	>	}
648		/* check backface visibility */
649		if (!hitfront & !backvis) {
650		raytrans(r);
#	Line 612 | Line 657 | m_bsdf(OBJREC *m, RAY *r)
657		raytrans(r);                    /* hide our proxy */
658		return(1);
659		}
660	+	if (hasthick && r->crtype & SHADOW)     /* early shadow check #1 */
661	+	return(1);
662		nd.mp = m;
663		nd.pr = r;
664		/* get BSDF data */
665	<	nd.sd = loadBSDF(m->oargs.sarg[1]);
666	<	/* early shadow check */
667	<	if (r->crtype & SHADOW && (nd.sd->tf == NULL) & (nd.sd->tb == NULL))
665	>	nd.sd = loadBSDF(m->oargs.sarg[hasthick]);
666	>	/* early shadow check #2 */
667	>	if (r->crtype & SHADOW && (nd.sd->tf == NULL) & (nd.sd->tb == NULL)) {
668	>	SDfreeCache(nd.sd);
669		return(1);
670	+	}
671		/* diffuse reflectance */
672		if (hitfront) {
673		cvt_sdcolor(nd.rdiff, &nd.sd->rLambFront);
#	Line 651 | Line 700 | m_bsdf(OBJREC *m, RAY *r)
700		multcolor(nd.rdiff, r->pcol);
701		multcolor(nd.tdiff, r->pcol);
702		/* get up vector */
703	<	upvec[0] = evalue(mf->ep[1]);
704	<	upvec[1] = evalue(mf->ep[2]);
705	<	upvec[2] = evalue(mf->ep[3]);
703	>	upvec[0] = evalue(mf->ep[hasthick+0]);
704	>	upvec[1] = evalue(mf->ep[hasthick+1]);
705	>	upvec[2] = evalue(mf->ep[hasthick+2]);
706		/* return to world coords */
707		if (mf->fxp != &unitxf) {
708		multv3(upvec, upvec, mf->fxp->xfm);
#	Line 674 | Line 723 | m_bsdf(OBJREC *m, RAY *r)
723		}
724		if (ec) {
725		objerror(m, WARNING, "Illegal orientation vector");
726	+	SDfreeCache(nd.sd);
727		return(1);
728		}
729	<	compute_through(&nd);                   /* compute through component */
730	<	if (r->crtype & SHADOW) {
731	<	RAY     tr;                     /* attempt to pass shadow ray */
732	<	if (rayorigin(&tr, TRANS, r, nd.cthru) < 0)
733	<	return(1);              /* no through component */
734	<	VCOPY(tr.rdir, r->rdir);
735	<	rayvalue(&tr);                  /* transmit with scaling */
736	<	multcolor(tr.rcol, tr.rcoef);
737	<	copycolor(r->rcol, tr.rcol);
738	<	return(1);                      /* we're done */
729	>	setcolor(nd.cthru, 0, 0, 0);            /* consider through component */
730	>	if (m->otype == MAT_ABSDF) {
731	>	compute_through(&nd);
732	>	if (r->crtype & SHADOW) {
733	>	RAY     tr;             /* attempt to pass shadow ray */
734	>	SDfreeCache(nd.sd);
735	>	if (rayorigin(&tr, TRANS, r, nd.cthru) < 0)
736	>	return(1);      /* no through component */
737	>	VCOPY(tr.rdir, r->rdir);
738	>	rayvalue(&tr);          /* transmit with scaling */
739	>	multcolor(tr.rcol, tr.rcoef);
740	>	copycolor(r->rcol, tr.rcol);
741	>	return(1);              /* we're done */
742	>	}
743		}
744		ec = SDinvXform(nd.fromloc, nd.toloc);
745		if (!ec)                                /* determine BSDF resolution */

Diff Legend

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