ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/m_bsdf.c
(Generate patch)

Comparing ray/src/rt/m_bsdf.c (file contents):
Revision 2.67 by greg, Tue Dec 7 23:49:50 2021 UTC vs.
Revision 2.73 by greg, Wed Apr 17 16:46:00 2024 UTC

# Line 86 | Line 86 | typedef struct {
86          RREAL   toloc[3][3];    /* world to local BSDF coords */
87          RREAL   fromloc[3][3];  /* local BSDF coords to world */
88          double  thick;          /* surface thickness */
89 <        COLOR   cthru;          /* "through" component for MAT_ABSDF */
90 <        COLOR   cthru_surr;     /* surround for "through" component */
89 >        SCOLOR  cthru;          /* "through" component for MAT_ABSDF */
90 >        SCOLOR  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   tdiff;          /* diffuse transmission */
95 <        COLOR   tunsamp;        /* BSDF hemispherical transmission */
92 >        SCOLOR  rdiff;          /* diffuse reflection */
93 >        SCOLOR  runsamp;        /* BSDF hemispherical reflection */
94 >        SCOLOR  tdiff;          /* diffuse transmission */
95 >        SCOLOR  tunsamp;        /* BSDF hemispherical transmission */
96   }  BSDFDAT;             /* BSDF material data */
97  
98 < #define cvt_sdcolor(cv, svp)    ccy2rgb(&(svp)->spec, (svp)->cieY, cv)
98 > #define cvt_sdcolor(scv, svp)   ccy2scolor(&(svp)->spec, (svp)->cieY, scv)
99  
100   typedef struct {
101          double  vy;             /* brightness (for sorting) */
102          FVECT   tdir;           /* through sample direction (normalized) */
103 <        COLOR   vcol;           /* BTDF color */
103 >        SCOLOR  vcol;           /* BTDF color */
104   }  PEAKSAMP;            /* BTDF peak sample */
105  
106   /* Comparison function to put near-peak values in descending order */
# Line 135 | Line 135 | compute_through(BSDFDAT *ndp)
135          FVECT           pdir;
136          double          tomega, srchrad;
137          double          tomsum, tomsurr;
138 <        COLOR           vpeak, vsurr;
138 >        SCOLOR          vpeak, vsurr, btdiff;
139          double          vypeak;
140          int             i, ns;
141          SDError         ec;
# Line 147 | Line 147 | compute_through(BSDFDAT *ndp)
147  
148          if (dfp == NULL)
149                  return;                         /* no specular transmission */
150 <        if (bright(ndp->pr->pcol) <= FTINY)
150 >        if (sintens(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++) {
# Line 165 | Line 165 | compute_through(BSDFDAT *ndp)
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);
168 >        scolorblack(vpeak);
169 >        scolorblack(vsurr);
170          vypeak = tomsum = tomsurr = 0;          /* combine top unique values */
171          ns = 0;
172          for (i = 0; i < NDIR2CHECK; i++) {
# Line 178 | Line 178 | compute_through(BSDFDAT *ndp)
178                  if (ec)
179                          goto baderror;
180  
181 <                scalecolor(psamp[i].vcol, tomega);
181 >                scalescolor(psamp[i].vcol, tomega);
182                                                  /* not part of peak? */
183                  if (tomega > 1.5*dfp->minProjSA ||
184                                          vypeak > 8.*psamp[i].vy*ns) {
185                          if (!i) return;         /* abort */
186 <                        addcolor(vsurr, psamp[i].vcol);
186 >                        saddscolor(vsurr, psamp[i].vcol);
187                          tomsurr += tomega;
188                          continue;
189                  }
190 <                addcolor(vpeak, psamp[i].vcol);
190 >                saddscolor(vpeak, psamp[i].vcol);
191                  tomsum += tomega;
192                  vypeak += psamp[i].vy;
193                  ++ns;
194          }
195 <        if (tomsurr <= FTINY)                   /* no surround implies no peak */
195 >        if (tomsurr < 0.2*tomsum)               /* insufficient surround? */
196                  return;
197 <        if ((vypeak/ns - (ndp->vray[2] > 0 ? ndp->sd->tLambFront.cieY
198 <                        : ndp->sd->tLambBack.cieY)*(1./PI))*tomsum < .0005)
199 <                return;                         /* < 0.05% transmission */
200 <        copycolor(ndp->cthru, vpeak);           /* already scaled by omega */
201 <        multcolor(ndp->cthru, ndp->pr->pcol);   /* modify by pattern */
202 <        scalecolor(vsurr, 1./tomsurr);          /* surround is avg. BTDF */
203 <        copycolor(ndp->cthru_surr, vsurr);
204 <        multcolor(ndp->cthru_surr, ndp->pr->pcol);
197 >        scalescolor(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 >        scalescolor(btdiff, (1./PI));
203 >        for (i = NCSAMP; i--; ) {               /* remove diffuse contrib. */
204 >                if ((vpeak[i] -= tomsum*btdiff[i]) < 0)
205 >                        vpeak[i] = 0;
206 >                if ((vsurr[i] -= btdiff[i]) < 0)
207 >                        vsurr[i] = 0;
208 >        }
209 >        if (pbright(vpeak) < .0005)             /* < 0.05% specular? */
210 >                return;
211 >        smultscolor(vsurr, ndp->pr->pcol);      /* modify by pattern */
212 >        smultscolor(vpeak, ndp->pr->pcol);
213 >        copyscolor(ndp->cthru_surr, vsurr);
214 >        copyscolor(ndp->cthru, vpeak);
215          return;
216   baderror:
217          objerror(ndp->mp, USER, transSDError(ec));
# Line 224 | Line 234 | bsdf_jitter(FVECT vres, BSDFDAT *ndp, double sr_psa)
234  
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)
237 > direct_specular_OK(SCOLOR scval, 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;
243 >        double  tsr, sd[2];
244 >        SCOLOR  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);
250 >        scolorblack(scval);
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) && sintens(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 (dx*dx + dy*dy <= (2.5*4./PI)*(tomega + dfp->minProjSA +
264 +                                                2.*sqrt(tomega*dfp->minProjSA))) {
265 +                        if (sintens(ndp->cthru_surr) <= FTINY)
266 +                                return(0);
267 +                        copyscolor(scval, 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:
# Line 269 | Line 296 | direct_specular_OK(COLOR cval, FVECT ldir, double omeg
296                  cvt_sdcolor(cdiff, &sv);
297          } else {
298                  diffY = 0;
299 <                setcolor(cdiff,  0, 0, 0);
299 >                scolorblack(cdiff);
300          }
274 –                                        /* check indirect over-counting */
275 –        if ((vsrc[2] > 0) ^ (ndp->vray[2] > 0) && bright(ndp->cthru) > FTINY) {
276 –                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 –                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 –                        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 –        }
301          ec = SDsizeBSDF(&tomega, ndp->vray, vsrc, SDqueryMin, ndp->sd);
302          if (ec)
303                  goto baderror;
# Line 312 | Line 322 | direct_specular_OK(COLOR cval, FVECT ldir, double omeg
322                  if (tomega2 < .12*tomega)
323                          continue;       /* not safe to include */
324                  cvt_sdcolor(csmp, &sv);
325 <                addcolor(cval, csmp);
325 >                saddscolor(scval, csmp);
326                  ++scnt;
327          }
328          if (!scnt)                      /* no valid specular samples? */
329                  return(0);
330  
331 <        sf = 1./scnt;                   /* weighted average BSDF */
322 <        scalecolor(cval, sf);
331 >        scalescolor(scval, 1./scnt);    /* weighted average BSDF */
332                                          /* subtract diffuse contribution */
333 <        for (i = 3*(diffY > FTINY); i--; )
334 <                if ((colval(cval,i) -= colval(cdiff,i)) < 0)
335 <                        colval(cval,i) = 0;
333 >        for (i = NCSAMP*(diffY > FTINY); i--; )
334 >                if ((scval[i] -= cdiff[i]) < 0)
335 >                        scval[i] = 0;
336          return(1);
337   baderror:
338          objerror(ndp->mp, USER, transSDError(ec));
# Line 333 | Line 342 | baderror:
342   /* Compute source contribution for BSDF (reflected & transmitted) */
343   static void
344   dir_bsdf(
345 <        COLOR  cval,                    /* returned coefficient */
345 >        SCOLOR  scval,                  /* returned coefficient */
346          void  *nnp,                     /* material data */
347          FVECT  ldir,                    /* light source direction */
348          double  omega                   /* light source size */
# Line 342 | Line 351 | dir_bsdf(
351          BSDFDAT         *np = (BSDFDAT *)nnp;
352          double          ldot;
353          double          dtmp;
354 <        COLOR           ctmp;
354 >        SCOLOR          sctmp;
355  
356 <        setcolor(cval,  0, 0, 0);
356 >        scolorblack(scval);
357  
358          ldot = DOT(np->pnorm, ldir);
359          if ((-FTINY <= ldot) & (ldot <= FTINY))
360                  return;
361  
362 <        if (ldot > 0 && bright(np->rdiff) > FTINY) {
362 >        if (ldot > 0 && sintens(np->rdiff) > FTINY) {
363                  /*
364                   *  Compute diffuse reflected component
365                   */
366 <                copycolor(ctmp, np->rdiff);
366 >                copyscolor(sctmp, np->rdiff);
367                  dtmp = ldot * omega * (1./PI);
368 <                scalecolor(ctmp, dtmp);
369 <                addcolor(cval, ctmp);
368 >                scalescolor(sctmp, dtmp);
369 >                saddscolor(scval, sctmp);
370          }
371 <        if (ldot < 0 && bright(np->tdiff) > FTINY) {
371 >        if (ldot < 0 && sintens(np->tdiff) > FTINY) {
372                  /*
373                   *  Compute diffuse transmission
374                   */
375 <                copycolor(ctmp, np->tdiff);
375 >                copyscolor(sctmp, np->tdiff);
376                  dtmp = -ldot * omega * (1./PI);
377 <                scalecolor(ctmp, dtmp);
378 <                addcolor(cval, ctmp);
377 >                scalescolor(sctmp, dtmp);
378 >                saddscolor(scval, sctmp);
379          }
380          if (ambRayInPmap(np->pr))
381                  return;         /* specular already in photon map */
382          /*
383           *  Compute specular scattering coefficient using BSDF
384           */
385 <        if (!direct_specular_OK(ctmp, ldir, omega, np))
385 >        if (!direct_specular_OK(sctmp, ldir, omega, np))
386                  return;
387          if (ldot < 0) {         /* pattern for specular transmission */
388 <                multcolor(ctmp, np->pr->pcol);
388 >                smultscolor(sctmp, np->pr->pcol);
389                  dtmp = -ldot * omega;
390          } else
391                  dtmp = ldot * omega;
392 <        scalecolor(ctmp, dtmp);
393 <        addcolor(cval, ctmp);
392 >        scalescolor(sctmp, dtmp);
393 >        saddscolor(scval, sctmp);
394   }
395  
396   /* Compute source contribution for BSDF (reflected only) */
397   static void
398   dir_brdf(
399 <        COLOR  cval,                    /* returned coefficient */
399 >        SCOLOR  scval,                  /* returned coefficient */
400          void  *nnp,                     /* material data */
401          FVECT  ldir,                    /* light source direction */
402          double  omega                   /* light source size */
# Line 396 | Line 405 | dir_brdf(
405          BSDFDAT         *np = (BSDFDAT *)nnp;
406          double          ldot;
407          double          dtmp;
408 <        COLOR           ctmp, ctmp1, ctmp2;
408 >        SCOLOR          sctmp;
409  
410 <        setcolor(cval,  0, 0, 0);
410 >        scolorblack(scval);
411  
412          ldot = DOT(np->pnorm, ldir);
413          
414          if (ldot <= FTINY)
415                  return;
416  
417 <        if (bright(np->rdiff) > FTINY) {
417 >        if (sintens(np->rdiff) > FTINY) {
418                  /*
419                   *  Compute diffuse reflected component
420                   */
421 <                copycolor(ctmp, np->rdiff);
421 >                copyscolor(sctmp, np->rdiff);
422                  dtmp = ldot * omega * (1./PI);
423 <                scalecolor(ctmp, dtmp);
424 <                addcolor(cval, ctmp);
423 >                scalescolor(sctmp, dtmp);
424 >                saddscolor(scval, sctmp);
425          }
426          if (ambRayInPmap(np->pr))
427                  return;         /* specular already in photon map */
428          /*
429           *  Compute specular reflection coefficient using BSDF
430           */
431 <        if (!direct_specular_OK(ctmp, ldir, omega, np))
431 >        if (!direct_specular_OK(sctmp, ldir, omega, np))
432                  return;
433          dtmp = ldot * omega;
434 <        scalecolor(ctmp, dtmp);
435 <        addcolor(cval, ctmp);
434 >        scalescolor(sctmp, dtmp);
435 >        saddscolor(scval, sctmp);
436   }
437  
438   /* Compute source contribution for BSDF (transmitted only) */
439   static void
440   dir_btdf(
441 <        COLOR  cval,                    /* returned coefficient */
441 >        SCOLOR  scval,                  /* returned coefficient */
442          void  *nnp,                     /* material data */
443          FVECT  ldir,                    /* light source direction */
444          double  omega                   /* light source size */
# Line 438 | Line 447 | dir_btdf(
447          BSDFDAT         *np = (BSDFDAT *)nnp;
448          double          ldot;
449          double          dtmp;
450 <        COLOR           ctmp;
450 >        SCOLOR          sctmp;
451  
452 <        setcolor(cval,  0, 0, 0);
452 >        scolorblack(scval);
453  
454          ldot = DOT(np->pnorm, ldir);
455  
456          if (ldot >= -FTINY)
457                  return;
458  
459 <        if (bright(np->tdiff) > FTINY) {
459 >        if (sintens(np->tdiff) > FTINY) {
460                  /*
461                   *  Compute diffuse transmission
462                   */
463 <                copycolor(ctmp, np->tdiff);
463 >                copyscolor(sctmp, np->tdiff);
464                  dtmp = -ldot * omega * (1./PI);
465 <                scalecolor(ctmp, dtmp);
466 <                addcolor(cval, ctmp);
465 >                scalescolor(sctmp, dtmp);
466 >                saddscolor(scval, sctmp);
467          }
468          if (ambRayInPmap(np->pr))
469                  return;         /* specular already in photon map */
470          /*
471           *  Compute specular scattering coefficient using BSDF
472           */
473 <        if (!direct_specular_OK(ctmp, ldir, omega, np))
473 >        if (!direct_specular_OK(sctmp, ldir, omega, np))
474                  return;
475                                          /* full pattern on transmission */
476 <        multcolor(ctmp, np->pr->pcol);
476 >        smultscolor(sctmp, np->pr->pcol);
477          dtmp = -ldot * omega;
478 <        scalecolor(ctmp, dtmp);
479 <        addcolor(cval, ctmp);
478 >        scalescolor(sctmp, dtmp);
479 >        saddscolor(scval, sctmp);
480   }
481  
482   /* Sample separate BSDF component */
# Line 476 | Line 485 | sample_sdcomp(BSDFDAT *ndp, SDComponent *dcp, int xmit
485   {
486          const int       hasthru = (xmit &&
487                                          !(ndp->pr->crtype & (SPECULAR|AMBIENT))
488 <                                        && bright(ndp->cthru) > FTINY);
488 >                                        && sintens(ndp->cthru) > FTINY);
489          int             nstarget = 1;
490          int             nsent = 0;
491          int             n;
# Line 521 | Line 530 | sample_sdcomp(BSDFDAT *ndp, SDComponent *dcp, int xmit
530                          bsv.cieY /= (double)nstarget;
531                  cvt_sdcolor(sr.rcoef, &bsv);    /* use sample color */
532                  if (xmit)                       /* apply pattern on transmit */
533 <                        multcolor(sr.rcoef, ndp->pr->pcol);
534 <                if (rayorigin(&sr, SPECULAR, ndp->pr, sr.rcoef) < 0) {
533 >                        smultscolor(sr.rcoef, ndp->pr->pcol);
534 >                if (rayorigin(&sr, xmit ? TSPECULAR : RSPECULAR, ndp->pr, sr.rcoef) < 0) {
535                          if (!n & (nstarget > 1)) {
536                                  n = nstarget;   /* avoid infinitue loop */
537 <                                nstarget = nstarget*sr.rweight/minweight;
537 >                                nstarget = nstarget*sr.rweight/(minweight + 1e-20);
538                                  if (n == nstarget) break;
539                                  n = -1;         /* moved target */
540                          }
# Line 534 | Line 543 | sample_sdcomp(BSDFDAT *ndp, SDComponent *dcp, int xmit
543                  if (xmit && ndp->thick != 0)    /* need to offset origin? */
544                          VSUM(sr.rorg, sr.rorg, ndp->pr->ron, -ndp->thick);
545                  rayvalue(&sr);                  /* send & evaluate sample */
546 <                multcolor(sr.rcol, sr.rcoef);
547 <                addcolor(ndp->pr->rcol, sr.rcol);
546 >                smultscolor(sr.rcol, sr.rcoef);
547 >                saddscolor(ndp->pr->rcol, sr.rcol);
548                  ++nsent;
549          }
550          return(nsent);
# Line 547 | Line 556 | sample_sdf(BSDFDAT *ndp, int sflags)
556   {
557          int             hasthru = (sflags == SDsampSpT &&
558                                          !(ndp->pr->crtype & (SPECULAR|AMBIENT))
559 <                                        && bright(ndp->cthru) > FTINY);
559 >                                        && sintens(ndp->cthru) > FTINY);
560          int             n, ntotal = 0;
561          double          b = 0;
562          SDSpectralDF    *dfp;
# Line 566 | Line 575 | sample_sdf(BSDFDAT *ndp, int sflags)
575                  else
576                          dfp = ndp->sd->rb;
577          }
578 <        setcolor(unsc,  0, 0, 0);
578 >        scolorblack(unsc);
579          if (dfp == NULL)                        /* no specular component? */
580                  return(0);
581  
# Line 575 | Line 584 | sample_sdf(BSDFDAT *ndp, int sflags)
584                  if (rayorigin(&tr, TRANS, ndp->pr, ndp->cthru) == 0) {
585                          VCOPY(tr.rdir, ndp->pr->rdir);
586                          rayvalue(&tr);
587 <                        multcolor(tr.rcol, tr.rcoef);
588 <                        addcolor(ndp->pr->rcol, tr.rcol);
587 >                        smultscolor(tr.rcol, tr.rcoef);
588 >                        saddscolor(ndp->pr->rcol, tr.rcol);
589                          ndp->pr->rxt = ndp->pr->rot + raydistance(&tr);
590                          ++ntotal;
591 <                        b = bright(ndp->cthru);
591 >                        b = pbright(ndp->cthru);
592                  } else
593                          hasthru = 0;
594          }
# Line 589 | Line 598 | sample_sdf(BSDFDAT *ndp, int sflags)
598                  FVECT   vjit;
599                  bsdf_jitter(vjit, ndp, ndp->sr_vpsa[1]);
600                  b = SDdirectHemi(vjit, sflags, ndp->sd) - b;
601 <                if (b < 0) b = 0;
601 >                b *= (b > 0);
602          }
603          if (b <= specthresh+FTINY) {            /* below sampling threshold? */
604                  if (b > FTINY) {                /* XXX no color from BSDF */
605                          if (sflags == SDsampSpT) {
606 <                                copycolor(unsc, ndp->pr->pcol);
607 <                                scalecolor(unsc, b);
606 >                                copyscolor(unsc, ndp->pr->pcol);
607 >                                scalescolor(unsc, b);
608                          } else                  /* no pattern on reflection */
609 <                                setcolor(unsc, b, b, b);
609 >                                setscolor(unsc, b, b, b);
610                  }
611                  return(ntotal);
612          }
# Line 617 | Line 626 | m_bsdf(OBJREC *m, RAY *r)
626   {
627          int     hasthick = (m->otype == MAT_BSDF);
628          int     hitfront;
629 <        COLOR   ctmp;
629 >        SCOLOR  sctmp;
630          SDError ec;
631          FVECT   upvec, vtmp;
632          MFUNC   *mf;
# Line 665 | Line 674 | m_bsdf(OBJREC *m, RAY *r)
674          if (hitfront) {
675                  cvt_sdcolor(nd.rdiff, &nd.sd->rLambFront);
676                  if (m->oargs.nfargs >= 3) {
677 <                        setcolor(ctmp, m->oargs.farg[0],
677 >                        setscolor(sctmp, m->oargs.farg[0],
678                                          m->oargs.farg[1],
679                                          m->oargs.farg[2]);
680 <                        addcolor(nd.rdiff, ctmp);
680 >                        saddscolor(nd.rdiff, sctmp);
681                  }
682                  cvt_sdcolor(nd.tdiff, &nd.sd->tLambFront);
683          } else {
684                  cvt_sdcolor(nd.rdiff, &nd.sd->rLambBack);
685                  if (m->oargs.nfargs >= 6) {
686 <                        setcolor(ctmp, m->oargs.farg[3],
686 >                        setscolor(sctmp, m->oargs.farg[3],
687                                          m->oargs.farg[4],
688                                          m->oargs.farg[5]);
689 <                        addcolor(nd.rdiff, ctmp);
689 >                        saddscolor(nd.rdiff, sctmp);
690                  }
691                  cvt_sdcolor(nd.tdiff, &nd.sd->tLambBack);
692          }
693          if (m->oargs.nfargs >= 9) {             /* add diffuse transmittance? */
694 <                setcolor(ctmp, m->oargs.farg[6],
694 >                setscolor(sctmp, m->oargs.farg[6],
695                                  m->oargs.farg[7],
696                                  m->oargs.farg[8]);
697 <                addcolor(nd.tdiff, ctmp);
697 >                saddscolor(nd.tdiff, sctmp);
698          }
699                                                  /* get modifiers */
700          raytexture(r, m->omod);
701                                                  /* modify diffuse values */
702 <        multcolor(nd.rdiff, r->pcol);
703 <        multcolor(nd.tdiff, r->pcol);
702 >        smultscolor(nd.rdiff, r->pcol);
703 >        smultscolor(nd.tdiff, r->pcol);
704                                                  /* get up vector */
705          upvec[0] = evalue(mf->ep[hasthick+0]);
706          upvec[1] = evalue(mf->ep[hasthick+1]);
# Line 719 | Line 728 | m_bsdf(OBJREC *m, RAY *r)
728                  SDfreeCache(nd.sd);
729                  return(1);
730          }
731 <        setcolor(nd.cthru, 0, 0, 0);            /* consider through component */
732 <        setcolor(nd.cthru_surr, 0, 0, 0);
731 >        scolorblack(nd.cthru);                  /* consider through component */
732 >        scolorblack(nd.cthru_surr);
733          if (m->otype == MAT_ABSDF) {
734                  compute_through(&nd);
735                  if (r->crtype & SHADOW) {
# Line 730 | Line 739 | m_bsdf(OBJREC *m, RAY *r)
739                                  return(1);      /* no through component */
740                          VCOPY(tr.rdir, r->rdir);
741                          rayvalue(&tr);          /* transmit with scaling */
742 <                        multcolor(tr.rcol, tr.rcoef);
743 <                        copycolor(r->rcol, tr.rcol);
742 >                        smultscolor(tr.rcol, tr.rcoef);
743 >                        copyscolor(r->rcol, tr.rcol);
744                          return(1);              /* we're done */
745                  }
746          }
# Line 754 | Line 763 | m_bsdf(OBJREC *m, RAY *r)
763                                                  /* sample transmission */
764          sample_sdf(&nd, SDsampSpT);
765                                                  /* compute indirect diffuse */
766 <        copycolor(ctmp, nd.rdiff);
767 <        addcolor(ctmp, nd.runsamp);
768 <        if (bright(ctmp) > FTINY) {             /* ambient from reflection */
769 <                if (!hitfront)
770 <                        flipsurface(r);
762 <                multambient(ctmp, r, nd.pnorm);
763 <                addcolor(r->rcol, ctmp);
764 <                if (!hitfront)
765 <                        flipsurface(r);
766 >        copyscolor(sctmp, nd.rdiff);
767 >        saddscolor(sctmp, nd.runsamp);
768 >        if (sintens(sctmp) > FTINY) {           /* ambient from reflection */
769 >                multambient(sctmp, r, nd.pnorm);
770 >                saddscolor(r->rcol, sctmp);
771          }
772 <        copycolor(ctmp, nd.tdiff);
773 <        addcolor(ctmp, nd.tunsamp);
774 <        if (bright(ctmp) > FTINY) {             /* ambient from other side */
772 >        copyscolor(sctmp, nd.tdiff);
773 >        saddscolor(sctmp, nd.tunsamp);
774 >        if (sintens(sctmp) > FTINY) {           /* ambient from other side */
775                  FVECT  bnorm;
771 –                if (hitfront)
772 –                        flipsurface(r);
776                  bnorm[0] = -nd.pnorm[0];
777                  bnorm[1] = -nd.pnorm[1];
778                  bnorm[2] = -nd.pnorm[2];
779                  if (nd.thick != 0) {            /* proxy with offset? */
780                          VCOPY(vtmp, r->rop);
781                          VSUM(r->rop, vtmp, r->ron, nd.thick);
782 <                        multambient(ctmp, r, bnorm);
782 >                        multambient(sctmp, r, bnorm);
783                          VCOPY(r->rop, vtmp);
784                  } else
785 <                        multambient(ctmp, r, bnorm);
786 <                addcolor(r->rcol, ctmp);
784 <                if (hitfront)
785 <                        flipsurface(r);
785 >                        multambient(sctmp, r, bnorm);
786 >                saddscolor(r->rcol, sctmp);
787          }
788                                                  /* add direct component */
789 <        if ((bright(nd.tdiff) <= FTINY) & (nd.sd->tf == NULL) &
790 <                                        (nd.sd->tb == NULL)) {
789 >        if ((nd.sd->tf == NULL) & (nd.sd->tb == NULL) &&
790 >                        sintens(nd.tdiff) <= FTINY) {
791                  direct(r, dir_brdf, &nd);       /* reflection only */
792          } else if (nd.thick == 0) {
793                  direct(r, dir_bsdf, &nd);       /* thin surface scattering */

Diff Legend

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