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.14 by greg, Sun Aug 21 22:38:12 2011 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"
15		#include  "bsdf.h"
16		#include  "random.h"
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.
26		*  A non-zero thickness has the further side-effect that an unscattered
27	<	*  (view) ray will pass right through our material if it has any
28	<	*  non-diffuse transmission, making the BSDF surface invisible.  This
29	<	*  shows the proxied geometry instead. Thickness has the further
30	<	*  effect of turning off reflection on the hidden side so that rays
29	<	*  heading in the opposite direction pass unimpeded through the BSDF
27	>	*  (view) ray will pass right through our material, making the BSDF
28	>	*  surface invisible and showing the proxied geometry instead. Thickness
29	>	*  has the further effect of turning off reflection on the reverse side so
30	>	*  rays heading in the opposite direction pass unimpeded through the BSDF
31		*  surface.  A paired surface may be placed on the opposide side of
32		*  the detail geometry, less than this thickness away, if a two-way
33		*  proxy is desired.  Note that the sign of the thickness is important.
#	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	+	*      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 42 | Line 50 | static const char RCSid[] = "$Id$";
50		*      We do not reorient the surface, so if the BSDF has no back-side
51		*  reflectance and none is given in the real arguments, a BSDF surface
52		*  with zero thickness will appear black when viewed from behind
53	<	*  unless backface visibility is off.
53	>	*  unless backface visibility is on, when it becomes invisible.
54		*      The diffuse arguments are added to components in the BSDF file,
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 58 | Line 73 | static const char RCSid[] = "$Id$";
73		/*
74		* Note that our reverse ray-tracing process means that the positions
75		* of incoming and outgoing vectors may be reversed in our calls
76	<	* to the BSDF library.  This is fine, since the bidirectional nature
76	>	* to the BSDF library.  This is usually fine, since the bidirectional nature
77		* of the BSDF (that's what the 'B' stands for) means it all works out.
78		*/
79
#	Line 71 | 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 for MAT_ABSDF */
90		SDData  *sd;            /* loaded BSDF data */
91	+	COLOR   rdiff;          /* diffuse reflection */
92		COLOR   runsamp;        /* BSDF hemispherical reflection */
93	<	COLOR   rdiff;          /* added diffuse reflection */
93	>	COLOR   tdiff;          /* diffuse transmission */
94		COLOR   tunsamp;        /* BSDF hemispherical transmission */
78	–	COLOR   tdiff;          /* added diffuse transmission */
95		}  BSDFDAT;             /* BSDF material data */
96
97		#define cvt_sdcolor(cv, svp)    ccy2rgb(&(svp)->spec, (svp)->cieY, cv)
98
99	<	/* Jitter ray sample according to projected solid angle and specjitter */
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	<	bsdf_jitter(FVECT vres, BSDFDAT *ndp, int domax)
117	>	compute_through(BSDFDAT *ndp)
118		{
119	<	double  sr_psa = ndp->sr_vpsa[domax];
119	>	#define NDIR2CHECK      29
120	>	static const float      dir2check[NDIR2CHECK][2] = {
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	>	double          tomsum;
138	>	COLOR           vpeak;
139	>	double          vypeak, vysum;
140	>	int             i, ns, ntot;
141	>	SDError         ec;
142
143	+	if (ndp->pr->rod > 0)
144	+	dfp = (ndp->sd->tf != NULL) ? ndp->sd->tf : ndp->sd->tb;
145	+	else
146	+	dfp = (ndp->sd->tb != NULL) ? ndp->sd->tb : ndp->sd->tf;
147	+
148	+	if (dfp == NULL)
149	+	return;                         /* no specular transmission */
150	+	if (bright(ndp->pr->pcol) <= FTINY)
151	+	return;                         /* pattern is black, here */
152	+	srchrad = sqrt(dfp->minProjSA);         /* else evaluate peak */
153	+	vysum = 0;
154	+	for (i = 0; i < NDIR2CHECK; i++) {
155	+	SDValue sv;
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(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 (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	+	copycolor(ndp->cthru, vpeak);           /* already scaled by omega */
201	+	multcolor(ndp->cthru, ndp->pr->pcol);   /* modify by pattern */
202	+	return;
203	+	baderror:
204	+	objerror(ndp->mp, USER, transSDError(ec));
205	+	#undef NDIR2CHECK
206	+	}
207	+
208	+	/* Jitter ray sample according to projected solid angle and specjitter */
209	+	static void
210	+	bsdf_jitter(FVECT vres, BSDFDAT *ndp, double sr_psa)
211	+	{
212		VCOPY(vres, ndp->vray);
213		if (specjitter < 1.)
214		sr_psa *= specjitter;
#	Line 96 | Line 219 | bsdf_jitter(FVECT vres, BSDFDAT *ndp, int domax)
219		normalize(vres);
220		}
221
222	<	/* Evaluate BSDF for direct component, returning true if OK to proceed */
222	>	/* Get BSDF specular for direct component, returning true if OK to proceed */
223		static int
224	<	direct_bsdf_OK(COLOR cval, FVECT ldir, double omega, BSDFDAT *ndp)
224	>	direct_specular_OK(COLOR cval, FVECT ldir, double omega, BSDFDAT *ndp)
225		{
226	<	int     nsamp = 1, ok = 0;
226	>	int     nsamp;
227	>	double  wtot = 0;
228		FVECT   vsrc, vsmp, vjit;
229	<	double  tomega;
230	<	double  sf, sd[2];
231	<	COLOR   csmp;
229	>	double  tomega, tomega2;
230	>	double  sf, tsr, sd[2];
231	>	COLOR   csmp, cdiff;
232	>	double  diffY;
233		SDValue sv;
234		SDError ec;
235		int     i;
236	+	/* in case we fail */
237	+	setcolor(cval,  0, 0, 0);
238		/* transform source direction */
239		if (SDmapDir(vsrc, ndp->toloc, ldir) != SDEnone)
240		return(0);
241	+	/* will discount diffuse portion */
242	+	switch ((vsrc[2] > 0)<<1 | (ndp->vray[2] > 0)) {
243	+	case 3:
244	+	if (ndp->sd->rf == NULL)
245	+	return(0);      /* all diffuse */
246	+	sv = ndp->sd->rLambFront;
247	+	break;
248	+	case 0:
249	+	if (ndp->sd->rb == NULL)
250	+	return(0);      /* all diffuse */
251	+	sv = ndp->sd->rLambBack;
252	+	break;
253	+	default:
254	+	if ((ndp->sd->tf == NULL) & (ndp->sd->tb == NULL))
255	+	return(0);      /* all diffuse */
256	+	sv = ndp->sd->tLamb;
257	+	break;
258	+	}
259	+	if (sv.cieY > FTINY) {
260	+	diffY = sv.cieY *= 1./PI;
261	+	cvt_sdcolor(cdiff, &sv);
262	+	} else {
263	+	diffY = 0;
264	+	setcolor(cdiff,  0, 0, 0);
265	+	}
266	+	/* need projected solid angle */
267	+	omega *= fabs(vsrc[2]);
268		/* check indirect over-counting */
269	<	if (ndp->thick != 0 && ndp->pr->crtype & (SPECULAR|AMBIENT)
270	<	&& vsrc[2] > 0 ^ ndp->vray[2] > 0) {
271	<	double  dx = vsrc[0] + ndp->vray[0];
272	<	double  dy = vsrc[1] + ndp->vray[1];
273	<	if (dx*dx + dy*dy <= omega*(1./PI))
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	>	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	<	if (specjitter > FTINY) {       /* assign number of samples */
281	<	ec = SDsizeBSDF(&tomega, ndp->vray, vsrc, SDqueryMin, ndp->sd);
282	<	if (ec)
283	<	goto baderror;
284	<	sf = specjitter * ndp->pr->rweight;
285	<	if (tomega <= omega*.01)
286	<	nsamp = 100.*sf + .5;
287	<	else
288	<	nsamp = 4.*sf*omega/tomega + .5;
289	<	nsamp += !nsamp;
290	<	}
291	<	sf = sqrt(omega);
292	<	setcolor(cval, .0, .0, .0);     /* sample our source area */
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)
286	>	nsamp = 1;
287	>	else if (25.*tomega <= omega)
288	>	nsamp = 100.*sf + .5;
289	>	else
290	>	nsamp = 4.*sf*omega/tomega + .5;
291	>	nsamp += !nsamp;
292	>	sf = sqrt(omega);               /* sample our source area */
293	>	tsr = sqrt(tomega);
294		for (i = nsamp; i--; ) {
295		VCOPY(vsmp, vsrc);      /* jitter query directions */
296		if (nsamp > 1) {
297		multisamp(sd, 2, (i + frandom())/(double)nsamp);
298		vsmp[0] += (sd[0] - .5)*sf;
299		vsmp[1] += (sd[1] - .5)*sf;
300	<	if (normalize(vsmp) == 0) {
142	<	--nsamp;
143	<	continue;
144	<	}
300	>	normalize(vsmp);
301		}
302	<	bsdf_jitter(vjit, ndp, 0);
302	>	bsdf_jitter(vjit, ndp, tsr);
303		/* compute BSDF */
304		ec = SDevalBSDF(&sv, vjit, vsmp, ndp->sd);
305		if (ec)
306		goto baderror;
307	<	if (sv.cieY <= FTINY)   /* worth using? */
308	<	continue;
307	>	if (sv.cieY - diffY <= FTINY)
308	>	continue;       /* no specular part */
309	>	/* check for variable resolution */
310	>	ec = SDsizeBSDF(&tomega2, vjit, vsmp, SDqueryMin, ndp->sd);
311	>	if (ec)
312	>	goto baderror;
313	>	if (tomega2 < .12*tomega)
314	>	continue;       /* not safe to include */
315		cvt_sdcolor(csmp, &sv);
316	<	addcolor(cval, csmp);   /* average it in */
317	<	++ok;
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	>	#endif
322	>	wtot += 1.;
323	>	addcolor(cval, csmp);
324		}
325	<	sf = 1./(double)nsamp;
325	>	if (wtot <= FTINY)              /* no valid specular samples? */
326	>	return(0);
327	>
328	>	sf = 1./wtot;                   /* weighted average BSDF */
329		scalecolor(cval, sf);
330	<	return(ok);
330	>	/* subtract diffuse contribution */
331	>	for (i = 3*(diffY > FTINY); i--; )
332	>	if ((colval(cval,i) -= colval(cdiff,i)) < 0)
333	>	colval(cval,i) = 0;
334	>	return(1);
335		baderror:
336		objerror(ndp->mp, USER, transSDError(ec));
337	+	return(0);                      /* gratis return */
338		}
339
340		/* Compute source contribution for BSDF (reflected & transmitted) */
#	Line 175 | Line 351 | dir_bsdf(
351		double          dtmp;
352		COLOR           ctmp;
353
354	<	setcolor(cval, .0, .0, .0);
354	>	setcolor(cval,  0, 0, 0);
355
356		ldot = DOT(np->pnorm, ldir);
357		if ((-FTINY <= ldot) & (ldot <= FTINY))
#	Line 183 | Line 359 | dir_bsdf(
359
360		if (ldot > 0 && bright(np->rdiff) > FTINY) {
361		/*
362	<	*  Compute added diffuse reflected component.
362	>	*  Compute diffuse reflected component
363		*/
364		copycolor(ctmp, np->rdiff);
365		dtmp = ldot * omega * (1./PI);
#	Line 192 | Line 368 | dir_bsdf(
368		}
369		if (ldot < 0 && bright(np->tdiff) > FTINY) {
370		/*
371	<	*  Compute added diffuse transmission.
371	>	*  Compute diffuse transmission
372		*/
373		copycolor(ctmp, np->tdiff);
374		dtmp = -ldot * omega * (1.0/PI);
375		scalecolor(ctmp, dtmp);
376		addcolor(cval, ctmp);
377		}
378	+	if (ambRayInPmap(np->pr))
379	+	return;         /* specular already in photon map */
380		/*
381	<	*  Compute scattering coefficient using BSDF.
381	>	*  Compute specular scattering coefficient using BSDF
382		*/
383	<	if (!direct_bsdf_OK(ctmp, ldir, omega, np))
383	>	if (!direct_specular_OK(ctmp, ldir, omega, np))
384		return;
385	<	if (ldot > 0) {         /* pattern only diffuse reflection */
208	<	COLOR   ctmp1, ctmp2;
209	<	dtmp = (np->pr->rod > 0) ? np->sd->rLambFront.cieY
210	<	: np->sd->rLambBack.cieY;
211	<	/* diffuse fraction */
212	<	dtmp /= PI * bright(ctmp);
213	<	copycolor(ctmp2, np->pr->pcol);
214	<	scalecolor(ctmp2, dtmp);
215	<	setcolor(ctmp1, 1.-dtmp, 1.-dtmp, 1.-dtmp);
216	<	addcolor(ctmp1, ctmp2);
217	<	multcolor(ctmp, ctmp1); /* apply derated pattern */
218	<	dtmp = ldot * omega;
219	<	} else {                        /* full pattern on transmission */
385	>	if (ldot < 0) {         /* pattern for specular transmission */
386		multcolor(ctmp, np->pr->pcol);
387		dtmp = -ldot * omega;
388	<	}
388	>	} else
389	>	dtmp = ldot * omega;
390		scalecolor(ctmp, dtmp);
391		addcolor(cval, ctmp);
392		}
#	Line 238 | Line 405 | dir_brdf(
405		double          dtmp;
406		COLOR           ctmp, ctmp1, ctmp2;
407
408	<	setcolor(cval, .0, .0, .0);
408	>	setcolor(cval,  0, 0, 0);
409
410		ldot = DOT(np->pnorm, ldir);
411
#	Line 247 | Line 414 | dir_brdf(
414
415		if (bright(np->rdiff) > FTINY) {
416		/*
417	<	*  Compute added diffuse reflected component.
417	>	*  Compute diffuse reflected component
418		*/
419		copycolor(ctmp, np->rdiff);
420		dtmp = ldot * omega * (1./PI);
421		scalecolor(ctmp, dtmp);
422		addcolor(cval, ctmp);
423		}
424	+	if (ambRayInPmap(np->pr))
425	+	return;         /* specular already in photon map */
426		/*
427	<	*  Compute reflection coefficient using BSDF.
427	>	*  Compute specular reflection coefficient using BSDF
428		*/
429	<	if (!direct_bsdf_OK(ctmp, ldir, omega, np))
429	>	if (!direct_specular_OK(ctmp, ldir, omega, np))
430		return;
262	–	/* pattern only diffuse reflection */
263	–	dtmp = (np->pr->rod > 0) ? np->sd->rLambFront.cieY
264	–	: np->sd->rLambBack.cieY;
265	–	dtmp /= PI * bright(ctmp);      /* diffuse fraction */
266	–	copycolor(ctmp2, np->pr->pcol);
267	–	scalecolor(ctmp2, dtmp);
268	–	setcolor(ctmp1, 1.-dtmp, 1.-dtmp, 1.-dtmp);
269	–	addcolor(ctmp1, ctmp2);
270	–	multcolor(ctmp, ctmp1);         /* apply derated pattern */
431		dtmp = ldot * omega;
432		scalecolor(ctmp, dtmp);
433		addcolor(cval, ctmp);
#	Line 287 | Line 447 | dir_btdf(
447		double          dtmp;
448		COLOR           ctmp;
449
450	<	setcolor(cval, .0, .0, .0);
450	>	setcolor(cval,  0, 0, 0);
451
452		ldot = DOT(np->pnorm, ldir);
453
#	Line 296 | Line 456 | dir_btdf(
456
457		if (bright(np->tdiff) > FTINY) {
458		/*
459	<	*  Compute added diffuse transmission.
459	>	*  Compute diffuse transmission
460		*/
461		copycolor(ctmp, np->tdiff);
462		dtmp = -ldot * omega * (1.0/PI);
463		scalecolor(ctmp, dtmp);
464		addcolor(cval, ctmp);
465		}
466	+	if (ambRayInPmap(np->pr))
467	+	return;         /* specular already in photon map */
468		/*
469	<	*  Compute scattering coefficient using BSDF.
469	>	*  Compute specular scattering coefficient using BSDF
470		*/
471	<	if (!direct_bsdf_OK(ctmp, ldir, omega, np))
471	>	if (!direct_specular_OK(ctmp, ldir, omega, np))
472		return;
473		/* full pattern on transmission */
474		multcolor(ctmp, np->pr->pcol);
#	Line 317 | Line 479 | dir_btdf(
479
480		/* Sample separate BSDF component */
481		static int
482	<	sample_sdcomp(BSDFDAT *ndp, SDComponent *dcp, int usepat)
482	>	sample_sdcomp(BSDFDAT *ndp, SDComponent *dcp, int xmit)
483		{
484	<	int     nstarget = 1;
485	<	int     nsent;
486	<	SDError ec;
487	<	SDValue bsv;
488	<	double  xrand;
489	<	FVECT   vsmp;
490	<	RAY     sr;
484	>	const int       hasthru = (xmit &&
485	>	!(ndp->pr->crtype & (SPECULAR|AMBIENT))
486	>	&& bright(ndp->cthru) > FTINY);
487	>	int             nstarget = 1;
488	>	int             nsent = 0;
489	>	int             n;
490	>	SDError         ec;
491	>	SDValue         bsv;
492	>	double          xrand;
493	>	FVECT           vsmp, vinc;
494	>	RAY             sr;
495		/* multiple samples? */
496		if (specjitter > 1.5) {
497		nstarget = specjitter*ndp->pr->rweight + .5;
498		nstarget += !nstarget;
499		}
500		/* run through our samples */
501	<	for (nsent = 0; nsent < nstarget; nsent++) {
502	<	if (nstarget == 1)              /* stratify random variable */
501	>	for (n = 0; n < nstarget; n++) {
502	>	if (nstarget == 1) {            /* stratify random variable */
503		xrand = urand(ilhash(dimlist,ndims)+samplendx);
504	<	else
505	<	xrand = (nsent + frandom())/(double)nstarget;
504	>	if (specjitter < 1.)
505	>	xrand = .5 + specjitter*(xrand-.5);
506	>	} else {
507	>	xrand = (n + frandom())/(double)nstarget;
508	>	}
509		SDerrorDetail[0] = '\0';        /* sample direction & coef. */
510	<	bsdf_jitter(vsmp, ndp, 0);
510	>	bsdf_jitter(vsmp, ndp, ndp->sr_vpsa[0]);
511	>	VCOPY(vinc, vsmp);              /* to compare after */
512		ec = SDsampComponent(&bsv, vsmp, xrand, dcp);
513		if (ec)
514		objerror(ndp->mp, USER, transSDError(ec));
515		if (bsv.cieY <= FTINY)          /* zero component? */
516		break;
517	<	/* map vector to world */
517	>	if (hasthru) {                  /* check for view ray */
518	>	double  dx = vinc[0] + vsmp[0];
519	>	double  dy = vinc[1] + vsmp[1];
520	>	if (dx*dx + dy*dy <= ndp->sr_vpsa[0]*ndp->sr_vpsa[0])
521	>	continue;       /* exclude view sample */
522	>	}
523	>	/* map non-view sample->world */
524		if (SDmapDir(sr.rdir, ndp->fromloc, vsmp) != SDEnone)
525		break;
526		/* spawn a specular ray */
527		if (nstarget > 1)
528		bsv.cieY /= (double)nstarget;
529		cvt_sdcolor(sr.rcoef, &bsv);    /* use sample color */
530	<	if (usepat)                     /* apply pattern? */
530	>	if (xmit)                       /* apply pattern on transmit */
531		multcolor(sr.rcoef, ndp->pr->pcol);
532		if (rayorigin(&sr, SPECULAR, ndp->pr, sr.rcoef) < 0) {
533	<	if (maxdepth > 0)
534	<	break;
535	<	continue;               /* Russian roulette victim */
533	>	if (!n & (nstarget > 1)) {
534	>	n = nstarget;   /* avoid infinitue loop */
535	>	nstarget = nstarget*sr.rweight/minweight;
536	>	if (n == nstarget) break;
537	>	n = -1;         /* moved target */
538	>	}
539	>	continue;               /* try again */
540		}
541	<	/* need to offset origin? */
362	<	if (ndp->thick != 0 && ndp->pr->rod > 0 ^ vsmp[2] > 0)
541	>	if (xmit && ndp->thick != 0)    /* need to offset origin? */
542		VSUM(sr.rorg, sr.rorg, ndp->pr->ron, -ndp->thick);
543		rayvalue(&sr);                  /* send & evaluate sample */
544		multcolor(sr.rcol, sr.rcoef);
545		addcolor(ndp->pr->rcol, sr.rcol);
546	+	++nsent;
547		}
548		return(nsent);
549		}
#	Line 372 | Line 552 | sample_sdcomp(BSDFDAT *ndp, SDComponent *dcp, int usep
552		static int
553		sample_sdf(BSDFDAT *ndp, int sflags)
554		{
555	+	int             hasthru = (sflags == SDsampSpT &&
556	+	!(ndp->pr->crtype & (SPECULAR|AMBIENT))
557	+	&& bright(ndp->cthru) > FTINY);
558		int             n, ntotal = 0;
559	+	double          b = 0;
560		SDSpectralDF    *dfp;
561		COLORV          *unsc;
562
563		if (sflags == SDsampSpT) {
564		unsc = ndp->tunsamp;
565	<	dfp = ndp->sd->tf;
566	<	cvt_sdcolor(unsc, &ndp->sd->tLamb);
565	>	if (ndp->pr->rod > 0)
566	>	dfp = (ndp->sd->tf != NULL) ? ndp->sd->tf : ndp->sd->tb;
567	>	else
568	>	dfp = (ndp->sd->tb != NULL) ? ndp->sd->tb : ndp->sd->tf;
569		} else /* sflags == SDsampSpR */ {
570		unsc = ndp->runsamp;
571	<	if (ndp->pr->rod > 0) {
571	>	if (ndp->pr->rod > 0)
572		dfp = ndp->sd->rf;
573	<	cvt_sdcolor(unsc, &ndp->sd->rLambFront);
388	<	} else {
573	>	else
574		dfp = ndp->sd->rb;
390	–	cvt_sdcolor(unsc, &ndp->sd->rLambBack);
391	–	}
575		}
576	<	multcolor(unsc, ndp->pr->pcol);
576	>	setcolor(unsc,  0, 0, 0);
577		if (dfp == NULL)                        /* no specular component? */
578		return(0);
579	<	/* below sampling threshold? */
580	<	if (dfp->maxHemi <= specthresh+FTINY) {
581	<	if (dfp->maxHemi > FTINY) {     /* XXX no color from BSDF */
582	<	FVECT   vjit;
583	<	double  d;
584	<	COLOR   ctmp;
585	<	bsdf_jitter(vjit, ndp, 1);
586	<	d = SDdirectHemi(vjit, sflags, ndp->sd);
579	>
580	>	if (hasthru) {                          /* separate view sample? */
581	>	RAY     tr;
582	>	if (rayorigin(&tr, TRANS, ndp->pr, ndp->cthru) == 0) {
583	>	VCOPY(tr.rdir, ndp->pr->rdir);
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
591	>	hasthru = 0;
592	>	}
593	>	if (dfp->maxHemi - b <= FTINY) {        /* have specular to sample? */
594	>	b = 0;
595	>	} else {
596	>	FVECT   vjit;
597	>	bsdf_jitter(vjit, ndp, ndp->sr_vpsa[1]);
598	>	b = SDdirectHemi(vjit, sflags, ndp->sd) - b;
599	>	if (b < 0) b = 0;
600	>	}
601	>	if (b <= specthresh+FTINY) {            /* below sampling threshold? */
602	>	if (b > FTINY) {                /* XXX no color from BSDF */
603		if (sflags == SDsampSpT) {
604	<	copycolor(ctmp, ndp->pr->pcol);
605	<	scalecolor(ctmp, d);
604	>	copycolor(unsc, ndp->pr->pcol);
605	>	scalecolor(unsc, b);
606		} else                  /* no pattern on reflection */
607	<	setcolor(ctmp, d, d, d);
409	<	addcolor(unsc, ctmp);
607	>	setcolor(unsc, b, b, b);
608		}
609	<	return(0);
609	>	return(ntotal);
610		}
611	<	/* else need to sample */
612	<	dimlist[ndims++] = (int)(size_t)ndp->mp;
415	<	ndims++;
611	>	dimlist[ndims] = (int)(size_t)ndp->mp;  /* else sample specular */
612	>	ndims += 2;
613		for (n = dfp->ncomp; n--; ) {           /* loop over components */
614		dimlist[ndims-1] = n + 9438;
615		ntotal += sample_sdcomp(ndp, &dfp->comp[n], sflags==SDsampSpT);
#	Line 425 | 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 432 | 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);
640	<	/* get thickness */
641	<	nd.thick = evalue(mf->ep[0]);
642	<	if ((-FTINY <= nd.thick) & (nd.thick <= FTINY))
643	<	nd.thick = .0;
644	<	/* check shadow */
645	<	if (r->crtype & SHADOW) {
646	<	if (nd.thick != 0)
449	<	raytrans(r);            /* pass-through */
450	<	return(1);                      /* or shadow */
639	>	mf = hasthick   ? getfunc(m, 5, 0x1d, 1)
640	>	: getfunc(m, 4, 0xe, 1) ;
641	>	setfunc(m, r);
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);
651	+	return(1);
652	+	}
653		/* check other rays to pass */
654	<	if (nd.thick != 0 && (!(r->crtype & (SPECULAR|AMBIENT)) ||
655	<	nd.thick > 0 ^ hitfront)) {
654	>	if (nd.thick != 0 && (r->crtype & SHADOW ||
655	>	!(r->crtype & (SPECULAR|AMBIENT)) ||
656	>	(nd.thick > 0) ^ hitfront)) {
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]);
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	<	if (m->oargs.nfargs < 3)
674	<	setcolor(nd.rdiff, .0, .0, .0);
675	<	else
465	<	setcolor(nd.rdiff, m->oargs.farg[0],
673	>	cvt_sdcolor(nd.rdiff, &nd.sd->rLambFront);
674	>	if (m->oargs.nfargs >= 3) {
675	>	setcolor(ctmp, m->oargs.farg[0],
676		m->oargs.farg[1],
677		m->oargs.farg[2]);
678	+	addcolor(nd.rdiff, ctmp);
679	+	}
680		} else {
681	<	if (m->oargs.nfargs < 6) {      /* check invisible backside */
682	<	if (!backvis && (nd.sd->rb == NULL) &
683	<	(nd.sd->tf == NULL)) {
472	<	SDfreeCache(nd.sd);
473	<	raytrans(r);
474	<	return(1);
475	<	}
476	<	setcolor(nd.rdiff, .0, .0, .0);
477	<	} else
478	<	setcolor(nd.rdiff, m->oargs.farg[3],
681	>	cvt_sdcolor(nd.rdiff, &nd.sd->rLambBack);
682	>	if (m->oargs.nfargs >= 6) {
683	>	setcolor(ctmp, m->oargs.farg[3],
684		m->oargs.farg[4],
685		m->oargs.farg[5]);
686	+	addcolor(nd.rdiff, ctmp);
687	+	}
688		}
689		/* diffuse transmittance */
690	<	if (m->oargs.nfargs < 9)
691	<	setcolor(nd.tdiff, .0, .0, .0);
692	<	else
486	<	setcolor(nd.tdiff, m->oargs.farg[6],
690	>	cvt_sdcolor(nd.tdiff, &nd.sd->tLamb);
691	>	if (m->oargs.nfargs >= 9) {
692	>	setcolor(ctmp, m->oargs.farg[6],
693		m->oargs.farg[7],
694		m->oargs.farg[8]);
695	<	nd.mp = m;
696	<	nd.pr = r;
695	>	addcolor(nd.tdiff, ctmp);
696	>	}
697		/* get modifiers */
698		raytexture(r, m->omod);
699		/* modify diffuse values */
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->f != &unitxf) {
708	<	multv3(upvec, upvec, mf->f->xfm);
709	<	nd.thick *= mf->f->sca;
707	>	if (mf->fxp != &unitxf) {
708	>	multv3(upvec, upvec, mf->fxp->xfm);
709	>	nd.thick *= mf->fxp->sca;
710		}
711	+	if (r->rox != NULL) {
712	+	multv3(upvec, upvec, r->rox->f.xfm);
713	+	nd.thick *= r->rox->f.sca;
714	+	}
715		raynormal(nd.pnorm, r);
716		/* compute local BSDF xform */
717		ec = SDcompXform(nd.toloc, nd.pnorm, upvec);
#	Line 511 | Line 721 | m_bsdf(OBJREC *m, RAY *r)
721		nd.vray[2] = -r->rdir[2];
722		ec = SDmapDir(nd.vray, nd.toloc, nd.vray);
723		}
514	–	if (!ec)
515	–	ec = SDinvXform(nd.fromloc, nd.toloc);
516	–	/* determine BSDF resolution */
517	–	if (!ec)
518	–	ec = SDsizeBSDF(nd.sr_vpsa, nd.vray, NULL,
519	–	SDqueryMin+SDqueryMax, nd.sd);
724		if (ec) {
725	<	objerror(m, WARNING, transSDError(ec));
725	>	objerror(m, WARNING, "Illegal orientation vector");
726		SDfreeCache(nd.sd);
727		return(1);
728		}
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 */
746	+	ec = SDsizeBSDF(nd.sr_vpsa, nd.vray, NULL,
747	+	SDqueryMin+SDqueryMax, nd.sd);
748	+	if (ec)
749	+	objerror(m, USER, transSDError(ec));
750	+
751		nd.sr_vpsa[0] = sqrt(nd.sr_vpsa[0]);
752		nd.sr_vpsa[1] = sqrt(nd.sr_vpsa[1]);
753		if (!hitfront) {                        /* perturb normal towards hit */
#	Line 555 | Line 781 | m_bsdf(OBJREC *m, RAY *r)
781		bnorm[2] = -nd.pnorm[2];
782		if (nd.thick != 0) {            /* proxy with offset? */
783		VCOPY(vtmp, r->rop);
784	<	VSUM(r->rop, vtmp, r->ron, -nd.thick);
784	>	VSUM(r->rop, vtmp, r->ron, nd.thick);
785		multambient(ctmp, r, bnorm);
786		VCOPY(r->rop, vtmp);
787		} else
#	Line 565 | Line 791 | m_bsdf(OBJREC *m, RAY *r)
791		flipsurface(r);
792		}
793		/* add direct component */
794	<	if ((bright(nd.tdiff) <= FTINY) & (nd.sd->tf == NULL)) {
794	>	if ((bright(nd.tdiff) <= FTINY) & (nd.sd->tf == NULL) &
795	>	(nd.sd->tb == NULL)) {
796		direct(r, dir_brdf, &nd);       /* reflection only */
797		} else if (nd.thick == 0) {
798		direct(r, dir_bsdf, &nd);       /* thin surface scattering */

Diff Legend

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