[ViewVC] Diff of: radiance/ray/src/rt/m

Comparing ray/src/rt/m_bsdf.c (file contents):
Revision 2.4 by greg, Sat Feb 19 23:42:09 2011 UTC vs.
Revision 2.70 by greg, Wed Mar 9 00:27:25 2022 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.
21		* String arguments include the BSDF and function files.
22	<	* A thickness variable causes the strange but useful behavior
23	<	* of translating transmitted rays this distance past the surface
24	<	* intersection in the normal direction to bypass intervening geometry.
25	<	* This only affects scattered, non-source directed samples. Thus,
26	<	* thickness is relevant only if there is a transmitted component.
27	<	* A positive thickness has the further side-effect that an unscattered
28	<	* (view) ray will pass right through our material if it has any
29	<	* non-diffuse transmission, making our BSDF invisible. This allows the
30	<	* underlying geometry to become visible. A matching surface should be
31	<	* placed on the other side, less than the thickness away, if the backside
32	<	* reflectance is non-zero.
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, 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.
34	>	* A positive thickness hides geometry behind the BSDF surface and uses
35	>	* front reflectance and transmission properties. A negative thickness
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
49		* system for the BSDF.
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, the surface will
52	<	* appear as black when viewed from behind (unless backvis is false).
53	<	* The diffuse compnent arguments are added to components in the BSDF file,
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 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
68	<	* 0\|3\|9 rdf gdf bdf
68	>	* 0\|3\|6\|9 rdf gdf bdf
69		* rdb gdb bdb
70		* rdt gdt bdt
71		*/
#	Line 50 \| 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 59 \| Line 82 \| typedef struct {
82		RAY pr; / intersected ray */
83		FVECT pnorm; /* perturbed surface normal */
84		FVECT vray; /* local outgoing (return) vector */
85	<	double sr_vpsa; /* sqrt of BSDF projected solid angle */
85	>	double sr_vpsa[2]; /* sqrt of BSDF projected solid angle extrema */
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	+	COLOR cthru_surr; /* surround for "through" component */
91		SDData sd; / loaded BSDF data */
92	+	COLOR rdiff; /* diffuse reflection */
93		COLOR runsamp; /* BSDF hemispherical reflection */
94	<	COLOR rdiff; /* added diffuse reflection */
94	>	COLOR tdiff; /* diffuse transmission */
95		COLOR tunsamp; /* BSDF hemispherical transmission */
70	–	COLOR tdiff; /* added diffuse transmission */
96		} BSDFDAT; /* BSDF material data */
97
98		#define cvt_sdcolor(cv, svp) ccy2rgb(&(svp)->spec, (svp)->cieY, cv)
99
100	<	/* Jitter ray sample according to projected solid angle and specjitter */
100	>	typedef struct {
101	>	double vy; /* brightness (for sorting) */
102	>	FVECT tdir; /* through sample direction (normalized) */
103	>	COLOR vcol; /* BTDF color */
104	>	} PEAKSAMP; /* BTDF peak sample */
105	>
106	>	/* Comparison function to put near-peak values in descending order */
107	>	static int
108	>	cmp_psamp(const void p1, const void p2)
109	>	{
110	>	double diff = ((const PEAKSAMP )p1).vy - ((const PEAKSAMP )p2).vy;
111	>	if (diff > 0) return(-1);
112	>	if (diff < 0) return(1);
113	>	return(0);
114	>	}
115	>
116	>	/* Compute "through" component color for MAT_ABSDF */
117		static void
118	<	bsdf_jitter(FVECT vres, BSDFDAT *ndp)
118	>	compute_through(BSDFDAT *ndp)
119		{
120	<	double sr_psa = ndp->sr_vpsa;
120	>	#define NDIR2CHECK 29
121	>	static const float dir2check[NDIR2CHECK][2] = {
122	>	{0, 0}, {-0.6, 0}, {0, 0.6},
123	>	{0, -0.6}, {0.6, 0}, {-0.6, 0.6},
124	>	{-0.6, -0.6}, {0.6, 0.6}, {0.6, -0.6},
125	>	{-1.2, 0}, {0, 1.2}, {0, -1.2},
126	>	{1.2, 0}, {-1.2, 1.2}, {-1.2, -1.2},
127	>	{1.2, 1.2}, {1.2, -1.2}, {-1.8, 0},
128	>	{0, 1.8}, {0, -1.8}, {1.8, 0},
129	>	{-1.8, 1.8}, {-1.8, -1.8}, {1.8, 1.8},
130	>	{1.8, -1.8}, {-2.4, 0}, {0, 2.4},
131	>	{0, -2.4}, {2.4, 0},
132	>	};
133	>	PEAKSAMP psamp[NDIR2CHECK];
134	>	SDSpectralDF *dfp;
135	>	FVECT pdir;
136	>	double tomega, srchrad;
137	>	double tomsum, tomsurr;
138	>	COLOR vpeak, vsurr, btdiff;
139	>	double vypeak;
140	>	int i, ns;
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	+	for (i = 0; i < NDIR2CHECK; i++) {
154	+	SDValue sv;
155	+	psamp[i].tdir[0] = -ndp->vray[0] + dir2check[i][0]*srchrad;
156	+	psamp[i].tdir[1] = -ndp->vray[1] + dir2check[i][1]*srchrad;
157	+	psamp[i].tdir[2] = -ndp->vray[2];
158	+	normalize(psamp[i].tdir);
159	+	ec = SDevalBSDF(&sv, ndp->vray, psamp[i].tdir, ndp->sd);
160	+	if (ec)
161	+	goto baderror;
162	+	cvt_sdcolor(psamp[i].vcol, &sv);
163	+	psamp[i].vy = sv.cieY;
164	+	}
165	+	qsort(psamp, NDIR2CHECK, sizeof(PEAKSAMP), cmp_psamp);
166	+	if (psamp[0].vy <= FTINY)
167	+	return; /* zero BTDF here */
168	+	setcolor(vpeak, 0, 0, 0);
169	+	setcolor(vsurr, 0, 0, 0);
170	+	vypeak = tomsum = tomsurr = 0; /* combine top unique values */
171	+	ns = 0;
172	+	for (i = 0; i < NDIR2CHECK; i++) {
173	+	if (i && psamp[i].vy == psamp[i-1].vy)
174	+	continue; /* assume duplicate sample */
175	+
176	+	ec = SDsizeBSDF(&tomega, ndp->vray, psamp[i].tdir,
177	+	SDqueryMin, ndp->sd);
178	+	if (ec)
179	+	goto baderror;
180	+
181	+	scalecolor(psamp[i].vcol, tomega);
182	+	/* not part of peak? */
183	+	if (tomega > 1.5*dfp->minProjSA \|\|
184	+	vypeak > 8.psamp[i].vyns) {
185	+	if (!i) return; /* abort */
186	+	addcolor(vsurr, psamp[i].vcol);
187	+	tomsurr += tomega;
188	+	continue;
189	+	}
190	+	addcolor(vpeak, psamp[i].vcol);
191	+	tomsum += tomega;
192	+	vypeak += psamp[i].vy;
193	+	++ns;
194	+	}
195	+	if (tomsurr < 0.2tomsum) / insufficient surround? */
196	+	return;
197	+	scalecolor(vsurr, 1./tomsurr); /* surround is avg. BTDF */
198	+	if (ndp->vray[2] > 0) /* get diffuse BTDF */
199	+	cvt_sdcolor(btdiff, &ndp->sd->tLambFront);
200	+	else
201	+	cvt_sdcolor(btdiff, &ndp->sd->tLambBack);
202	+	scalecolor(btdiff, (1./PI));
203	+	for (i = 3; i--; ) { /* remove diffuse contrib. */
204	+	if ((colval(vpeak,i) -= tomsum*colval(btdiff,i)) < 0)
205	+	colval(vpeak,i) = 0;
206	+	if ((colval(vsurr,i) -= colval(btdiff,i)) < 0)
207	+	colval(vsurr,i) = 0;
208	+	}
209	+	if (bright(vpeak) < .0005) /* < 0.05% specular? */
210	+	return;
211	+	multcolor(vsurr, ndp->pr->pcol); /* modify by color */
212	+	multcolor(vpeak, ndp->pr->pcol);
213	+	copycolor(ndp->cthru, vpeak);
214	+	copycolor(ndp->cthru_surr, vsurr);
215	+	return;
216	+	baderror:
217	+	objerror(ndp->mp, USER, transSDError(ec));
218	+	#undef NDIR2CHECK
219	+	}
220	+
221	+	/* Jitter ray sample according to projected solid angle and specjitter */
222	+	static void
223	+	bsdf_jitter(FVECT vres, BSDFDAT *ndp, double sr_psa)
224	+	{
225		VCOPY(vres, ndp->vray);
226		if (specjitter < 1.)
227		sr_psa *= specjitter;
#	Line 88 \| Line 232 \| *bsdf_jitter(FVECT vres, BSDFDAT ndp)**
232		normalize(vres);
233		}
234
235	<	/* Compute source contribution for BSDF */
235	>	/* Get BSDF specular for direct component, returning true if OK to proceed */
236	>	static int
237	>	direct_specular_OK(COLOR cval, FVECT ldir, double omega, BSDFDAT *ndp)
238	>	{
239	>	int nsamp = 1;
240	>	int scnt = 0;
241	>	FVECT vsrc, vjit;
242	>	double tomega, tomega2;
243	>	double sf, tsr, sd[2];
244	>	COLOR csmp, cdiff;
245	>	double diffY;
246	>	SDValue sv;
247	>	SDError ec;
248	>	int i;
249	>	/* in case we fail */
250	>	setcolor(cval, 0, 0, 0);
251	>	/* transform source direction */
252	>	if (SDmapDir(vsrc, ndp->toloc, ldir) != SDEnone)
253	>	return(0);
254	>	/* check indirect over-counting */
255	>	if ((vsrc[2] > 0) ^ (ndp->vray[2] > 0) && bright(ndp->cthru) > FTINY) {
256	>	double dx = vsrc[0] + ndp->vray[0];
257	>	double dy = vsrc[1] + ndp->vray[1];
258	>	SDSpectralDF *dfp = (ndp->pr->rod > 0) ?
259	>	((ndp->sd->tf != NULL) ? ndp->sd->tf : ndp->sd->tb) :
260	>	((ndp->sd->tb != NULL) ? ndp->sd->tb : ndp->sd->tf) ;
261	>
262	>	tomega = omega*fabs(vsrc[2]);
263	>	if (dxdx + dydy <= (2.54./PI)(tomega + dfp->minProjSA +
264	>	2.sqrt(tomegadfp->minProjSA))) {
265	>	if (bright(ndp->cthru_surr) <= FTINY)
266	>	return(0);
267	>	copycolor(cval, ndp->cthru_surr);
268	>	return(1); /* return non-zero surround BTDF */
269	>	}
270	>	}
271	>	/* will discount diffuse portion */
272	>	switch ((vsrc[2] > 0)<<1 \| (ndp->vray[2] > 0)) {
273	>	case 3:
274	>	if (ndp->sd->rf == NULL)
275	>	return(0); /* all diffuse */
276	>	sv = ndp->sd->rLambFront;
277	>	break;
278	>	case 0:
279	>	if (ndp->sd->rb == NULL)
280	>	return(0); /* all diffuse */
281	>	sv = ndp->sd->rLambBack;
282	>	break;
283	>	case 1:
284	>	if ((ndp->sd->tf == NULL) & (ndp->sd->tb == NULL))
285	>	return(0); /* all diffuse */
286	>	sv = ndp->sd->tLambFront;
287	>	break;
288	>	case 2:
289	>	if ((ndp->sd->tf == NULL) & (ndp->sd->tb == NULL))
290	>	return(0); /* all diffuse */
291	>	sv = ndp->sd->tLambBack;
292	>	break;
293	>	}
294	>	if (sv.cieY > FTINY) {
295	>	diffY = sv.cieY *= 1./PI;
296	>	cvt_sdcolor(cdiff, &sv);
297	>	} else {
298	>	diffY = 0;
299	>	setcolor(cdiff, 0, 0, 0);
300	>	}
301	>	ec = SDsizeBSDF(&tomega, ndp->vray, vsrc, SDqueryMin, ndp->sd);
302	>	if (ec)
303	>	goto baderror;
304	>	/* check if sampling BSDF */
305	>	if ((tsr = sqrt(tomega)) > 0) {
306	>	nsamp = 4.specjitterndp->pr->rweight + .5;
307	>	nsamp += !nsamp;
308	>	}
309	>	/* jitter to fuzz BSDF cells */
310	>	for (i = nsamp; i--; ) {
311	>	bsdf_jitter(vjit, ndp, tsr);
312	>	/* compute BSDF */
313	>	ec = SDevalBSDF(&sv, vjit, vsrc, ndp->sd);
314	>	if (ec)
315	>	goto baderror;
316	>	if (sv.cieY - diffY <= FTINY)
317	>	continue; /* no specular part */
318	>	/* check for variable resolution */
319	>	ec = SDsizeBSDF(&tomega2, vjit, vsrc, SDqueryMin, ndp->sd);
320	>	if (ec)
321	>	goto baderror;
322	>	if (tomega2 < .12*tomega)
323	>	continue; /* not safe to include */
324	>	cvt_sdcolor(csmp, &sv);
325	>	addcolor(cval, csmp);
326	>	++scnt;
327	>	}
328	>	if (!scnt) /* no valid specular samples? */
329	>	return(0);
330	>
331	>	sf = 1./scnt; /* weighted average BSDF */
332	>	scalecolor(cval, sf);
333	>	/* subtract diffuse contribution */
334	>	for (i = 3*(diffY > FTINY); i--; )
335	>	if ((colval(cval,i) -= colval(cdiff,i)) < 0)
336	>	colval(cval,i) = 0;
337	>	return(1);
338	>	baderror:
339	>	objerror(ndp->mp, USER, transSDError(ec));
340	>	return(0); /* gratis return */
341	>	}
342	>
343	>	/* Compute source contribution for BSDF (reflected & transmitted) */
344		static void
345	<	dirbsdf(
345	>	dir_bsdf(
346		COLOR cval, /* returned coefficient */
347		void nnp, / material data */
348		FVECT ldir, /* light source direction */
#	Line 98 \| Line 350 \| dirbsdf(
350		)
351		{
352		BSDFDAT np = (BSDFDAT )nnp;
101	–	SDError ec;
102	–	SDValue sv;
103	–	FVECT vsrc;
104	–	FVECT vjit;
353		double ldot;
354		double dtmp;
355		COLOR ctmp;
356
357	<	setcolor(cval, .0, .0, .0);
357	>	setcolor(cval, 0, 0, 0);
358
359		ldot = DOT(np->pnorm, ldir);
360		if ((-FTINY <= ldot) & (ldot <= FTINY))
361		return;
362
363	<	if (ldot > .0 && bright(np->rdiff) > FTINY) {
363	>	if (ldot > 0 && bright(np->rdiff) > FTINY) {
364		/*
365	<	* Compute added diffuse reflected component.
365	>	* Compute diffuse reflected component
366		*/
367		copycolor(ctmp, np->rdiff);
368		dtmp = ldot * omega * (1./PI);
369		scalecolor(ctmp, dtmp);
370		addcolor(cval, ctmp);
371		}
372	<	if (ldot < .0 && bright(np->tdiff) > FTINY) {
372	>	if (ldot < 0 && bright(np->tdiff) > FTINY) {
373		/*
374	<	* Compute added diffuse transmission.
374	>	* Compute diffuse transmission
375		*/
376		copycolor(ctmp, np->tdiff);
377	<	dtmp = -ldot * omega * (1.0/PI);
377	>	dtmp = -ldot * omega * (1./PI);
378		scalecolor(ctmp, dtmp);
379		addcolor(cval, ctmp);
380		}
381	+	if (ambRayInPmap(np->pr))
382	+	return; /* specular already in photon map */
383		/*
384	<	* Compute scattering coefficient using BSDF.
384	>	* Compute specular scattering coefficient using BSDF
385		*/
386	<	if (SDmapDir(vsrc, np->toloc, ldir) != SDEnone)
386	>	if (!direct_specular_OK(ctmp, ldir, omega, np))
387		return;
388	<	bsdf_jitter(vjit, np);
139	<	ec = SDevalBSDF(&sv, vjit, vsrc, np->sd);
140	<	if (ec)
141	<	objerror(np->mp, USER, transSDError(ec));
142	<
143	<	if (sv.cieY <= FTINY) /* not worth using? */
144	<	return;
145	<	cvt_sdcolor(ctmp, &sv);
146	<	if (ldot > .0) { /* pattern only diffuse reflection */
147	<	COLOR ctmp1, ctmp2;
148	<	dtmp = (np->pr->rod > .0) ? np->sd->rLambFront.cieY
149	<	: np->sd->rLambBack.cieY;
150	<	dtmp /= PI * sv.cieY; /* diffuse fraction */
151	<	copycolor(ctmp2, np->pr->pcol);
152	<	scalecolor(ctmp2, dtmp);
153	<	setcolor(ctmp1, 1.-dtmp, 1.-dtmp, 1.-dtmp);
154	<	addcolor(ctmp1, ctmp2);
155	<	multcolor(ctmp, ctmp1); /* apply derated pattern */
156	<	dtmp = ldot * omega;
157	<	} else { /* full pattern on transmission */
388	>	if (ldot < 0) { /* pattern for specular transmission */
389		multcolor(ctmp, np->pr->pcol);
390		dtmp = -ldot * omega;
391	+	} else
392	+	dtmp = ldot * omega;
393	+	scalecolor(ctmp, dtmp);
394	+	addcolor(cval, ctmp);
395	+	}
396	+
397	+	/* Compute source contribution for BSDF (reflected only) */
398	+	static void
399	+	dir_brdf(
400	+	COLOR cval, /* returned coefficient */
401	+	void nnp, / material data */
402	+	FVECT ldir, /* light source direction */
403	+	double omega /* light source size */
404	+	)
405	+	{
406	+	BSDFDAT np = (BSDFDAT )nnp;
407	+	double ldot;
408	+	double dtmp;
409	+	COLOR ctmp, ctmp1, ctmp2;
410	+
411	+	setcolor(cval, 0, 0, 0);
412	+
413	+	ldot = DOT(np->pnorm, ldir);
414	+
415	+	if (ldot <= FTINY)
416	+	return;
417	+
418	+	if (bright(np->rdiff) > FTINY) {
419	+	/*
420	+	* Compute diffuse reflected component
421	+	*/
422	+	copycolor(ctmp, np->rdiff);
423	+	dtmp = ldot * omega * (1./PI);
424	+	scalecolor(ctmp, dtmp);
425	+	addcolor(cval, ctmp);
426		}
427	+	if (ambRayInPmap(np->pr))
428	+	return; /* specular already in photon map */
429	+	/*
430	+	* Compute specular reflection coefficient using BSDF
431	+	*/
432	+	if (!direct_specular_OK(ctmp, ldir, omega, np))
433	+	return;
434	+	dtmp = ldot * omega;
435		scalecolor(ctmp, dtmp);
436		addcolor(cval, ctmp);
437		}
438
439	+	/* Compute source contribution for BSDF (transmitted only) */
440	+	static void
441	+	dir_btdf(
442	+	COLOR cval, /* returned coefficient */
443	+	void nnp, / material data */
444	+	FVECT ldir, /* light source direction */
445	+	double omega /* light source size */
446	+	)
447	+	{
448	+	BSDFDAT np = (BSDFDAT )nnp;
449	+	double ldot;
450	+	double dtmp;
451	+	COLOR ctmp;
452	+
453	+	setcolor(cval, 0, 0, 0);
454	+
455	+	ldot = DOT(np->pnorm, ldir);
456	+
457	+	if (ldot >= -FTINY)
458	+	return;
459	+
460	+	if (bright(np->tdiff) > FTINY) {
461	+	/*
462	+	* Compute diffuse transmission
463	+	*/
464	+	copycolor(ctmp, np->tdiff);
465	+	dtmp = -ldot * omega * (1./PI);
466	+	scalecolor(ctmp, dtmp);
467	+	addcolor(cval, ctmp);
468	+	}
469	+	if (ambRayInPmap(np->pr))
470	+	return; /* specular already in photon map */
471	+	/*
472	+	* Compute specular scattering coefficient using BSDF
473	+	*/
474	+	if (!direct_specular_OK(ctmp, ldir, omega, np))
475	+	return;
476	+	/* full pattern on transmission */
477	+	multcolor(ctmp, np->pr->pcol);
478	+	dtmp = -ldot * omega;
479	+	scalecolor(ctmp, dtmp);
480	+	addcolor(cval, ctmp);
481	+	}
482	+
483		/* Sample separate BSDF component */
484		static int
485	<	sample_sdcomp(BSDFDAT ndp, SDComponent dcp, int usepat)
485	>	sample_sdcomp(BSDFDAT ndp, SDComponent dcp, int xmit)
486		{
487	<	int nstarget = 1;
488	<	int nsent = 0;
489	<	SDError ec;
490	<	SDValue bsv;
491	<	double sthick;
492	<	FVECT vjit, vsmp;
493	<	RAY sr;
494	<	int ntrials;
487	>	const int hasthru = (xmit &&
488	>	!(ndp->pr->crtype & (SPECULAR\|AMBIENT))
489	>	&& bright(ndp->cthru) > FTINY);
490	>	int nstarget = 1;
491	>	int nsent = 0;
492	>	int n;
493	>	SDError ec;
494	>	SDValue bsv;
495	>	double xrand;
496	>	FVECT vsmp, vinc;
497	>	RAY sr;
498		/* multiple samples? */
499		if (specjitter > 1.5) {
500		nstarget = specjitter*ndp->pr->rweight + .5;
501	<	if (nstarget < 1)
181	<	nstarget = 1;
501	>	nstarget += !nstarget;
502		}
503	<	/* run through our trials */
504	<	for (ntrials = 0; nsent < nstarget && ntrials < 9*nstarget; ntrials++) {
505	<	SDerrorDetail[0] = '\0';
506	<	/* sample direction & coef. */
507	<	bsdf_jitter(vjit, ndp);
508	<	ec = SDsampComponent(&bsv, vsmp, vjit, ntrials ? frandom()
509	<	: urand(ilhash(dimlist,ndims)+samplendx), dcp);
503	>	/* run through our samples */
504	>	for (n = 0; n < nstarget; n++) {
505	>	if (nstarget == 1) { /* stratify random variable */
506	>	xrand = urand(ilhash(dimlist,ndims)+samplendx);
507	>	if (specjitter < 1.)
508	>	xrand = .5 + specjitter*(xrand-.5);
509	>	} else {
510	>	xrand = (n + frandom())/(double)nstarget;
511	>	}
512	>	SDerrorDetail[0] = '\0'; /* sample direction & coef. */
513	>	bsdf_jitter(vsmp, ndp, ndp->sr_vpsa[0]);
514	>	VCOPY(vinc, vsmp); /* to compare after */
515	>	ec = SDsampComponent(&bsv, vsmp, xrand, dcp);
516		if (ec)
517		objerror(ndp->mp, USER, transSDError(ec));
518	<	/* zero component? */
193	<	if (bsv.cieY <= FTINY)
518	>	if (bsv.cieY <= FTINY) /* zero component? */
519		break;
520	<	/* map vector to world */
520	>	if (hasthru) { /* check for view ray */
521	>	double dx = vinc[0] + vsmp[0];
522	>	double dy = vinc[1] + vsmp[1];
523	>	if (dxdx + dydy <= ndp->sr_vpsa[0]*ndp->sr_vpsa[0])
524	>	continue; /* exclude view sample */
525	>	}
526	>	/* map non-view sample->world */
527		if (SDmapDir(sr.rdir, ndp->fromloc, vsmp) != SDEnone)
528		break;
198	–	/* unintentional penetration? */
199	–	if (DOT(sr.rdir, ndp->pr->ron) > .0 ^ vsmp[2] > .0)
200	–	continue;
529		/* spawn a specular ray */
530		if (nstarget > 1)
531		bsv.cieY /= (double)nstarget;
532	<	cvt_sdcolor(sr.rcoef, &bsv); /* use color */
533	<	if (usepat) /* pattern on transmission */
532	>	cvt_sdcolor(sr.rcoef, &bsv); /* use sample color */
533	>	if (xmit) /* apply pattern on transmit */
534		multcolor(sr.rcoef, ndp->pr->pcol);
535		if (rayorigin(&sr, SPECULAR, ndp->pr, sr.rcoef) < 0) {
536	<	if (maxdepth > 0)
537	<	break;
538	<	++nsent; /* Russian roulette victim */
539	<	continue;
536	>	if (!n & (nstarget > 1)) {
537	>	n = nstarget; /* avoid infinitue loop */
538	>	nstarget = nstarget*sr.rweight/minweight;
539	>	if (n == nstarget) break;
540	>	n = -1; /* moved target */
541	>	}
542	>	continue; /* try again */
543		}
544	<	if (ndp->thick > FTINY) { /* need to move origin? */
545	<	sthick = (ndp->pr->rod > .0) ? -ndp->thick : ndp->thick;
215	<	if (sthick < .0 ^ vsmp[2] > .0)
216	<	VSUM(sr.rorg, sr.rorg, ndp->pr->ron, sthick);
217	<	}
544	>	if (xmit && ndp->thick != 0) /* need to offset origin? */
545	>	VSUM(sr.rorg, sr.rorg, ndp->pr->ron, -ndp->thick);
546		rayvalue(&sr); /* send & evaluate sample */
547		multcolor(sr.rcol, sr.rcoef);
548		addcolor(ndp->pr->rcol, sr.rcol);
#	Line 227 \| Line 555 \| *sample_sdcomp(BSDFDAT ndp, SDComponent dcp, int usep*
555		static int
556		sample_sdf(BSDFDAT *ndp, int sflags)
557		{
558	+	int hasthru = (sflags == SDsampSpT &&
559	+	!(ndp->pr->crtype & (SPECULAR\|AMBIENT))
560	+	&& bright(ndp->cthru) > FTINY);
561		int n, ntotal = 0;
562	+	double b = 0;
563		SDSpectralDF *dfp;
564		COLORV *unsc;
565
566		if (sflags == SDsampSpT) {
567		unsc = ndp->tunsamp;
568	<	dfp = ndp->sd->tf;
569	<	cvt_sdcolor(unsc, &ndp->sd->tLamb);
568	>	if (ndp->pr->rod > 0)
569	>	dfp = (ndp->sd->tf != NULL) ? ndp->sd->tf : ndp->sd->tb;
570	>	else
571	>	dfp = (ndp->sd->tb != NULL) ? ndp->sd->tb : ndp->sd->tf;
572		} else /* sflags == SDsampSpR */ {
573		unsc = ndp->runsamp;
574	<	if (ndp->pr->rod > .0) {
574	>	if (ndp->pr->rod > 0)
575		dfp = ndp->sd->rf;
576	<	cvt_sdcolor(unsc, &ndp->sd->rLambFront);
243	<	} else {
576	>	else
577		dfp = ndp->sd->rb;
245	–	cvt_sdcolor(unsc, &ndp->sd->rLambBack);
246	–	}
578		}
579	<	multcolor(unsc, ndp->pr->pcol);
579	>	setcolor(unsc, 0, 0, 0);
580		if (dfp == NULL) /* no specular component? */
581		return(0);
582	<	/* below sampling threshold? */
583	<	if (dfp->maxHemi <= specthresh+FTINY) {
584	<	if (dfp->maxHemi > FTINY) { /* XXX no color from BSDF */
585	<	FVECT vjit;
586	<	double d;
587	<	COLOR ctmp;
588	<	bsdf_jitter(vjit, ndp);
589	<	d = SDdirectHemi(vjit, sflags, ndp->sd);
582	>
583	>	if (hasthru) { /* separate view sample? */
584	>	RAY tr;
585	>	if (rayorigin(&tr, TRANS, ndp->pr, ndp->cthru) == 0) {
586	>	VCOPY(tr.rdir, ndp->pr->rdir);
587	>	rayvalue(&tr);
588	>	multcolor(tr.rcol, tr.rcoef);
589	>	addcolor(ndp->pr->rcol, tr.rcol);
590	>	ndp->pr->rxt = ndp->pr->rot + raydistance(&tr);
591	>	++ntotal;
592	>	b = bright(ndp->cthru);
593	>	} else
594	>	hasthru = 0;
595	>	}
596	>	if (dfp->maxHemi - b <= FTINY) { /* have specular to sample? */
597	>	b = 0;
598	>	} else {
599	>	FVECT vjit;
600	>	bsdf_jitter(vjit, ndp, ndp->sr_vpsa[1]);
601	>	b = SDdirectHemi(vjit, sflags, ndp->sd) - b;
602	>	if (b < 0) b = 0;
603	>	}
604	>	if (b <= specthresh+FTINY) { /* below sampling threshold? */
605	>	if (b > FTINY) { /* XXX no color from BSDF */
606		if (sflags == SDsampSpT) {
607	<	copycolor(ctmp, ndp->pr->pcol);
608	<	scalecolor(ctmp, d);
607	>	copycolor(unsc, ndp->pr->pcol);
608	>	scalecolor(unsc, b);
609		} else /* no pattern on reflection */
610	<	setcolor(ctmp, d, d, d);
264	<	addcolor(unsc, ctmp);
610	>	setcolor(unsc, b, b, b);
611		}
612	<	return(0);
612	>	return(ntotal);
613		}
614	<	/* else need to sample */
615	<	dimlist[ndims++] = (int)(size_t)ndp->mp;
270	<	ndims++;
614	>	dimlist[ndims] = (int)(size_t)ndp->mp; /* else sample specular */
615	>	ndims += 2;
616		for (n = dfp->ncomp; n--; ) { /* loop over components */
617		dimlist[ndims-1] = n + 9438;
618		ntotal += sample_sdcomp(ndp, &dfp->comp[n], sflags==SDsampSpT);
#	Line 280 \| Line 625 \| *sample_sdf(BSDFDAT ndp, int sflags)**
625		int
626		m_bsdf(OBJREC m, RAY r)
627		{
628	+	int hasthick = (m->otype == MAT_BSDF);
629	+	int hitfront;
630		COLOR ctmp;
631		SDError ec;
632	<	FVECT upvec, outVec;
632	>	FVECT upvec, vtmp;
633		MFUNC *mf;
634		BSDFDAT nd;
635		/* check arguments */
636	<	if ((m->oargs.nsargs < 6) \| (m->oargs.nfargs > 9) \|
636	>	if ((m->oargs.nsargs < hasthick+5) \| (m->oargs.nfargs > 9) \|
637		(m->oargs.nfargs % 3))
638		objerror(m, USER, "bad # arguments");
639	<
640	<	/* get BSDF data */
294	<	nd.sd = loadBSDF(m->oargs.sarg[1]);
639	>	/* record surface struck */
640	>	hitfront = (r->rod > 0);
641		/* load cal file */
642	<	mf = getfunc(m, 5, 0x1d, 1);
643	<	/* get thickness */
644	<	nd.thick = evalue(mf->ep[0]);
645	<	if (nd.thick < .0)
646	<	nd.thick = .0;
647	<	/* check shadow */
648	<	if (r->crtype & SHADOW) {
649	<	if ((nd.thick > FTINY) & (nd.sd->tf != NULL))
304	<	raytrans(r); /* pass-through */
305	<	SDfreeCache(nd.sd);
306	<	return(1); /* else shadow */
642	>	mf = hasthick ? getfunc(m, 5, 0x1d, 1)
643	>	: getfunc(m, 4, 0xe, 1) ;
644	>	setfunc(m, r);
645	>	nd.thick = 0; /* set thickness */
646	>	if (hasthick) {
647	>	nd.thick = evalue(mf->ep[0]);
648	>	if ((-FTINY <= nd.thick) & (nd.thick <= FTINY))
649	>	nd.thick = 0;
650		}
651	<	/* check unscattered ray */
652	<	if (!(r->crtype & (SPECULAR\|AMBIENT)) &&
653	<	(nd.thick > FTINY) & (nd.sd->tf != NULL)) {
651	>	/* check backface visibility */
652	>	if (!hitfront & !backvis) {
653	>	raytrans(r);
654	>	return(1);
655	>	}
656	>	/* check other rays to pass */
657	>	if (nd.thick != 0 && (r->crtype & SHADOW \|\|
658	>	!(r->crtype & (SPECULAR\|AMBIENT)) \|\|
659	>	(nd.thick > 0) ^ hitfront)) {
660	>	raytrans(r); /* hide our proxy */
661	>	return(1);
662	>	}
663	>	if (hasthick && r->crtype & SHADOW) /* early shadow check #1 */
664	>	return(1);
665	>	nd.mp = m;
666	>	nd.pr = r;
667	>	/* get BSDF data */
668	>	nd.sd = loadBSDF(m->oargs.sarg[hasthick]);
669	>	/* early shadow check #2 */
670	>	if (r->crtype & SHADOW && (nd.sd->tf == NULL) & (nd.sd->tb == NULL)) {
671		SDfreeCache(nd.sd);
312	–	raytrans(r); /* pass-through */
672		return(1);
673		}
674	<	/* diffuse reflectance */
675	<	if (r->rod > .0) {
676	<	if (m->oargs.nfargs < 3)
677	<	setcolor(nd.rdiff, .0, .0, .0);
678	<	else
320	<	setcolor(nd.rdiff, m->oargs.farg[0],
674	>	/* diffuse components */
675	>	if (hitfront) {
676	>	cvt_sdcolor(nd.rdiff, &nd.sd->rLambFront);
677	>	if (m->oargs.nfargs >= 3) {
678	>	setcolor(ctmp, m->oargs.farg[0],
679		m->oargs.farg[1],
680		m->oargs.farg[2]);
681	+	addcolor(nd.rdiff, ctmp);
682	+	}
683	+	cvt_sdcolor(nd.tdiff, &nd.sd->tLambFront);
684		} else {
685	<	if (m->oargs.nfargs < 6) { /* check invisible backside */
686	<	if (!backvis && (nd.sd->rb == NULL) &
687	<	(nd.sd->tf == NULL)) {
327	<	SDfreeCache(nd.sd);
328	<	raytrans(r);
329	<	return(1);
330	<	}
331	<	setcolor(nd.rdiff, .0, .0, .0);
332	<	} else
333	<	setcolor(nd.rdiff, m->oargs.farg[3],
685	>	cvt_sdcolor(nd.rdiff, &nd.sd->rLambBack);
686	>	if (m->oargs.nfargs >= 6) {
687	>	setcolor(ctmp, m->oargs.farg[3],
688		m->oargs.farg[4],
689		m->oargs.farg[5]);
690	+	addcolor(nd.rdiff, ctmp);
691	+	}
692	+	cvt_sdcolor(nd.tdiff, &nd.sd->tLambBack);
693		}
694	<	/* diffuse transmittance */
695	<	if (m->oargs.nfargs < 9)
339	<	setcolor(nd.tdiff, .0, .0, .0);
340	<	else
341	<	setcolor(nd.tdiff, m->oargs.farg[6],
694	>	if (m->oargs.nfargs >= 9) { /* add diffuse transmittance? */
695	>	setcolor(ctmp, m->oargs.farg[6],
696		m->oargs.farg[7],
697		m->oargs.farg[8]);
698	<	nd.mp = m;
699	<	nd.pr = r;
698	>	addcolor(nd.tdiff, ctmp);
699	>	}
700		/* get modifiers */
701		raytexture(r, m->omod);
348	–	if (bright(r->pcol) <= FTINY) { /* black pattern?! */
349	–	SDfreeCache(nd.sd);
350	–	return(1);
351	–	}
702		/* modify diffuse values */
703		multcolor(nd.rdiff, r->pcol);
704		multcolor(nd.tdiff, r->pcol);
705		/* get up vector */
706	<	upvec[0] = evalue(mf->ep[1]);
707	<	upvec[1] = evalue(mf->ep[2]);
708	<	upvec[2] = evalue(mf->ep[3]);
706	>	upvec[0] = evalue(mf->ep[hasthick+0]);
707	>	upvec[1] = evalue(mf->ep[hasthick+1]);
708	>	upvec[2] = evalue(mf->ep[hasthick+2]);
709		/* return to world coords */
710	<	if (mf->f != &unitxf) {
711	<	multv3(upvec, upvec, mf->f->xfm);
712	<	nd.thick *= mf->f->sca;
710	>	if (mf->fxp != &unitxf) {
711	>	multv3(upvec, upvec, mf->fxp->xfm);
712	>	nd.thick *= mf->fxp->sca;
713		}
714	+	if (r->rox != NULL) {
715	+	multv3(upvec, upvec, r->rox->f.xfm);
716	+	nd.thick *= r->rox->f.sca;
717	+	}
718		raynormal(nd.pnorm, r);
719		/* compute local BSDF xform */
720		ec = SDcompXform(nd.toloc, nd.pnorm, upvec);
#	Line 370 \| Line 724 \| *m_bsdf(OBJREC m, RAY r)*
724		nd.vray[2] = -r->rdir[2];
725		ec = SDmapDir(nd.vray, nd.toloc, nd.vray);
726		}
727	<	if (!ec)
728	<	ec = SDinvXform(nd.fromloc, nd.toloc);
375	<	/* determine BSDF resolution */
376	<	if (!ec)
377	<	ec = SDsizeBSDF(&nd.sr_vpsa, nd.vray, SDqueryMin, nd.sd);
378	<	if (!ec)
379	<	nd.sr_vpsa = sqrt(nd.sr_vpsa);
380	<	else {
381	<	objerror(m, WARNING, transSDError(ec));
727	>	if (ec) {
728	>	objerror(m, WARNING, "Illegal orientation vector");
729		SDfreeCache(nd.sd);
730		return(1);
731		}
732	<
733	<	if (r->rod < .0) { /* perturb normal towards hit */
732	>	setcolor(nd.cthru, 0, 0, 0); /* consider through component */
733	>	setcolor(nd.cthru_surr, 0, 0, 0);
734	>	if (m->otype == MAT_ABSDF) {
735	>	compute_through(&nd);
736	>	if (r->crtype & SHADOW) {
737	>	RAY tr; /* attempt to pass shadow ray */
738	>	SDfreeCache(nd.sd);
739	>	if (rayorigin(&tr, TRANS, r, nd.cthru) < 0)
740	>	return(1); /* no through component */
741	>	VCOPY(tr.rdir, r->rdir);
742	>	rayvalue(&tr); /* transmit with scaling */
743	>	multcolor(tr.rcol, tr.rcoef);
744	>	copycolor(r->rcol, tr.rcol);
745	>	return(1); /* we're done */
746	>	}
747	>	}
748	>	ec = SDinvXform(nd.fromloc, nd.toloc);
749	>	if (!ec) /* determine BSDF resolution */
750	>	ec = SDsizeBSDF(nd.sr_vpsa, nd.vray, NULL,
751	>	SDqueryMin+SDqueryMax, nd.sd);
752	>	if (ec)
753	>	objerror(m, USER, transSDError(ec));
754	>
755	>	nd.sr_vpsa[0] = sqrt(nd.sr_vpsa[0]);
756	>	nd.sr_vpsa[1] = sqrt(nd.sr_vpsa[1]);
757	>	if (!hitfront) { /* perturb normal towards hit */
758		nd.pnorm[0] = -nd.pnorm[0];
759		nd.pnorm[1] = -nd.pnorm[1];
760		nd.pnorm[2] = -nd.pnorm[2];
#	Line 395 \| Line 766 \| *m_bsdf(OBJREC m, RAY r)*
766		/* compute indirect diffuse */
767		copycolor(ctmp, nd.rdiff);
768		addcolor(ctmp, nd.runsamp);
769	<	if (bright(ctmp) > FTINY) { /* ambient from this side */
770	<	if (r->rod < .0)
769	>	if (bright(ctmp) > FTINY) { /* ambient from reflection */
770	>	if (!hitfront)
771		flipsurface(r);
772		multambient(ctmp, r, nd.pnorm);
773		addcolor(r->rcol, ctmp);
774	<	if (r->rod < .0)
774	>	if (!hitfront)
775		flipsurface(r);
776		}
777		copycolor(ctmp, nd.tdiff);
778		addcolor(ctmp, nd.tunsamp);
779		if (bright(ctmp) > FTINY) { /* ambient from other side */
780		FVECT bnorm;
781	<	if (r->rod > .0)
781	>	if (hitfront)
782		flipsurface(r);
783		bnorm[0] = -nd.pnorm[0];
784		bnorm[1] = -nd.pnorm[1];
785		bnorm[2] = -nd.pnorm[2];
786	<	multambient(ctmp, r, bnorm);
786	>	if (nd.thick != 0) { /* proxy with offset? */
787	>	VCOPY(vtmp, r->rop);
788	>	VSUM(r->rop, vtmp, r->ron, nd.thick);
789	>	multambient(ctmp, r, bnorm);
790	>	VCOPY(r->rop, vtmp);
791	>	} else
792	>	multambient(ctmp, r, bnorm);
793		addcolor(r->rcol, ctmp);
794	<	if (r->rod > .0)
794	>	if (hitfront)
795		flipsurface(r);
796		}
797		/* add direct component */
798	<	direct(r, dirbsdf, &nd);
798	>	if ((bright(nd.tdiff) <= FTINY) & (nd.sd->tf == NULL) &
799	>	(nd.sd->tb == NULL)) {
800	>	direct(r, dir_brdf, &nd); /* reflection only */
801	>	} else if (nd.thick == 0) {
802	>	direct(r, dir_bsdf, &nd); /* thin surface scattering */
803	>	} else {
804	>	direct(r, dir_brdf, &nd); /* reflection first */
805	>	VCOPY(vtmp, r->rop); /* offset for transmitted */
806	>	VSUM(r->rop, vtmp, r->ron, -nd.thick);
807	>	direct(r, dir_btdf, &nd); /* separate transmission */
808	>	VCOPY(r->rop, vtmp);
809	>	}
810		/* clean up */
811		SDfreeCache(nd.sd);
812		return(1);

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing ray/src/rt/m_bsdf.c (file contents): Revision 2.4 by greg, Sat Feb 19 23:42:09 2011 UTC vs. Revision 2.70 by greg, Wed Mar 9 00:27:25 2022 UTC

Diff Legend

Comparing ray/src/rt/m_bsdf.c (file contents):
Revision 2.4 by greg, Sat Feb 19 23:42:09 2011 UTC vs.
Revision 2.70 by greg, Wed Mar 9 00:27:25 2022 UTC