ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/m_bsdf.c
Revision: 2.68
Committed: Thu Feb 10 16:24:51 2022 UTC (3 years, 2 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.67: +2 -2 lines
Log Message: 
perf: Modest improvement in determining when to extract "through" peak

File Contents

# User Rev Content
1 greg 2.1 #ifndef lint
2 greg 2.68 static const char RCSid[] = "$Id: m_bsdf.c,v 2.67 2021/12/07 23:49:50 greg Exp $";
3 greg 2.1 #endif
4     /*
5     * Shading for materials with BSDFs taken from XML data files
6     */
7    
8     #include "copyright.h"
9    
10     #include "ray.h"
11 greg 2.50 #include "otypes.h"
12 greg 2.1 #include "ambient.h"
13     #include "source.h"
14     #include "func.h"
15     #include "bsdf.h"
16     #include "random.h"
17 greg 2.30 #include "pmapmat.h"
18 greg 2.1
19     /*
20 greg 2.65 * Arguments to this material include optional diffuse colors.
21 greg 2.1 * String arguments include the BSDF and function files.
22 greg 2.50 * For the MAT_BSDF type, a non-zero thickness causes the useful behavior
23 greg 2.5 * 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 greg 2.35 * (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 greg 2.5 * 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 greg 2.52 * For the MAT_ABSDF type, we check for a strong "through" component.
40 greg 2.50 * Such a component will cause direct rays to pass through unscattered.
41 greg 2.40 * 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 greg 2.52 * A MAT_BSDF type with zero thickness behaves the same as a MAT_ABSDF
45 greg 2.50 * type with no strong through component.
46 greg 2.1 * 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 greg 2.5 * reflectance and none is given in the real arguments, a BSDF surface
52     * with zero thickness will appear black when viewed from behind
53 greg 2.35 * unless backface visibility is on, when it becomes invisible.
54 greg 2.5 * The diffuse arguments are added to components in the BSDF file,
55 greg 2.1 * not multiplied. However, patterns affect this material as a multiplier
56     * on everything except non-diffuse reflection.
57     *
58 greg 2.52 * Arguments for MAT_ABSDF are:
59 greg 2.50 * 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 greg 2.1 * Arguments for MAT_BSDF are:
66     * 6+ thick BSDFfile ux uy uz funcfile transform
67     * 0
68 greg 2.8 * 0|3|6|9 rdf gdf bdf
69 greg 2.1 * rdb gdb bdb
70     * rdt gdt bdt
71     */
72    
73 greg 2.4 /*
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 greg 2.35 * to the BSDF library. This is usually fine, since the bidirectional nature
77 greg 2.4 * of the BSDF (that's what the 'B' stands for) means it all works out.
78     */
79    
80 greg 2.1 typedef struct {
81     OBJREC *mp; /* material pointer */
82     RAY *pr; /* intersected ray */
83     FVECT pnorm; /* perturbed surface normal */
84 greg 2.4 FVECT vray; /* local outgoing (return) vector */
85 greg 2.9 double sr_vpsa[2]; /* sqrt of BSDF projected solid angle extrema */
86 greg 2.1 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 greg 2.52 COLOR cthru; /* "through" component for MAT_ABSDF */
90 greg 2.61 COLOR cthru_surr; /* surround for "through" component */
91 greg 2.1 SDData *sd; /* loaded BSDF data */
92 greg 2.31 COLOR rdiff; /* diffuse reflection */
93 greg 2.39 COLOR runsamp; /* BSDF hemispherical reflection */
94 greg 2.31 COLOR tdiff; /* diffuse transmission */
95 greg 2.39 COLOR tunsamp; /* BSDF hemispherical transmission */
96 greg 2.1 } BSDFDAT; /* BSDF material data */
97    
98     #define cvt_sdcolor(cv, svp) ccy2rgb(&(svp)->spec, (svp)->cieY, cv)
99    
100 greg 2.58 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 greg 2.52 /* Compute "through" component color for MAT_ABSDF */
117 greg 2.34 static void
118     compute_through(BSDFDAT *ndp)
119     {
120 greg 2.60 #define NDIR2CHECK 29
121 greg 2.34 static const float dir2check[NDIR2CHECK][2] = {
122 greg 2.60 {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 greg 2.34 };
133 greg 2.58 PEAKSAMP psamp[NDIR2CHECK];
134 greg 2.34 SDSpectralDF *dfp;
135     FVECT pdir;
136     double tomega, srchrad;
137 greg 2.61 double tomsum, tomsurr;
138     COLOR vpeak, vsurr;
139     double vypeak;
140 greg 2.65 int i, ns;
141 greg 2.34 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 greg 2.58 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 greg 2.67 ec = SDevalBSDF(&sv, ndp->vray, psamp[i].tdir, ndp->sd);
160 greg 2.58 if (ec)
161     goto baderror;
162     cvt_sdcolor(psamp[i].vcol, &sv);
163 greg 2.61 psamp[i].vy = sv.cieY;
164 greg 2.58 }
165     qsort(psamp, NDIR2CHECK, sizeof(PEAKSAMP), cmp_psamp);
166 greg 2.61 if (psamp[0].vy <= FTINY)
167 greg 2.65 return; /* zero BTDF here */
168 greg 2.40 setcolor(vpeak, 0, 0, 0);
169 greg 2.61 setcolor(vsurr, 0, 0, 0);
170     vypeak = tomsum = tomsurr = 0; /* combine top unique values */
171     ns = 0;
172 greg 2.34 for (i = 0; i < NDIR2CHECK; i++) {
173 greg 2.65 if (i && psamp[i].vy == psamp[i-1].vy)
174     continue; /* assume duplicate sample */
175 greg 2.61
176 greg 2.67 ec = SDsizeBSDF(&tomega, ndp->vray, psamp[i].tdir,
177 greg 2.58 SDqueryMin, ndp->sd);
178 greg 2.34 if (ec)
179     goto baderror;
180 greg 2.65
181     scalecolor(psamp[i].vcol, tomega);
182     /* not part of peak? */
183 greg 2.61 if (tomega > 1.5*dfp->minProjSA ||
184     vypeak > 8.*psamp[i].vy*ns) {
185     if (!i) return; /* abort */
186     addcolor(vsurr, psamp[i].vcol);
187     tomsurr += tomega;
188 greg 2.58 continue;
189 greg 2.34 }
190 greg 2.58 addcolor(vpeak, psamp[i].vcol);
191     tomsum += tomega;
192     vypeak += psamp[i].vy;
193     ++ns;
194     }
195 greg 2.68 if (tomsurr < 0.2*tomsum) /* insufficient surround? */
196 greg 2.65 return;
197 greg 2.62 if ((vypeak/ns - (ndp->vray[2] > 0 ? ndp->sd->tLambFront.cieY
198 greg 2.65 : ndp->sd->tLambBack.cieY)*(1./PI))*tomsum < .0005)
199     return; /* < 0.05% transmission */
200 greg 2.58 copycolor(ndp->cthru, vpeak); /* already scaled by omega */
201 greg 2.34 multcolor(ndp->cthru, ndp->pr->pcol); /* modify by pattern */
202 greg 2.65 scalecolor(vsurr, 1./tomsurr); /* surround is avg. BTDF */
203     copycolor(ndp->cthru_surr, vsurr);
204     multcolor(ndp->cthru_surr, ndp->pr->pcol);
205 greg 2.34 return;
206     baderror:
207     objerror(ndp->mp, USER, transSDError(ec));
208     #undef NDIR2CHECK
209     }
210    
211 greg 2.4 /* Jitter ray sample according to projected solid angle and specjitter */
212     static void
213 greg 2.15 bsdf_jitter(FVECT vres, BSDFDAT *ndp, double sr_psa)
214 greg 2.4 {
215     VCOPY(vres, ndp->vray);
216     if (specjitter < 1.)
217     sr_psa *= specjitter;
218     if (sr_psa <= FTINY)
219     return;
220     vres[0] += sr_psa*(.5 - frandom());
221     vres[1] += sr_psa*(.5 - frandom());
222     normalize(vres);
223     }
224    
225 greg 2.33 /* Get BSDF specular for direct component, returning true if OK to proceed */
226 greg 2.7 static int
227 greg 2.33 direct_specular_OK(COLOR cval, FVECT ldir, double omega, BSDFDAT *ndp)
228 greg 2.7 {
229 greg 2.66 int nsamp = 1;
230     int scnt = 0;
231     FVECT vsrc, vjit;
232 greg 2.36 double tomega, tomega2;
233 greg 2.15 double sf, tsr, sd[2];
234 greg 2.32 COLOR csmp, cdiff;
235     double diffY;
236 greg 2.7 SDValue sv;
237     SDError ec;
238 greg 2.13 int i;
239 greg 2.37 /* in case we fail */
240 greg 2.40 setcolor(cval, 0, 0, 0);
241 greg 2.7 /* transform source direction */
242     if (SDmapDir(vsrc, ndp->toloc, ldir) != SDEnone)
243     return(0);
244 greg 2.32 /* will discount diffuse portion */
245     switch ((vsrc[2] > 0)<<1 | (ndp->vray[2] > 0)) {
246     case 3:
247     if (ndp->sd->rf == NULL)
248     return(0); /* all diffuse */
249     sv = ndp->sd->rLambFront;
250     break;
251     case 0:
252     if (ndp->sd->rb == NULL)
253     return(0); /* all diffuse */
254     sv = ndp->sd->rLambBack;
255     break;
256 greg 2.62 case 1:
257 greg 2.32 if ((ndp->sd->tf == NULL) & (ndp->sd->tb == NULL))
258     return(0); /* all diffuse */
259 greg 2.62 sv = ndp->sd->tLambFront;
260     break;
261     case 2:
262     if ((ndp->sd->tf == NULL) & (ndp->sd->tb == NULL))
263     return(0); /* all diffuse */
264     sv = ndp->sd->tLambBack;
265 greg 2.32 break;
266     }
267 greg 2.33 if (sv.cieY > FTINY) {
268     diffY = sv.cieY *= 1./PI;
269 greg 2.32 cvt_sdcolor(cdiff, &sv);
270     } else {
271 greg 2.40 diffY = 0;
272     setcolor(cdiff, 0, 0, 0);
273 greg 2.32 }
274 greg 2.13 /* check indirect over-counting */
275 greg 2.40 if ((vsrc[2] > 0) ^ (ndp->vray[2] > 0) && bright(ndp->cthru) > FTINY) {
276 greg 2.53 double dx = vsrc[0] + ndp->vray[0];
277     double dy = vsrc[1] + ndp->vray[1];
278     SDSpectralDF *dfp = (ndp->pr->rod > 0) ?
279     ((ndp->sd->tf != NULL) ? ndp->sd->tf : ndp->sd->tb) :
280     ((ndp->sd->tb != NULL) ? ndp->sd->tb : ndp->sd->tf) ;
281    
282 greg 2.66 tomega = omega*fabs(vsrc[2]);
283     if (dx*dx + dy*dy <= (2.5*4./PI)*(tomega + dfp->minProjSA +
284     2.*sqrt(tomega*dfp->minProjSA))) {
285 greg 2.61 if (bright(ndp->cthru_surr) <= FTINY)
286     return(0);
287     copycolor(cval, ndp->cthru_surr);
288     return(1); /* return non-zero surround BTDF */
289     }
290 greg 2.7 }
291 greg 2.53 ec = SDsizeBSDF(&tomega, ndp->vray, vsrc, SDqueryMin, ndp->sd);
292     if (ec)
293     goto baderror;
294 greg 2.66 /* check if sampling BSDF */
295     if ((tsr = sqrt(tomega)) > 0) {
296     nsamp = 4.*specjitter*ndp->pr->rweight + .5;
297     nsamp += !nsamp;
298     }
299     /* jitter to fuzz BSDF cells */
300 greg 2.13 for (i = nsamp; i--; ) {
301 greg 2.15 bsdf_jitter(vjit, ndp, tsr);
302 greg 2.37 /* compute BSDF */
303 greg 2.66 ec = SDevalBSDF(&sv, vjit, vsrc, ndp->sd);
304 greg 2.37 if (ec)
305     goto baderror;
306     if (sv.cieY - diffY <= FTINY)
307     continue; /* no specular part */
308 greg 2.36 /* check for variable resolution */
309 greg 2.66 ec = SDsizeBSDF(&tomega2, vjit, vsrc, SDqueryMin, ndp->sd);
310 greg 2.36 if (ec)
311     goto baderror;
312     if (tomega2 < .12*tomega)
313     continue; /* not safe to include */
314 greg 2.13 cvt_sdcolor(csmp, &sv);
315 greg 2.43 addcolor(cval, csmp);
316 greg 2.66 ++scnt;
317 greg 2.13 }
318 greg 2.66 if (!scnt) /* no valid specular samples? */
319 greg 2.37 return(0);
320    
321 greg 2.66 sf = 1./scnt; /* weighted average BSDF */
322 greg 2.13 scalecolor(cval, sf);
323 greg 2.32 /* subtract diffuse contribution */
324     for (i = 3*(diffY > FTINY); i--; )
325 greg 2.40 if ((colval(cval,i) -= colval(cdiff,i)) < 0)
326     colval(cval,i) = 0;
327 greg 2.32 return(1);
328 greg 2.13 baderror:
329     objerror(ndp->mp, USER, transSDError(ec));
330 greg 2.17 return(0); /* gratis return */
331 greg 2.7 }
332    
333 greg 2.5 /* Compute source contribution for BSDF (reflected & transmitted) */
334 greg 2.1 static void
335 greg 2.5 dir_bsdf(
336 greg 2.1 COLOR cval, /* returned coefficient */
337     void *nnp, /* material data */
338     FVECT ldir, /* light source direction */
339     double omega /* light source size */
340     )
341     {
342 greg 2.3 BSDFDAT *np = (BSDFDAT *)nnp;
343 greg 2.1 double ldot;
344     double dtmp;
345     COLOR ctmp;
346    
347 greg 2.40 setcolor(cval, 0, 0, 0);
348 greg 2.1
349     ldot = DOT(np->pnorm, ldir);
350     if ((-FTINY <= ldot) & (ldot <= FTINY))
351     return;
352    
353 greg 2.9 if (ldot > 0 && bright(np->rdiff) > FTINY) {
354 greg 2.1 /*
355 greg 2.39 * Compute diffuse reflected component
356 greg 2.1 */
357     copycolor(ctmp, np->rdiff);
358     dtmp = ldot * omega * (1./PI);
359     scalecolor(ctmp, dtmp);
360     addcolor(cval, ctmp);
361     }
362 greg 2.9 if (ldot < 0 && bright(np->tdiff) > FTINY) {
363 greg 2.1 /*
364 greg 2.39 * Compute diffuse transmission
365 greg 2.1 */
366     copycolor(ctmp, np->tdiff);
367 greg 2.66 dtmp = -ldot * omega * (1./PI);
368 greg 2.1 scalecolor(ctmp, dtmp);
369     addcolor(cval, ctmp);
370     }
371 greg 2.30 if (ambRayInPmap(np->pr))
372     return; /* specular already in photon map */
373 greg 2.1 /*
374 greg 2.39 * Compute specular scattering coefficient using BSDF
375 greg 2.1 */
376 greg 2.33 if (!direct_specular_OK(ctmp, ldir, omega, np))
377 greg 2.1 return;
378 greg 2.31 if (ldot < 0) { /* pattern for specular transmission */
379 greg 2.1 multcolor(ctmp, np->pr->pcol);
380     dtmp = -ldot * omega;
381 greg 2.31 } else
382     dtmp = ldot * omega;
383 greg 2.1 scalecolor(ctmp, dtmp);
384     addcolor(cval, ctmp);
385     }
386    
387 greg 2.5 /* Compute source contribution for BSDF (reflected only) */
388     static void
389     dir_brdf(
390     COLOR cval, /* returned coefficient */
391     void *nnp, /* material data */
392     FVECT ldir, /* light source direction */
393     double omega /* light source size */
394     )
395     {
396     BSDFDAT *np = (BSDFDAT *)nnp;
397     double ldot;
398     double dtmp;
399     COLOR ctmp, ctmp1, ctmp2;
400    
401 greg 2.40 setcolor(cval, 0, 0, 0);
402 greg 2.5
403     ldot = DOT(np->pnorm, ldir);
404    
405     if (ldot <= FTINY)
406     return;
407    
408     if (bright(np->rdiff) > FTINY) {
409     /*
410 greg 2.39 * Compute diffuse reflected component
411 greg 2.5 */
412     copycolor(ctmp, np->rdiff);
413     dtmp = ldot * omega * (1./PI);
414     scalecolor(ctmp, dtmp);
415     addcolor(cval, ctmp);
416     }
417 greg 2.30 if (ambRayInPmap(np->pr))
418     return; /* specular already in photon map */
419 greg 2.5 /*
420 greg 2.39 * Compute specular reflection coefficient using BSDF
421 greg 2.5 */
422 greg 2.33 if (!direct_specular_OK(ctmp, ldir, omega, np))
423 greg 2.5 return;
424     dtmp = ldot * omega;
425     scalecolor(ctmp, dtmp);
426     addcolor(cval, ctmp);
427     }
428    
429     /* Compute source contribution for BSDF (transmitted only) */
430     static void
431     dir_btdf(
432     COLOR cval, /* returned coefficient */
433     void *nnp, /* material data */
434     FVECT ldir, /* light source direction */
435     double omega /* light source size */
436     )
437     {
438     BSDFDAT *np = (BSDFDAT *)nnp;
439     double ldot;
440     double dtmp;
441     COLOR ctmp;
442    
443 greg 2.40 setcolor(cval, 0, 0, 0);
444 greg 2.5
445     ldot = DOT(np->pnorm, ldir);
446    
447     if (ldot >= -FTINY)
448     return;
449    
450     if (bright(np->tdiff) > FTINY) {
451     /*
452 greg 2.39 * Compute diffuse transmission
453 greg 2.5 */
454     copycolor(ctmp, np->tdiff);
455 greg 2.66 dtmp = -ldot * omega * (1./PI);
456 greg 2.5 scalecolor(ctmp, dtmp);
457     addcolor(cval, ctmp);
458     }
459 greg 2.30 if (ambRayInPmap(np->pr))
460     return; /* specular already in photon map */
461 greg 2.5 /*
462 greg 2.39 * Compute specular scattering coefficient using BSDF
463 greg 2.5 */
464 greg 2.33 if (!direct_specular_OK(ctmp, ldir, omega, np))
465 greg 2.5 return;
466     /* full pattern on transmission */
467     multcolor(ctmp, np->pr->pcol);
468     dtmp = -ldot * omega;
469     scalecolor(ctmp, dtmp);
470     addcolor(cval, ctmp);
471     }
472    
473 greg 2.1 /* Sample separate BSDF component */
474     static int
475 greg 2.40 sample_sdcomp(BSDFDAT *ndp, SDComponent *dcp, int xmit)
476 greg 2.1 {
477 greg 2.47 const int hasthru = (xmit &&
478     !(ndp->pr->crtype & (SPECULAR|AMBIENT))
479     && bright(ndp->cthru) > FTINY);
480 greg 2.41 int nstarget = 1;
481     int nsent = 0;
482     int n;
483     SDError ec;
484     SDValue bsv;
485     double xrand;
486     FVECT vsmp, vinc;
487     RAY sr;
488 greg 2.1 /* multiple samples? */
489     if (specjitter > 1.5) {
490     nstarget = specjitter*ndp->pr->rweight + .5;
491 greg 2.14 nstarget += !nstarget;
492 greg 2.1 }
493 greg 2.11 /* run through our samples */
494 greg 2.40 for (n = 0; n < nstarget; n++) {
495 greg 2.15 if (nstarget == 1) { /* stratify random variable */
496 greg 2.11 xrand = urand(ilhash(dimlist,ndims)+samplendx);
497 greg 2.15 if (specjitter < 1.)
498     xrand = .5 + specjitter*(xrand-.5);
499     } else {
500 greg 2.40 xrand = (n + frandom())/(double)nstarget;
501 greg 2.15 }
502 greg 2.11 SDerrorDetail[0] = '\0'; /* sample direction & coef. */
503 greg 2.15 bsdf_jitter(vsmp, ndp, ndp->sr_vpsa[0]);
504 greg 2.40 VCOPY(vinc, vsmp); /* to compare after */
505 greg 2.11 ec = SDsampComponent(&bsv, vsmp, xrand, dcp);
506 greg 2.1 if (ec)
507 greg 2.2 objerror(ndp->mp, USER, transSDError(ec));
508 greg 2.11 if (bsv.cieY <= FTINY) /* zero component? */
509 greg 2.1 break;
510 greg 2.40 if (hasthru) { /* check for view ray */
511     double dx = vinc[0] + vsmp[0];
512     double dy = vinc[1] + vsmp[1];
513     if (dx*dx + dy*dy <= ndp->sr_vpsa[0]*ndp->sr_vpsa[0])
514     continue; /* exclude view sample */
515     }
516     /* map non-view sample->world */
517 greg 2.4 if (SDmapDir(sr.rdir, ndp->fromloc, vsmp) != SDEnone)
518 greg 2.1 break;
519     /* spawn a specular ray */
520     if (nstarget > 1)
521     bsv.cieY /= (double)nstarget;
522 greg 2.11 cvt_sdcolor(sr.rcoef, &bsv); /* use sample color */
523 greg 2.40 if (xmit) /* apply pattern on transmit */
524 greg 2.1 multcolor(sr.rcoef, ndp->pr->pcol);
525     if (rayorigin(&sr, SPECULAR, ndp->pr, sr.rcoef) < 0) {
526 greg 2.48 if (!n & (nstarget > 1)) {
527 greg 2.49 n = nstarget; /* avoid infinitue loop */
528 greg 2.48 nstarget = nstarget*sr.rweight/minweight;
529 greg 2.49 if (n == nstarget) break;
530 greg 2.48 n = -1; /* moved target */
531     }
532     continue; /* try again */
533 greg 2.1 }
534 greg 2.40 if (xmit && ndp->thick != 0) /* need to offset origin? */
535 greg 2.5 VSUM(sr.rorg, sr.rorg, ndp->pr->ron, -ndp->thick);
536 greg 2.1 rayvalue(&sr); /* send & evaluate sample */
537     multcolor(sr.rcol, sr.rcoef);
538     addcolor(ndp->pr->rcol, sr.rcol);
539 greg 2.40 ++nsent;
540 greg 2.1 }
541     return(nsent);
542     }
543    
544     /* Sample non-diffuse components of BSDF */
545     static int
546     sample_sdf(BSDFDAT *ndp, int sflags)
547     {
548 greg 2.46 int hasthru = (sflags == SDsampSpT &&
549 greg 2.47 !(ndp->pr->crtype & (SPECULAR|AMBIENT))
550     && bright(ndp->cthru) > FTINY);
551 greg 2.1 int n, ntotal = 0;
552 greg 2.40 double b = 0;
553 greg 2.1 SDSpectralDF *dfp;
554     COLORV *unsc;
555    
556     if (sflags == SDsampSpT) {
557 greg 2.39 unsc = ndp->tunsamp;
558 greg 2.22 if (ndp->pr->rod > 0)
559     dfp = (ndp->sd->tf != NULL) ? ndp->sd->tf : ndp->sd->tb;
560     else
561     dfp = (ndp->sd->tb != NULL) ? ndp->sd->tb : ndp->sd->tf;
562 greg 2.1 } else /* sflags == SDsampSpR */ {
563 greg 2.39 unsc = ndp->runsamp;
564 greg 2.31 if (ndp->pr->rod > 0)
565 greg 2.1 dfp = ndp->sd->rf;
566 greg 2.31 else
567 greg 2.1 dfp = ndp->sd->rb;
568     }
569 greg 2.40 setcolor(unsc, 0, 0, 0);
570 greg 2.1 if (dfp == NULL) /* no specular component? */
571     return(0);
572 greg 2.40
573     if (hasthru) { /* separate view sample? */
574     RAY tr;
575     if (rayorigin(&tr, TRANS, ndp->pr, ndp->cthru) == 0) {
576     VCOPY(tr.rdir, ndp->pr->rdir);
577     rayvalue(&tr);
578     multcolor(tr.rcol, tr.rcoef);
579     addcolor(ndp->pr->rcol, tr.rcol);
580 greg 2.56 ndp->pr->rxt = ndp->pr->rot + raydistance(&tr);
581 greg 2.40 ++ntotal;
582     b = bright(ndp->cthru);
583     } else
584     hasthru = 0;
585     }
586 greg 2.43 if (dfp->maxHemi - b <= FTINY) { /* have specular to sample? */
587 greg 2.40 b = 0;
588     } else {
589     FVECT vjit;
590     bsdf_jitter(vjit, ndp, ndp->sr_vpsa[1]);
591     b = SDdirectHemi(vjit, sflags, ndp->sd) - b;
592     if (b < 0) b = 0;
593     }
594     if (b <= specthresh+FTINY) { /* below sampling threshold? */
595     if (b > FTINY) { /* XXX no color from BSDF */
596 greg 2.1 if (sflags == SDsampSpT) {
597 greg 2.39 copycolor(unsc, ndp->pr->pcol);
598 greg 2.40 scalecolor(unsc, b);
599 greg 2.1 } else /* no pattern on reflection */
600 greg 2.40 setcolor(unsc, b, b, b);
601 greg 2.1 }
602 greg 2.40 return(ntotal);
603 greg 2.1 }
604 greg 2.41 dimlist[ndims] = (int)(size_t)ndp->mp; /* else sample specular */
605     ndims += 2;
606 greg 2.1 for (n = dfp->ncomp; n--; ) { /* loop over components */
607     dimlist[ndims-1] = n + 9438;
608     ntotal += sample_sdcomp(ndp, &dfp->comp[n], sflags==SDsampSpT);
609     }
610     ndims -= 2;
611     return(ntotal);
612     }
613    
614     /* Color a ray that hit a BSDF material */
615     int
616     m_bsdf(OBJREC *m, RAY *r)
617     {
618 greg 2.50 int hasthick = (m->otype == MAT_BSDF);
619 greg 2.6 int hitfront;
620 greg 2.1 COLOR ctmp;
621     SDError ec;
622 greg 2.5 FVECT upvec, vtmp;
623 greg 2.1 MFUNC *mf;
624     BSDFDAT nd;
625     /* check arguments */
626 greg 2.50 if ((m->oargs.nsargs < hasthick+5) | (m->oargs.nfargs > 9) |
627 greg 2.1 (m->oargs.nfargs % 3))
628     objerror(m, USER, "bad # arguments");
629 greg 2.6 /* record surface struck */
630 greg 2.9 hitfront = (r->rod > 0);
631 greg 2.1 /* load cal file */
632 greg 2.50 mf = hasthick ? getfunc(m, 5, 0x1d, 1)
633     : getfunc(m, 4, 0xe, 1) ;
634 greg 2.25 setfunc(m, r);
635 greg 2.50 nd.thick = 0; /* set thickness */
636     if (hasthick) {
637     nd.thick = evalue(mf->ep[0]);
638     if ((-FTINY <= nd.thick) & (nd.thick <= FTINY))
639     nd.thick = 0;
640     }
641 greg 2.26 /* check backface visibility */
642     if (!hitfront & !backvis) {
643     raytrans(r);
644     return(1);
645     }
646 greg 2.5 /* check other rays to pass */
647 greg 2.34 if (nd.thick != 0 && (r->crtype & SHADOW ||
648     !(r->crtype & (SPECULAR|AMBIENT)) ||
649 greg 2.29 (nd.thick > 0) ^ hitfront)) {
650 greg 2.5 raytrans(r); /* hide our proxy */
651 greg 2.1 return(1);
652     }
653 greg 2.51 if (hasthick && r->crtype & SHADOW) /* early shadow check #1 */
654     return(1);
655 greg 2.31 nd.mp = m;
656     nd.pr = r;
657 greg 2.5 /* get BSDF data */
658 greg 2.50 nd.sd = loadBSDF(m->oargs.sarg[hasthick]);
659 greg 2.51 /* early shadow check #2 */
660 greg 2.55 if (r->crtype & SHADOW && (nd.sd->tf == NULL) & (nd.sd->tb == NULL)) {
661     SDfreeCache(nd.sd);
662 greg 2.34 return(1);
663 greg 2.55 }
664 greg 2.63 /* diffuse components */
665 greg 2.6 if (hitfront) {
666 greg 2.31 cvt_sdcolor(nd.rdiff, &nd.sd->rLambFront);
667     if (m->oargs.nfargs >= 3) {
668     setcolor(ctmp, m->oargs.farg[0],
669 greg 2.1 m->oargs.farg[1],
670     m->oargs.farg[2]);
671 greg 2.31 addcolor(nd.rdiff, ctmp);
672     }
673 greg 2.63 cvt_sdcolor(nd.tdiff, &nd.sd->tLambFront);
674 greg 2.1 } else {
675 greg 2.31 cvt_sdcolor(nd.rdiff, &nd.sd->rLambBack);
676     if (m->oargs.nfargs >= 6) {
677     setcolor(ctmp, m->oargs.farg[3],
678 greg 2.1 m->oargs.farg[4],
679     m->oargs.farg[5]);
680 greg 2.31 addcolor(nd.rdiff, ctmp);
681     }
682 greg 2.63 cvt_sdcolor(nd.tdiff, &nd.sd->tLambBack);
683 greg 2.1 }
684 greg 2.63 if (m->oargs.nfargs >= 9) { /* add diffuse transmittance? */
685 greg 2.31 setcolor(ctmp, m->oargs.farg[6],
686 greg 2.1 m->oargs.farg[7],
687     m->oargs.farg[8]);
688 greg 2.31 addcolor(nd.tdiff, ctmp);
689     }
690 greg 2.1 /* get modifiers */
691     raytexture(r, m->omod);
692     /* modify diffuse values */
693     multcolor(nd.rdiff, r->pcol);
694     multcolor(nd.tdiff, r->pcol);
695     /* get up vector */
696 greg 2.50 upvec[0] = evalue(mf->ep[hasthick+0]);
697     upvec[1] = evalue(mf->ep[hasthick+1]);
698     upvec[2] = evalue(mf->ep[hasthick+2]);
699 greg 2.1 /* return to world coords */
700 greg 2.21 if (mf->fxp != &unitxf) {
701     multv3(upvec, upvec, mf->fxp->xfm);
702     nd.thick *= mf->fxp->sca;
703 greg 2.1 }
704 greg 2.23 if (r->rox != NULL) {
705     multv3(upvec, upvec, r->rox->f.xfm);
706     nd.thick *= r->rox->f.sca;
707     }
708 greg 2.1 raynormal(nd.pnorm, r);
709     /* compute local BSDF xform */
710     ec = SDcompXform(nd.toloc, nd.pnorm, upvec);
711     if (!ec) {
712 greg 2.4 nd.vray[0] = -r->rdir[0];
713     nd.vray[1] = -r->rdir[1];
714     nd.vray[2] = -r->rdir[2];
715     ec = SDmapDir(nd.vray, nd.toloc, nd.vray);
716 greg 2.20 }
717 greg 2.19 if (ec) {
718     objerror(m, WARNING, "Illegal orientation vector");
719 greg 2.55 SDfreeCache(nd.sd);
720 greg 2.19 return(1);
721 greg 2.1 }
722 greg 2.50 setcolor(nd.cthru, 0, 0, 0); /* consider through component */
723 greg 2.61 setcolor(nd.cthru_surr, 0, 0, 0);
724 greg 2.52 if (m->otype == MAT_ABSDF) {
725 greg 2.50 compute_through(&nd);
726     if (r->crtype & SHADOW) {
727     RAY tr; /* attempt to pass shadow ray */
728 greg 2.55 SDfreeCache(nd.sd);
729 greg 2.50 if (rayorigin(&tr, TRANS, r, nd.cthru) < 0)
730     return(1); /* no through component */
731     VCOPY(tr.rdir, r->rdir);
732     rayvalue(&tr); /* transmit with scaling */
733     multcolor(tr.rcol, tr.rcoef);
734     copycolor(r->rcol, tr.rcol);
735     return(1); /* we're done */
736     }
737 greg 2.34 }
738     ec = SDinvXform(nd.fromloc, nd.toloc);
739     if (!ec) /* determine BSDF resolution */
740     ec = SDsizeBSDF(nd.sr_vpsa, nd.vray, NULL,
741     SDqueryMin+SDqueryMax, nd.sd);
742 greg 2.20 if (ec)
743     objerror(m, USER, transSDError(ec));
744    
745 greg 2.9 nd.sr_vpsa[0] = sqrt(nd.sr_vpsa[0]);
746     nd.sr_vpsa[1] = sqrt(nd.sr_vpsa[1]);
747 greg 2.6 if (!hitfront) { /* perturb normal towards hit */
748 greg 2.1 nd.pnorm[0] = -nd.pnorm[0];
749     nd.pnorm[1] = -nd.pnorm[1];
750     nd.pnorm[2] = -nd.pnorm[2];
751     }
752     /* sample reflection */
753     sample_sdf(&nd, SDsampSpR);
754     /* sample transmission */
755     sample_sdf(&nd, SDsampSpT);
756     /* compute indirect diffuse */
757 greg 2.39 copycolor(ctmp, nd.rdiff);
758     addcolor(ctmp, nd.runsamp);
759     if (bright(ctmp) > FTINY) { /* ambient from reflection */
760 greg 2.6 if (!hitfront)
761 greg 2.1 flipsurface(r);
762     multambient(ctmp, r, nd.pnorm);
763     addcolor(r->rcol, ctmp);
764 greg 2.6 if (!hitfront)
765 greg 2.1 flipsurface(r);
766     }
767 greg 2.39 copycolor(ctmp, nd.tdiff);
768     addcolor(ctmp, nd.tunsamp);
769     if (bright(ctmp) > FTINY) { /* ambient from other side */
770 greg 2.1 FVECT bnorm;
771 greg 2.6 if (hitfront)
772 greg 2.1 flipsurface(r);
773     bnorm[0] = -nd.pnorm[0];
774     bnorm[1] = -nd.pnorm[1];
775     bnorm[2] = -nd.pnorm[2];
776 greg 2.9 if (nd.thick != 0) { /* proxy with offset? */
777 greg 2.5 VCOPY(vtmp, r->rop);
778 greg 2.18 VSUM(r->rop, vtmp, r->ron, nd.thick);
779 greg 2.5 multambient(ctmp, r, bnorm);
780     VCOPY(r->rop, vtmp);
781     } else
782     multambient(ctmp, r, bnorm);
783 greg 2.1 addcolor(r->rcol, ctmp);
784 greg 2.6 if (hitfront)
785 greg 2.1 flipsurface(r);
786     }
787     /* add direct component */
788 greg 2.22 if ((bright(nd.tdiff) <= FTINY) & (nd.sd->tf == NULL) &
789     (nd.sd->tb == NULL)) {
790 greg 2.5 direct(r, dir_brdf, &nd); /* reflection only */
791 greg 2.9 } else if (nd.thick == 0) {
792 greg 2.5 direct(r, dir_bsdf, &nd); /* thin surface scattering */
793     } else {
794     direct(r, dir_brdf, &nd); /* reflection first */
795     VCOPY(vtmp, r->rop); /* offset for transmitted */
796     VSUM(r->rop, vtmp, r->ron, -nd.thick);
797 greg 2.6 direct(r, dir_btdf, &nd); /* separate transmission */
798 greg 2.5 VCOPY(r->rop, vtmp);
799     }
800 greg 2.1 /* clean up */
801     SDfreeCache(nd.sd);
802     return(1);
803     }