ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/src/rt/m_bsdf.c
Revision: 2.65
Committed: Fri Aug 27 03:09:27 2021 UTC (4 years, 2 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.64: +15 -25 lines
Log Message: 
perf: Undid last change and reduced specular transmission threshold for PE to 0.05%

File Contents

# User Rev Content
1 greg 2.1 #ifndef lint
2 greg 2.64 static const char RCSid[] = "$Id: m_bsdf.c,v 2.63 2021/03/27 20:08:58 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     ec = SDevalBSDF(&sv, psamp[i].tdir, ndp->vray, ndp->sd);
160     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.58 ec = SDsizeBSDF(&tomega, psamp[i].tdir, ndp->vray,
177     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.65 if (tomsurr <= FTINY) /* no surround implies no peak */
196     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.43 int nsamp;
230     double wtot = 0;
231 greg 2.13 FVECT vsrc, vsmp, 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.53 /* need projected solid angle */
275 greg 2.37 omega *= fabs(vsrc[2]);
276 greg 2.13 /* check indirect over-counting */
277 greg 2.40 if ((vsrc[2] > 0) ^ (ndp->vray[2] > 0) && bright(ndp->cthru) > FTINY) {
278 greg 2.53 double dx = vsrc[0] + ndp->vray[0];
279     double dy = vsrc[1] + ndp->vray[1];
280     SDSpectralDF *dfp = (ndp->pr->rod > 0) ?
281     ((ndp->sd->tf != NULL) ? ndp->sd->tf : ndp->sd->tb) :
282     ((ndp->sd->tb != NULL) ? ndp->sd->tb : ndp->sd->tf) ;
283    
284     if (dx*dx + dy*dy <= (2.5*4./PI)*(omega + dfp->minProjSA +
285 greg 2.61 2.*sqrt(omega*dfp->minProjSA))) {
286     if (bright(ndp->cthru_surr) <= FTINY)
287     return(0);
288     copycolor(cval, ndp->cthru_surr);
289     return(1); /* return non-zero surround BTDF */
290     }
291 greg 2.7 }
292 greg 2.53 ec = SDsizeBSDF(&tomega, ndp->vray, vsrc, SDqueryMin, ndp->sd);
293     if (ec)
294     goto baderror;
295 greg 2.37 /* assign number of samples */
296 greg 2.15 sf = specjitter * ndp->pr->rweight;
297 greg 2.40 if (tomega <= 0)
298 greg 2.24 nsamp = 1;
299     else if (25.*tomega <= omega)
300 greg 2.15 nsamp = 100.*sf + .5;
301     else
302     nsamp = 4.*sf*omega/tomega + .5;
303     nsamp += !nsamp;
304 greg 2.37 sf = sqrt(omega); /* sample our source area */
305 greg 2.15 tsr = sqrt(tomega);
306 greg 2.13 for (i = nsamp; i--; ) {
307     VCOPY(vsmp, vsrc); /* jitter query directions */
308     if (nsamp > 1) {
309     multisamp(sd, 2, (i + frandom())/(double)nsamp);
310     vsmp[0] += (sd[0] - .5)*sf;
311     vsmp[1] += (sd[1] - .5)*sf;
312 greg 2.36 normalize(vsmp);
313 greg 2.13 }
314 greg 2.15 bsdf_jitter(vjit, ndp, tsr);
315 greg 2.37 /* compute BSDF */
316     ec = SDevalBSDF(&sv, vjit, vsmp, ndp->sd);
317     if (ec)
318     goto baderror;
319     if (sv.cieY - diffY <= FTINY)
320     continue; /* no specular part */
321 greg 2.36 /* check for variable resolution */
322     ec = SDsizeBSDF(&tomega2, vjit, vsmp, SDqueryMin, ndp->sd);
323     if (ec)
324     goto baderror;
325     if (tomega2 < .12*tomega)
326     continue; /* not safe to include */
327 greg 2.13 cvt_sdcolor(csmp, &sv);
328 greg 2.59 #if 0
329     if (sf < 2.5*tsr) { /* weight by BSDF for small sources */
330 greg 2.44 scalecolor(csmp, sv.cieY);
331     wtot += sv.cieY;
332     } else
333 greg 2.59 #endif
334     wtot += 1.;
335 greg 2.43 addcolor(cval, csmp);
336 greg 2.13 }
337 greg 2.43 if (wtot <= FTINY) /* no valid specular samples? */
338 greg 2.37 return(0);
339    
340 greg 2.43 sf = 1./wtot; /* weighted average BSDF */
341 greg 2.13 scalecolor(cval, sf);
342 greg 2.32 /* subtract diffuse contribution */
343     for (i = 3*(diffY > FTINY); i--; )
344 greg 2.40 if ((colval(cval,i) -= colval(cdiff,i)) < 0)
345     colval(cval,i) = 0;
346 greg 2.32 return(1);
347 greg 2.13 baderror:
348     objerror(ndp->mp, USER, transSDError(ec));
349 greg 2.17 return(0); /* gratis return */
350 greg 2.7 }
351    
352 greg 2.5 /* Compute source contribution for BSDF (reflected & transmitted) */
353 greg 2.1 static void
354 greg 2.5 dir_bsdf(
355 greg 2.1 COLOR cval, /* returned coefficient */
356     void *nnp, /* material data */
357     FVECT ldir, /* light source direction */
358     double omega /* light source size */
359     )
360     {
361 greg 2.3 BSDFDAT *np = (BSDFDAT *)nnp;
362 greg 2.1 double ldot;
363     double dtmp;
364     COLOR ctmp;
365    
366 greg 2.40 setcolor(cval, 0, 0, 0);
367 greg 2.1
368     ldot = DOT(np->pnorm, ldir);
369     if ((-FTINY <= ldot) & (ldot <= FTINY))
370     return;
371    
372 greg 2.9 if (ldot > 0 && bright(np->rdiff) > FTINY) {
373 greg 2.1 /*
374 greg 2.39 * Compute diffuse reflected component
375 greg 2.1 */
376     copycolor(ctmp, np->rdiff);
377     dtmp = ldot * omega * (1./PI);
378     scalecolor(ctmp, dtmp);
379     addcolor(cval, ctmp);
380     }
381 greg 2.9 if (ldot < 0 && bright(np->tdiff) > FTINY) {
382 greg 2.1 /*
383 greg 2.39 * Compute diffuse transmission
384 greg 2.1 */
385     copycolor(ctmp, np->tdiff);
386     dtmp = -ldot * omega * (1.0/PI);
387     scalecolor(ctmp, dtmp);
388     addcolor(cval, ctmp);
389     }
390 greg 2.30 if (ambRayInPmap(np->pr))
391     return; /* specular already in photon map */
392 greg 2.1 /*
393 greg 2.39 * Compute specular scattering coefficient using BSDF
394 greg 2.1 */
395 greg 2.33 if (!direct_specular_OK(ctmp, ldir, omega, np))
396 greg 2.1 return;
397 greg 2.31 if (ldot < 0) { /* pattern for specular transmission */
398 greg 2.1 multcolor(ctmp, np->pr->pcol);
399     dtmp = -ldot * omega;
400 greg 2.31 } else
401     dtmp = ldot * omega;
402 greg 2.1 scalecolor(ctmp, dtmp);
403     addcolor(cval, ctmp);
404     }
405    
406 greg 2.5 /* Compute source contribution for BSDF (reflected only) */
407     static void
408     dir_brdf(
409     COLOR cval, /* returned coefficient */
410     void *nnp, /* material data */
411     FVECT ldir, /* light source direction */
412     double omega /* light source size */
413     )
414     {
415     BSDFDAT *np = (BSDFDAT *)nnp;
416     double ldot;
417     double dtmp;
418     COLOR ctmp, ctmp1, ctmp2;
419    
420 greg 2.40 setcolor(cval, 0, 0, 0);
421 greg 2.5
422     ldot = DOT(np->pnorm, ldir);
423    
424     if (ldot <= FTINY)
425     return;
426    
427     if (bright(np->rdiff) > FTINY) {
428     /*
429 greg 2.39 * Compute diffuse reflected component
430 greg 2.5 */
431     copycolor(ctmp, np->rdiff);
432     dtmp = ldot * omega * (1./PI);
433     scalecolor(ctmp, dtmp);
434     addcolor(cval, ctmp);
435     }
436 greg 2.30 if (ambRayInPmap(np->pr))
437     return; /* specular already in photon map */
438 greg 2.5 /*
439 greg 2.39 * Compute specular reflection coefficient using BSDF
440 greg 2.5 */
441 greg 2.33 if (!direct_specular_OK(ctmp, ldir, omega, np))
442 greg 2.5 return;
443     dtmp = ldot * omega;
444     scalecolor(ctmp, dtmp);
445     addcolor(cval, ctmp);
446     }
447    
448     /* Compute source contribution for BSDF (transmitted only) */
449     static void
450     dir_btdf(
451     COLOR cval, /* returned coefficient */
452     void *nnp, /* material data */
453     FVECT ldir, /* light source direction */
454     double omega /* light source size */
455     )
456     {
457     BSDFDAT *np = (BSDFDAT *)nnp;
458     double ldot;
459     double dtmp;
460     COLOR ctmp;
461    
462 greg 2.40 setcolor(cval, 0, 0, 0);
463 greg 2.5
464     ldot = DOT(np->pnorm, ldir);
465    
466     if (ldot >= -FTINY)
467     return;
468    
469     if (bright(np->tdiff) > FTINY) {
470     /*
471 greg 2.39 * Compute diffuse transmission
472 greg 2.5 */
473     copycolor(ctmp, np->tdiff);
474     dtmp = -ldot * omega * (1.0/PI);
475     scalecolor(ctmp, dtmp);
476     addcolor(cval, ctmp);
477     }
478 greg 2.30 if (ambRayInPmap(np->pr))
479     return; /* specular already in photon map */
480 greg 2.5 /*
481 greg 2.39 * Compute specular scattering coefficient using BSDF
482 greg 2.5 */
483 greg 2.33 if (!direct_specular_OK(ctmp, ldir, omega, np))
484 greg 2.5 return;
485     /* full pattern on transmission */
486     multcolor(ctmp, np->pr->pcol);
487     dtmp = -ldot * omega;
488     scalecolor(ctmp, dtmp);
489     addcolor(cval, ctmp);
490     }
491    
492 greg 2.1 /* Sample separate BSDF component */
493     static int
494 greg 2.40 sample_sdcomp(BSDFDAT *ndp, SDComponent *dcp, int xmit)
495 greg 2.1 {
496 greg 2.47 const int hasthru = (xmit &&
497     !(ndp->pr->crtype & (SPECULAR|AMBIENT))
498     && bright(ndp->cthru) > FTINY);
499 greg 2.41 int nstarget = 1;
500     int nsent = 0;
501     int n;
502     SDError ec;
503     SDValue bsv;
504     double xrand;
505     FVECT vsmp, vinc;
506     RAY sr;
507 greg 2.1 /* multiple samples? */
508     if (specjitter > 1.5) {
509     nstarget = specjitter*ndp->pr->rweight + .5;
510 greg 2.14 nstarget += !nstarget;
511 greg 2.1 }
512 greg 2.11 /* run through our samples */
513 greg 2.40 for (n = 0; n < nstarget; n++) {
514 greg 2.15 if (nstarget == 1) { /* stratify random variable */
515 greg 2.11 xrand = urand(ilhash(dimlist,ndims)+samplendx);
516 greg 2.15 if (specjitter < 1.)
517     xrand = .5 + specjitter*(xrand-.5);
518     } else {
519 greg 2.40 xrand = (n + frandom())/(double)nstarget;
520 greg 2.15 }
521 greg 2.11 SDerrorDetail[0] = '\0'; /* sample direction & coef. */
522 greg 2.15 bsdf_jitter(vsmp, ndp, ndp->sr_vpsa[0]);
523 greg 2.40 VCOPY(vinc, vsmp); /* to compare after */
524 greg 2.11 ec = SDsampComponent(&bsv, vsmp, xrand, dcp);
525 greg 2.1 if (ec)
526 greg 2.2 objerror(ndp->mp, USER, transSDError(ec));
527 greg 2.11 if (bsv.cieY <= FTINY) /* zero component? */
528 greg 2.1 break;
529 greg 2.40 if (hasthru) { /* check for view ray */
530     double dx = vinc[0] + vsmp[0];
531     double dy = vinc[1] + vsmp[1];
532     if (dx*dx + dy*dy <= ndp->sr_vpsa[0]*ndp->sr_vpsa[0])
533     continue; /* exclude view sample */
534     }
535     /* map non-view sample->world */
536 greg 2.4 if (SDmapDir(sr.rdir, ndp->fromloc, vsmp) != SDEnone)
537 greg 2.1 break;
538     /* spawn a specular ray */
539     if (nstarget > 1)
540     bsv.cieY /= (double)nstarget;
541 greg 2.11 cvt_sdcolor(sr.rcoef, &bsv); /* use sample color */
542 greg 2.40 if (xmit) /* apply pattern on transmit */
543 greg 2.1 multcolor(sr.rcoef, ndp->pr->pcol);
544     if (rayorigin(&sr, SPECULAR, ndp->pr, sr.rcoef) < 0) {
545 greg 2.48 if (!n & (nstarget > 1)) {
546 greg 2.49 n = nstarget; /* avoid infinitue loop */
547 greg 2.48 nstarget = nstarget*sr.rweight/minweight;
548 greg 2.49 if (n == nstarget) break;
549 greg 2.48 n = -1; /* moved target */
550     }
551     continue; /* try again */
552 greg 2.1 }
553 greg 2.40 if (xmit && ndp->thick != 0) /* need to offset origin? */
554 greg 2.5 VSUM(sr.rorg, sr.rorg, ndp->pr->ron, -ndp->thick);
555 greg 2.1 rayvalue(&sr); /* send & evaluate sample */
556     multcolor(sr.rcol, sr.rcoef);
557     addcolor(ndp->pr->rcol, sr.rcol);
558 greg 2.40 ++nsent;
559 greg 2.1 }
560     return(nsent);
561     }
562    
563     /* Sample non-diffuse components of BSDF */
564     static int
565     sample_sdf(BSDFDAT *ndp, int sflags)
566     {
567 greg 2.46 int hasthru = (sflags == SDsampSpT &&
568 greg 2.47 !(ndp->pr->crtype & (SPECULAR|AMBIENT))
569     && bright(ndp->cthru) > FTINY);
570 greg 2.1 int n, ntotal = 0;
571 greg 2.40 double b = 0;
572 greg 2.1 SDSpectralDF *dfp;
573     COLORV *unsc;
574    
575     if (sflags == SDsampSpT) {
576 greg 2.39 unsc = ndp->tunsamp;
577 greg 2.22 if (ndp->pr->rod > 0)
578     dfp = (ndp->sd->tf != NULL) ? ndp->sd->tf : ndp->sd->tb;
579     else
580     dfp = (ndp->sd->tb != NULL) ? ndp->sd->tb : ndp->sd->tf;
581 greg 2.1 } else /* sflags == SDsampSpR */ {
582 greg 2.39 unsc = ndp->runsamp;
583 greg 2.31 if (ndp->pr->rod > 0)
584 greg 2.1 dfp = ndp->sd->rf;
585 greg 2.31 else
586 greg 2.1 dfp = ndp->sd->rb;
587     }
588 greg 2.40 setcolor(unsc, 0, 0, 0);
589 greg 2.1 if (dfp == NULL) /* no specular component? */
590     return(0);
591 greg 2.40
592     if (hasthru) { /* separate view sample? */
593     RAY tr;
594     if (rayorigin(&tr, TRANS, ndp->pr, ndp->cthru) == 0) {
595     VCOPY(tr.rdir, ndp->pr->rdir);
596     rayvalue(&tr);
597     multcolor(tr.rcol, tr.rcoef);
598     addcolor(ndp->pr->rcol, tr.rcol);
599 greg 2.56 ndp->pr->rxt = ndp->pr->rot + raydistance(&tr);
600 greg 2.40 ++ntotal;
601     b = bright(ndp->cthru);
602     } else
603     hasthru = 0;
604     }
605 greg 2.43 if (dfp->maxHemi - b <= FTINY) { /* have specular to sample? */
606 greg 2.40 b = 0;
607     } else {
608     FVECT vjit;
609     bsdf_jitter(vjit, ndp, ndp->sr_vpsa[1]);
610     b = SDdirectHemi(vjit, sflags, ndp->sd) - b;
611     if (b < 0) b = 0;
612     }
613     if (b <= specthresh+FTINY) { /* below sampling threshold? */
614     if (b > FTINY) { /* XXX no color from BSDF */
615 greg 2.1 if (sflags == SDsampSpT) {
616 greg 2.39 copycolor(unsc, ndp->pr->pcol);
617 greg 2.40 scalecolor(unsc, b);
618 greg 2.1 } else /* no pattern on reflection */
619 greg 2.40 setcolor(unsc, b, b, b);
620 greg 2.1 }
621 greg 2.40 return(ntotal);
622 greg 2.1 }
623 greg 2.41 dimlist[ndims] = (int)(size_t)ndp->mp; /* else sample specular */
624     ndims += 2;
625 greg 2.1 for (n = dfp->ncomp; n--; ) { /* loop over components */
626     dimlist[ndims-1] = n + 9438;
627     ntotal += sample_sdcomp(ndp, &dfp->comp[n], sflags==SDsampSpT);
628     }
629     ndims -= 2;
630     return(ntotal);
631     }
632    
633     /* Color a ray that hit a BSDF material */
634     int
635     m_bsdf(OBJREC *m, RAY *r)
636     {
637 greg 2.50 int hasthick = (m->otype == MAT_BSDF);
638 greg 2.6 int hitfront;
639 greg 2.1 COLOR ctmp;
640     SDError ec;
641 greg 2.5 FVECT upvec, vtmp;
642 greg 2.1 MFUNC *mf;
643     BSDFDAT nd;
644     /* check arguments */
645 greg 2.50 if ((m->oargs.nsargs < hasthick+5) | (m->oargs.nfargs > 9) |
646 greg 2.1 (m->oargs.nfargs % 3))
647     objerror(m, USER, "bad # arguments");
648 greg 2.6 /* record surface struck */
649 greg 2.9 hitfront = (r->rod > 0);
650 greg 2.1 /* load cal file */
651 greg 2.50 mf = hasthick ? getfunc(m, 5, 0x1d, 1)
652     : getfunc(m, 4, 0xe, 1) ;
653 greg 2.25 setfunc(m, r);
654 greg 2.50 nd.thick = 0; /* set thickness */
655     if (hasthick) {
656     nd.thick = evalue(mf->ep[0]);
657     if ((-FTINY <= nd.thick) & (nd.thick <= FTINY))
658     nd.thick = 0;
659     }
660 greg 2.26 /* check backface visibility */
661     if (!hitfront & !backvis) {
662     raytrans(r);
663     return(1);
664     }
665 greg 2.5 /* check other rays to pass */
666 greg 2.34 if (nd.thick != 0 && (r->crtype & SHADOW ||
667     !(r->crtype & (SPECULAR|AMBIENT)) ||
668 greg 2.29 (nd.thick > 0) ^ hitfront)) {
669 greg 2.5 raytrans(r); /* hide our proxy */
670 greg 2.1 return(1);
671     }
672 greg 2.51 if (hasthick && r->crtype & SHADOW) /* early shadow check #1 */
673     return(1);
674 greg 2.31 nd.mp = m;
675     nd.pr = r;
676 greg 2.5 /* get BSDF data */
677 greg 2.50 nd.sd = loadBSDF(m->oargs.sarg[hasthick]);
678 greg 2.51 /* early shadow check #2 */
679 greg 2.55 if (r->crtype & SHADOW && (nd.sd->tf == NULL) & (nd.sd->tb == NULL)) {
680     SDfreeCache(nd.sd);
681 greg 2.34 return(1);
682 greg 2.55 }
683 greg 2.63 /* diffuse components */
684 greg 2.6 if (hitfront) {
685 greg 2.31 cvt_sdcolor(nd.rdiff, &nd.sd->rLambFront);
686     if (m->oargs.nfargs >= 3) {
687     setcolor(ctmp, m->oargs.farg[0],
688 greg 2.1 m->oargs.farg[1],
689     m->oargs.farg[2]);
690 greg 2.31 addcolor(nd.rdiff, ctmp);
691     }
692 greg 2.63 cvt_sdcolor(nd.tdiff, &nd.sd->tLambFront);
693 greg 2.1 } else {
694 greg 2.31 cvt_sdcolor(nd.rdiff, &nd.sd->rLambBack);
695     if (m->oargs.nfargs >= 6) {
696     setcolor(ctmp, m->oargs.farg[3],
697 greg 2.1 m->oargs.farg[4],
698     m->oargs.farg[5]);
699 greg 2.31 addcolor(nd.rdiff, ctmp);
700     }
701 greg 2.63 cvt_sdcolor(nd.tdiff, &nd.sd->tLambBack);
702 greg 2.1 }
703 greg 2.63 if (m->oargs.nfargs >= 9) { /* add diffuse transmittance? */
704 greg 2.31 setcolor(ctmp, m->oargs.farg[6],
705 greg 2.1 m->oargs.farg[7],
706     m->oargs.farg[8]);
707 greg 2.31 addcolor(nd.tdiff, ctmp);
708     }
709 greg 2.1 /* get modifiers */
710     raytexture(r, m->omod);
711     /* modify diffuse values */
712     multcolor(nd.rdiff, r->pcol);
713     multcolor(nd.tdiff, r->pcol);
714     /* get up vector */
715 greg 2.50 upvec[0] = evalue(mf->ep[hasthick+0]);
716     upvec[1] = evalue(mf->ep[hasthick+1]);
717     upvec[2] = evalue(mf->ep[hasthick+2]);
718 greg 2.1 /* return to world coords */
719 greg 2.21 if (mf->fxp != &unitxf) {
720     multv3(upvec, upvec, mf->fxp->xfm);
721     nd.thick *= mf->fxp->sca;
722 greg 2.1 }
723 greg 2.23 if (r->rox != NULL) {
724     multv3(upvec, upvec, r->rox->f.xfm);
725     nd.thick *= r->rox->f.sca;
726     }
727 greg 2.1 raynormal(nd.pnorm, r);
728     /* compute local BSDF xform */
729     ec = SDcompXform(nd.toloc, nd.pnorm, upvec);
730     if (!ec) {
731 greg 2.4 nd.vray[0] = -r->rdir[0];
732     nd.vray[1] = -r->rdir[1];
733     nd.vray[2] = -r->rdir[2];
734     ec = SDmapDir(nd.vray, nd.toloc, nd.vray);
735 greg 2.20 }
736 greg 2.19 if (ec) {
737     objerror(m, WARNING, "Illegal orientation vector");
738 greg 2.55 SDfreeCache(nd.sd);
739 greg 2.19 return(1);
740 greg 2.1 }
741 greg 2.50 setcolor(nd.cthru, 0, 0, 0); /* consider through component */
742 greg 2.61 setcolor(nd.cthru_surr, 0, 0, 0);
743 greg 2.52 if (m->otype == MAT_ABSDF) {
744 greg 2.50 compute_through(&nd);
745     if (r->crtype & SHADOW) {
746     RAY tr; /* attempt to pass shadow ray */
747 greg 2.55 SDfreeCache(nd.sd);
748 greg 2.50 if (rayorigin(&tr, TRANS, r, nd.cthru) < 0)
749     return(1); /* no through component */
750     VCOPY(tr.rdir, r->rdir);
751     rayvalue(&tr); /* transmit with scaling */
752     multcolor(tr.rcol, tr.rcoef);
753     copycolor(r->rcol, tr.rcol);
754     return(1); /* we're done */
755     }
756 greg 2.34 }
757     ec = SDinvXform(nd.fromloc, nd.toloc);
758     if (!ec) /* determine BSDF resolution */
759     ec = SDsizeBSDF(nd.sr_vpsa, nd.vray, NULL,
760     SDqueryMin+SDqueryMax, nd.sd);
761 greg 2.20 if (ec)
762     objerror(m, USER, transSDError(ec));
763    
764 greg 2.9 nd.sr_vpsa[0] = sqrt(nd.sr_vpsa[0]);
765     nd.sr_vpsa[1] = sqrt(nd.sr_vpsa[1]);
766 greg 2.6 if (!hitfront) { /* perturb normal towards hit */
767 greg 2.1 nd.pnorm[0] = -nd.pnorm[0];
768     nd.pnorm[1] = -nd.pnorm[1];
769     nd.pnorm[2] = -nd.pnorm[2];
770     }
771     /* sample reflection */
772     sample_sdf(&nd, SDsampSpR);
773     /* sample transmission */
774     sample_sdf(&nd, SDsampSpT);
775     /* compute indirect diffuse */
776 greg 2.39 copycolor(ctmp, nd.rdiff);
777     addcolor(ctmp, nd.runsamp);
778     if (bright(ctmp) > FTINY) { /* ambient from reflection */
779 greg 2.6 if (!hitfront)
780 greg 2.1 flipsurface(r);
781     multambient(ctmp, r, nd.pnorm);
782     addcolor(r->rcol, ctmp);
783 greg 2.6 if (!hitfront)
784 greg 2.1 flipsurface(r);
785     }
786 greg 2.39 copycolor(ctmp, nd.tdiff);
787     addcolor(ctmp, nd.tunsamp);
788     if (bright(ctmp) > FTINY) { /* ambient from other side */
789 greg 2.1 FVECT bnorm;
790 greg 2.6 if (hitfront)
791 greg 2.1 flipsurface(r);
792     bnorm[0] = -nd.pnorm[0];
793     bnorm[1] = -nd.pnorm[1];
794     bnorm[2] = -nd.pnorm[2];
795 greg 2.9 if (nd.thick != 0) { /* proxy with offset? */
796 greg 2.5 VCOPY(vtmp, r->rop);
797 greg 2.18 VSUM(r->rop, vtmp, r->ron, nd.thick);
798 greg 2.5 multambient(ctmp, r, bnorm);
799     VCOPY(r->rop, vtmp);
800     } else
801     multambient(ctmp, r, bnorm);
802 greg 2.1 addcolor(r->rcol, ctmp);
803 greg 2.6 if (hitfront)
804 greg 2.1 flipsurface(r);
805     }
806     /* add direct component */
807 greg 2.22 if ((bright(nd.tdiff) <= FTINY) & (nd.sd->tf == NULL) &
808     (nd.sd->tb == NULL)) {
809 greg 2.5 direct(r, dir_brdf, &nd); /* reflection only */
810 greg 2.9 } else if (nd.thick == 0) {
811 greg 2.5 direct(r, dir_bsdf, &nd); /* thin surface scattering */
812     } else {
813     direct(r, dir_brdf, &nd); /* reflection first */
814     VCOPY(vtmp, r->rop); /* offset for transmitted */
815     VSUM(r->rop, vtmp, r->ron, -nd.thick);
816 greg 2.6 direct(r, dir_btdf, &nd); /* separate transmission */
817 greg 2.5 VCOPY(r->rop, vtmp);
818     }
819 greg 2.1 /* clean up */
820     SDfreeCache(nd.sd);
821     return(1);
822     }