ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/m_bsdf.c
Revision: 2.60
Committed: Wed Jun 10 16:00:32 2020 UTC (4 years, 11 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.59: +12 -15 lines
Log Message: 
Increased number of sampling directions for better peak evaluation
(thanks to David G-M for implementation and testing)

File Contents

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