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

Comparing ray/src/rt/pmapmat.c (file contents):
Revision 2.18 by greg, Tue Jun 26 14:42:18 2018 UTC vs.
Revision 2.19 by rschregle, Tue Dec 4 21:58:46 2018 UTC

# Line 34 | Line 34 | static const char RCSid[] = "$Id$";
34   #define  SP_FLAT     010
35   #define  SP_BADU     040
36   #define  MLAMBDA     500
37 < #define  RINDEX    1.52
37 > #define  RINDEX      1.52
38   #define  FRESNE(ci)  (exp(-5.85*(ci)) - 0.00287989916)
39  
40  
# Line 59 | Line 59 | typedef struct {
59  
60   typedef struct {
61     OBJREC   *mp;
62 <   RAY      *pr;                
63 <   FVECT    pnorm;              
64 <   FVECT    vray;              
65 <   double   sr_vpsa [2];        
66 <   RREAL        toloc [3][3];  
67 <   RREAL        fromloc [3][3];
68 <   double   thick;              
62 >   RAY      *pr;
63 >   DATARRAY *dp;
64 >   COLOR    mcolor;
65 >   COLOR    rdiff;
66 >   COLOR    tdiff;
67 >   double   rspec;
68 >   double   trans;
69 >   double   tspec;
70 >   FVECT    pnorm;
71 >   double   pdot;
72 > }  BRDFDAT;
73 >
74 > typedef struct {
75 >   OBJREC   *mp;
76 >   RAY      *pr;
77 >   FVECT    pnorm;
78 >   FVECT    vray;
79 >   double   sr_vpsa [2];
80 >   RREAL    toloc [3][3];
81 >   RREAL    fromloc [3][3];
82 >   double   thick;
83     SDData   *sd;
84     COLOR           runsamp;
85     COLOR           rdiff;
# Line 206 | Line 220 | static int isoSpecPhotonScatter (NORMDAT *nd, RAY *ray
220     int      niter, i = 0;
221    
222     /* Set up sample coordinates */  
223 <   getperpendicular(u, nd -> pnorm, 1);  
223 >   getperpendicular(u, nd -> pnorm, 1);
224     fcross(v, nd -> pnorm, u);
225    
226     if (nd -> specfl & SP_REFL) {
# Line 240 | Line 254 | static int isoSpecPhotonScatter (NORMDAT *nd, RAY *ray
254           cosp = cos(d);
255           sinp = sin(d);
256           d2 = pmapRandom(scatterState);
257 <         d = d2 <= FTINY ? 1 : sqrt(-log(d2) * nd -> alpha2);        
257 >         d = d2 <= FTINY ? 1 : sqrt(-log(d2) * nd -> alpha2);
258          
259           for (i = 0; i < 3; i++)
260              rayOut -> rdir [i] = nd -> prdir [i] +
# Line 261 | Line 275 | static int isoSpecPhotonScatter (NORMDAT *nd, RAY *ray
275   static void diffPhotonScatter (FVECT normal, RAY* rayOut)
276   /* Generate cosine-weighted direction for diffuse ray */
277   {
278 <   const RREAL cosThetaSqr = pmapRandom(scatterState),
278 >   const RREAL cosThetaSqr = pmapRandom(scatterState),
279                 cosTheta = sqrt(cosThetaSqr),
280 <               sinTheta = sqrt(1 - cosThetaSqr),
281 <               phi = 2 * PI * pmapRandom(scatterState),
280 >               sinTheta = sqrt(1 - cosThetaSqr),
281 >               phi = 2 * PI * pmapRandom(scatterState),
282                 du = cos(phi) * sinTheta, dv = sin(phi) * sinTheta;
283     FVECT       u, v;
284     int         i = 0;
# Line 421 | Line 435 | static int normalPhotonScatter (OBJREC *mat, RAY *rayI
435        
436        if (hastexture) {
437           /* Perturb */
438 <         for (i = 0; i < 3; i++)
438 >         for (i = 0; i < 3; i++)
439              nd.prdir [i] = rayIn -> rdir [i] - rayIn -> pert [i];
440              
441 <         if (DOT(nd.prdir, rayIn -> ron) < -FTINY)
441 >         if (DOT(nd.prdir, rayIn -> ron) < -FTINY)
442              normalize(nd.prdir);
443           else VCOPY(nd.prdir, rayIn -> rdir);
444        }
445        else VCOPY(nd.prdir, rayIn -> rdir);
446        
447        if ((nd.specfl & (SP_TRAN | SP_PURE)) == (SP_TRAN | SP_PURE))
448 <         /* Perfect specular transmission */  
448 >         /* Perfect specular transmission */
449           VCOPY(rayOut.rdir, nd.prdir);
450 <      else if (!isoSpecPhotonScatter(&nd, &rayOut))
450 >      else if (!isoSpecPhotonScatter(&nd, &rayOut))
451           return 0;
452          
453 <      photonRay(rayIn, &rayOut, PMAP_SPECTRANS, nd.mcolor);  
453 >      photonRay(rayIn, &rayOut, PMAP_SPECTRANS, nd.mcolor);
454     }
455    
456     else if (xi > (albedo -= prdiff)) {
# Line 469 | Line 483 | static int normalPhotonScatter (OBJREC *mat, RAY *rayI
483   static void getacoords (ANISODAT *np)
484   /* Set up coordinate system for anisotropic sampling; cloned from aniso.c */
485   {
486 <        MFUNC  *mf;
487 <        int  i;
486 >   MFUNC  *mf;
487 >   int  i;
488  
489 <        mf = getfunc(np->mp, 3, 0x7, 1);
490 <        setfunc(np->mp, np->rp);
491 <        errno = 0;
492 <        
493 <        for (i = 0; i < 3; i++)
494 <           np->u[i] = evalue(mf->ep[i]);
495 <          
489 >   mf = getfunc(np->mp, 3, 0x7, 1);
490 >   setfunc(np->mp, np->rp);
491 >   errno = 0;
492 >
493 >   for (i = 0; i < 3; i++)
494 >      np->u[i] = evalue(mf->ep[i]);
495 >  
496     if ((errno == EDOM) | (errno == ERANGE)) {
497        objerror(np->mp, WARNING, "compute error");
498        np->specfl |= SP_BADU;
# Line 488 | Line 502 | static void getacoords (ANISODAT *np)
502     if (mf->fxp != &unitxf)
503        multv3(np->u, np->u, mf->fxp->xfm);
504        
505 <        fcross(np->v, np->pnorm, np->u);
506 <        
507 <        if (normalize(np->v) == 0.0) {
508 <           objerror(np->mp, WARNING, "illegal orientation vector");
509 <           np->specfl |= SP_BADU;
510 <           return;
505 >   fcross(np->v, np->pnorm, np->u);
506 >
507 >   if (normalize(np->v) == 0.0) {
508 >      objerror(np->mp, WARNING, "illegal orientation vector");
509 >      np->specfl |= SP_BADU;
510 >      return;
511     }
512    
513     fcross(np->u, np->v, np->pnorm);
# Line 519 | Line 533 | static int anisoSpecPhotonScatter (ANISODAT *nd, RAY *
533     if (rayOut -> rtype & TRANS) {
534        /* Specular transmission */
535  
536 <      if (DOT(rayIn -> pert, rayIn -> pert) <= FTINY * FTINY)
536 >      if (DOT(rayIn -> pert, rayIn -> pert) <= sqr(FTINY))
537           VCOPY(nd -> prdir, rayIn -> rdir);
538        else {
539           /* perturb */
# Line 555 | Line 569 | static int anisoSpecPhotonScatter (ANISODAT *nd, RAY *
569           }
570        }
571        
572 <      return 0;  
572 >      return 0;
573     }
574    
575     else {
# Line 573 | Line 587 | static int anisoSpecPhotonScatter (ANISODAT *nd, RAY *
587           d = d2 <= FTINY ? 1
588                           : sqrt(-log(d2) /
589                                  (sqr(cosp) / sqr(nd -> u_alpha) +
590 <                                 sqr(sinp) / (nd -> v_alpha * nd -> v_alpha)));
590 >                                 sqr(sinp) / (nd->v_alpha * nd->v_alpha)));
591                                  
592           for (i = 0; i < 3; i++)
593              h [i] = nd -> pnorm [i] +
# Line 750 | Line 764 | static int dielectricPhotonScatter (OBJREC *mat, RAY *
764     /* get modifiers */
765     raytexture(rayIn, mat -> omod);                      
766    
767 <   if ((hastexture = (DOT(rayIn -> pert, rayIn -> pert) > FTINY * FTINY)))
767 >   if ((hastexture = (DOT(rayIn -> pert, rayIn -> pert) > sqr(FTINY))))
768        /* Perturb normal */
769        cos1 = raynormal(dnorm, rayIn);
770     else {
# Line 760 | Line 774 | static int dielectricPhotonScatter (OBJREC *mat, RAY *
774    
775     /* index of refraction */
776     nratio = mat -> otype ==
777 <      MAT_DIELECTRIC ? mat -> oargs.farg [3] + mat -> oargs.farg [4] / MLAMBDA
778 <                     : mat -> oargs.farg [3] / mat -> oargs.farg [7];
777 >      MAT_DIELECTRIC ? mat->oargs.farg[3] + mat->oargs.farg[4] / MLAMBDA
778 >                     : mat->oargs.farg[3] / mat->oargs.farg[7];
779                      
780     if (cos1 < 0) {
781        /* inside */
# Line 838 | Line 852 | static int dielectricPhotonScatter (OBJREC *mat, RAY *
852        for (i = 0; i < 3; i++)
853           rayOut.rdir [i] = nratio * rayIn -> rdir [i] + d1 * dnorm [i];
854          
855 <      if (hastexture && DOT(rayOut.rdir, rayIn -> ron) * hastexture >= -FTINY) {
855 >      if (hastexture && DOT(rayOut.rdir, rayIn->ron)*hastexture >= -FTINY) {
856           d1 *= hastexture;
857          
858           for (i = 0; i < 3; i++)
# Line 857 | Line 871 | static int dielectricPhotonScatter (OBJREC *mat, RAY *
871        photonRay(rayIn, &rayOut, PMAP_SPECREFL, NULL);
872        VSUM(rayOut.rdir, rayIn -> rdir, dnorm, 2 * cos1);
873        
874 <      if (hastexture && DOT(rayOut.rdir, rayIn -> ron) * hastexture <= FTINY)
874 >      if (hastexture && DOT(rayOut.rdir, rayIn->ron) * hastexture <= FTINY)
875           for (i = 0; i < 3; i++)
876              rayOut.rdir [i] = rayIn -> rdir [i] +
877                                2 * rayIn -> rod * rayIn -> ron [i];
# Line 897 | Line 911 | static int glassPhotonScatter (OBJREC *mat, RAY *rayIn
911     /* reorient if necessary */
912     if (rayIn -> rod < 0)
913        flipsurface(rayIn);
914 <   if ((hastexture = (DOT(rayIn -> pert, rayIn -> pert) > FTINY * FTINY) ))
914 >   if ((hastexture = (DOT(rayIn -> pert, rayIn -> pert) > sqr(FTINY))))
915        pdot = raynormal(pnorm, rayIn);
916     else {
917        VCOPY(pnorm, rayIn -> ron);
# Line 979 | Line 993 | static int aliasPhotonScatter (OBJREC *mat, RAY *rayIn
993   /* Transfer photon scattering to alias target */
994   {
995     OBJECT   aliasObj;
996 <   OBJREC   aliasRec;
996 >   OBJREC   aliasRec, *aliasPtr;
997    
998     /* Straight replacement? */
999     if (!mat -> oargs.nsargs) {
# Line 996 | Line 1010 | static int aliasPhotonScatter (OBJREC *mat, RAY *rayIn
1010     if (mat -> oargs.nsargs != 1)
1011        objerror(mat, INTERNAL, "bad # string arguments");
1012        
1013 <   aliasObj = lastmod(objndx(mat), mat -> oargs.sarg [0]);
1014 <      
1001 <   if (aliasObj < 0)
1002 <      objerror(mat, USER, "bad reference");
1003 <      
1004 <   memcpy(&aliasRec, objptr(aliasObj), sizeof(OBJREC));
1013 >   aliasPtr = mat;
1014 >   aliasObj = objndx(aliasPtr);
1015    
1016 +   /* Follow alias trail */
1017 +   do {
1018 +      aliasObj = aliasPtr -> oargs.nsargs == 1
1019 +                     ? lastmod(aliasObj, aliasPtr -> oargs.sarg [0])
1020 +                     : aliasPtr -> omod;
1021 +      if (aliasObj < 0)
1022 +         objerror(aliasPtr, USER, "bad reference");
1023 +        
1024 +      aliasPtr = objptr(aliasObj);
1025 +   } while (aliasPtr -> otype == MOD_ALIAS);
1026 +
1027 +   /* Copy alias object */
1028 +   aliasRec = *aliasPtr;
1029 +  
1030     /* Substitute modifier */
1031     aliasRec.omod = mat -> omod;
1032    
1033     /* Replacement scattering routine */
1034     photonScatter [aliasRec.otype] (&aliasRec, rayIn);
1035 +
1036 + #if 0
1037 +   /* Avoid potential memory leak? */
1038 +   if (aliasRec.os != aliasPtr -> os) {
1039 +      if (aliasObj -> os)
1040 +         free_os(aliasObj);
1041 +      aliasPtr -> os = aliasRec.os;
1042 +   }
1043 + #endif
1044 +
1045     return 0;
1046   }
1047  
# Line 1036 | Line 1070 | static int clipPhotonScatter (OBJREC *mat, RAY *rayIn)
1070              continue;
1071              
1072           if ((mod = lastmod(obj, mat -> oargs.sarg [i])) == OVOID) {
1073 <            sprintf(errmsg, "unknown modifier \"%s\"", mat -> oargs.sarg [i]);
1073 >            sprintf(errmsg, "unknown modifier \"%s\"", mat->oargs.sarg[i]);
1074              objerror(mat, WARNING, errmsg);
1075              continue;
1076           }
# Line 1232 | Line 1266 | static int mx_dataPhotonScatter (OBJREC *mat, RAY *ray
1266        if (!strcmp(mat -> oargs.sarg [i], VOIDID))
1267           mod [i] = OVOID;
1268        else if ((mod [i] = lastmod(obj, mat -> oargs.sarg [i])) == OVOID) {
1269 <         sprintf(errmsg, "undefined modifier \"%s\"", mat -> oargs.sarg [i]);
1269 >         sprintf(errmsg, "undefined modifier \"%s\"", mat->oargs.sarg[i]);
1270           objerror(mat, USER, errmsg);
1271        }
1272        
# Line 1297 | Line 1331 | static int mx_pdataPhotonScatter (OBJREC *mat, RAY *ra
1331        if (!strcmp(mat -> oargs.sarg [i], VOIDID))
1332           mod [i] = OVOID;
1333        else if ((mod [i] = lastmod(obj, mat -> oargs.sarg [i])) == OVOID) {
1334 <         sprintf(errmsg, "undefined modifier \"%s\"", mat -> oargs.sarg [i]);
1334 >         sprintf(errmsg, "undefined modifier \"%s\"", mat->oargs.sarg[i]);
1335           objerror(mat, USER, errmsg);
1336        }
1337        
# Line 1359 | Line 1393 | static int mx_funcPhotonScatter (OBJREC *mat, RAY *ray
1393        if (!strcmp(mat -> oargs.sarg [i], VOIDID))
1394           mod [i] = OVOID;
1395        else if ((mod [i] = lastmod(obj, mat -> oargs.sarg [i])) == OVOID) {
1396 <         sprintf(errmsg, "undefined modifier \"%s\"", mat -> oargs.sarg [i]);
1396 >         sprintf(errmsg, "undefined modifier \"%s\"", mat->oargs.sarg[i]);
1397           objerror(mat, USER, errmsg);
1398        }
1399        
# Line 1417 | Line 1451 | static int pattexPhotonScatter (OBJREC *mat, RAY *rayI
1451  
1452  
1453  
1454 + static int setbrdfunc(BRDFDAT *bd)
1455 + /* Set up brdf function and variables; ripped off from m_brdf.c */
1456 + {
1457 +   FVECT v;
1458 +  
1459 +   if (setfunc(bd -> mp, bd -> pr) == 0)
1460 +      return 0;
1461 +
1462 +   /* (Re)Assign func variables */
1463 +   multv3(v, bd -> pnorm, funcxf.xfm);
1464 +   varset("NxP", '=', v [0] / funcxf.sca);
1465 +   varset("NyP", '=', v [1] / funcxf.sca);
1466 +   varset("NzP", '=', v [2] / funcxf.sca);
1467 +   varset("RdotP", '=',
1468 +          bd -> pdot <= -1. ? -1. : bd -> pdot >= 1. ? 1. : bd -> pdot);
1469 +   varset("CrP", '=', colval(bd -> mcolor, RED));
1470 +   varset("CgP", '=', colval(bd -> mcolor, GRN));
1471 +   varset("CbP", '=', colval(bd -> mcolor, BLU));
1472 +  
1473 +   return 1;
1474 + }
1475 +
1476 +
1477 +
1478 + static int brtdFuncPhotonScatter (OBJREC *mat, RAY *rayIn)
1479 + /* Generate new photon ray for BRTDfunc material and recurse */
1480 + {
1481 +   int      hitfront = 1, hastexture, i;
1482 +   BRDFDAT  nd;
1483 +   RAY      rayOut;
1484 +   COLOR    rspecCol, tspecCol;
1485 +   double   prDiff, ptDiff, prSpec, ptSpec, albedo, xi;
1486 +   MFUNC    *mf;
1487 +   FVECT    bnorm;
1488 +
1489 +   if (mat -> oargs.nsargs < 10 || mat -> oargs.nfargs < 9)
1490 +      objerror(mat, USER, "bad # arguments");
1491 +   nd.mp = mat;
1492 +   nd.pr = rayIn;
1493 +   /* Dummies */
1494 +   nd.rspec = nd.tspec = 1.0;
1495 +   nd.trans = 0.5;
1496 +
1497 +   /* Diffuse reflectance */
1498 +   if (rayIn -> rod > 0.0)
1499 +      setcolor(nd.rdiff, mat -> oargs.farg[0], mat -> oargs.farg [1],
1500 +               mat -> oargs.farg [2]);
1501 +   else
1502 +      setcolor(nd.rdiff, mat-> oargs.farg [3], mat -> oargs.farg [4],
1503 +               mat -> oargs.farg [5]);
1504 +   /* Diffuse transmittance */
1505 +   setcolor(nd.tdiff, mat -> oargs.farg [6], mat -> oargs.farg [7],
1506 +            mat -> oargs.farg [8]);
1507 +
1508 +   /* Get modifiers */
1509 +   raytexture(rayIn, mat -> omod);
1510 +   hastexture = (DOT(rayIn -> pert, rayIn -> pert) > sqr(FTINY));
1511 +   if (hastexture) {
1512 +      /* Perturb normal */
1513 +      nd.pdot = raynormal(nd.pnorm, rayIn);
1514 +   }
1515 +   else {
1516 +      VCOPY(nd.pnorm, rayIn -> ron);
1517 +      nd.pdot = rayIn -> rod;
1518 +   }
1519 +
1520 +   if (rayIn -> rod < 0.0) {
1521 +      /* Orient perturbed values */
1522 +      nd.pdot = -nd.pdot;
1523 +      for (i = 0; i < 3; i++) {
1524 +         nd.pnorm [i] = -nd.pnorm [i];
1525 +         rayIn -> pert [i] = -rayIn -> pert [i];
1526 +      }
1527 +      
1528 +      hitfront = 0;
1529 +   }
1530 +  
1531 +   /* Get pattern color, modify diffuse values */
1532 +   copycolor(nd.mcolor, rayIn -> pcol);
1533 +   multcolor(nd.rdiff, nd.mcolor);
1534 +   multcolor(nd.tdiff, nd.mcolor);
1535 +
1536 +   /* Load cal file, evaluate spec refl/trans vars */
1537 +   nd.dp = NULL;
1538 +   mf = getfunc(mat, 9, 0x3f, 0);
1539 +   setbrdfunc(&nd);
1540 +   errno = 0;
1541 +   setcolor(rspecCol,
1542 +            evalue(mf->ep[0]), evalue(mf->ep[1]), evalue(mf->ep[2]));
1543 +   setcolor(tspecCol,
1544 +            evalue(mf->ep[3]), evalue(mf->ep[4]), evalue(mf->ep[5]));
1545 +   if (errno == EDOM || errno == ERANGE)
1546 +      objerror(mat, WARNING, "compute error");
1547 +   else {
1548 +      /* Set up probabilities */
1549 +      prDiff = colorAvg(nd.rdiff);
1550 +      ptDiff = colorAvg(nd.tdiff);
1551 +      prSpec = colorAvg(rspecCol);
1552 +      ptSpec = colorAvg(tspecCol);
1553 +      albedo = prDiff + ptDiff + prSpec + ptSpec;
1554 +   }
1555 +
1556 +   /* Insert direct and indirect photon hits if diffuse component */
1557 +   if (prDiff > FTINY || ptDiff > FTINY)
1558 +      addPhotons(rayIn);
1559 +
1560 +   /* Stochastically sample absorption or scattering events */
1561 +   if ((xi = pmapRandom(rouletteState)) > albedo)
1562 +      /* Absorbed */
1563 +      return 0;
1564 +
1565 +   if (xi > (albedo -= prSpec)) {
1566 +      /* Specular reflection */
1567 +      photonRay(rayIn, &rayOut, PMAP_SPECREFL, rspecCol);
1568 +      VSUM(rayOut.rdir, rayIn -> rdir, nd.pnorm, 2 * nd.pdot);
1569 +      checknorm(rayOut.rdir);
1570 +   }
1571 +   else if (xi > (albedo -= ptSpec)) {
1572 +      /* Specular transmission */
1573 +      photonRay(rayIn, &rayOut, PMAP_SPECTRANS, tspecCol);
1574 +      if (hastexture) {
1575 +         /* Perturb direction */
1576 +         VSUB(rayOut.rdir, rayIn -> rdir, rayIn -> pert);
1577 +         if (normalize(rayOut.rdir) == 0.0) {
1578 +            objerror(mat, WARNING, "illegal perturbation");
1579 +            VCOPY(rayOut.rdir, rayIn -> rdir);
1580 +         }
1581 +         else VCOPY(rayOut.rdir, rayIn -> rdir);
1582 +      }
1583 +   }
1584 +   else if (xi > (albedo -= prDiff)) {
1585 +      /* Diffuse reflection */
1586 +      if (!hitfront)
1587 +         flipsurface(rayIn);
1588 +      photonRay(rayIn, &rayOut, PMAP_DIFFREFL, nd.mcolor);
1589 +      diffPhotonScatter(nd.pnorm, &rayOut);
1590 +   }
1591 +   else {
1592 +      /* Diffuse transmission */
1593 +      if (hitfront)
1594 +         flipsurface(rayIn);
1595 +      photonRay(rayIn, &rayOut, PMAP_DIFFTRANS, nd.mcolor);
1596 +      bnorm [0] = -nd.pnorm [0];
1597 +      bnorm [1] = -nd.pnorm [1];
1598 +      bnorm [2] = -nd.pnorm [2];
1599 +      diffPhotonScatter(bnorm, &rayOut);
1600 +   }
1601 +
1602 +   return 0;
1603 + }
1604 +
1605 +
1606 +
1607 + #if 0
1608 + int
1609 + m_brdf2(                        /* color a ray that hit a BRDF material */
1610 +        OBJREC  *m,
1611 +        RAY  *r
1612 + )
1613 + {
1614 +        BRDFDAT  nd;
1615 +        COLOR  ctmp;
1616 +        FVECT  vtmp;
1617 +        double  dtmp;
1618 +                                                /* always a shadow */
1619 +        if (r->crtype & SHADOW)
1620 +                return(1);
1621 +                                                /* check arguments */
1622 +        if ((m->oargs.nsargs < (hasdata(m->otype)?4:2)) | (m->oargs.nfargs <
1623 +                        ((m->otype==MAT_TFUNC)|(m->otype==MAT_TDATA)?6:4)))
1624 +                objerror(m, USER, "bad # arguments");
1625 +                                                /* check for back side */
1626 +        if (r->rod < 0.0) {
1627 +                if (!backvis) {
1628 +                        raytrans(r);
1629 +                        return(1);
1630 +                }
1631 +                raytexture(r, m->omod);
1632 +                flipsurface(r);                 /* reorient if backvis */
1633 +        } else
1634 +                raytexture(r, m->omod);
1635 +
1636 +        nd.mp = m;
1637 +        nd.pr = r;
1638 +                                                /* get material color */
1639 +        setcolor(nd.mcolor, m->oargs.farg[0],
1640 +                        m->oargs.farg[1],
1641 +                        m->oargs.farg[2]);
1642 +                                                /* get specular component */
1643 +        nd.rspec = m->oargs.farg[3];
1644 +                                                /* compute transmittance */
1645 +        if ((m->otype == MAT_TFUNC) | (m->otype == MAT_TDATA)) {
1646 +                nd.trans = m->oargs.farg[4]*(1.0 - nd.rspec);
1647 +                nd.tspec = nd.trans * m->oargs.farg[5];
1648 +                dtmp = nd.trans - nd.tspec;
1649 +                setcolor(nd.tdiff, dtmp, dtmp, dtmp);
1650 +        } else {
1651 +                nd.tspec = nd.trans = 0.0;
1652 +                setcolor(nd.tdiff, 0.0, 0.0, 0.0);
1653 +        }
1654 +                                                /* compute reflectance */
1655 +        dtmp = 1.0 - nd.trans - nd.rspec;
1656 +        setcolor(nd.rdiff, dtmp, dtmp, dtmp);
1657 +        nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
1658 +        multcolor(nd.mcolor, r->pcol);          /* modify material color */
1659 +        multcolor(nd.rdiff, nd.mcolor);
1660 +        multcolor(nd.tdiff, nd.mcolor);
1661 +                                                /* load auxiliary files */
1662 +        if (hasdata(m->otype)) {
1663 +                nd.dp = getdata(m->oargs.sarg[1]);
1664 +                getfunc(m, 2, 0, 0);
1665 +        } else {
1666 +                nd.dp = NULL;
1667 +                getfunc(m, 1, 0, 0);
1668 +        }
1669 +                                                /* compute ambient */
1670 +        if (nd.trans < 1.0-FTINY) {
1671 +                copycolor(ctmp, nd.mcolor);     /* modified by material color */
1672 +                scalecolor(ctmp, 1.0-nd.trans);
1673 +                multambient(ctmp, r, nd.pnorm);
1674 +                addcolor(r->rcol, ctmp);        /* add to returned color */
1675 +        }
1676 +        if (nd.trans > FTINY) {         /* from other side */
1677 +                flipsurface(r);
1678 +                vtmp[0] = -nd.pnorm[0];
1679 +                vtmp[1] = -nd.pnorm[1];
1680 +                vtmp[2] = -nd.pnorm[2];
1681 +                copycolor(ctmp, nd.mcolor);
1682 +                scalecolor(ctmp, nd.trans);
1683 +                multambient(ctmp, r, vtmp);
1684 +                addcolor(r->rcol, ctmp);
1685 +                flipsurface(r);
1686 +        }
1687 +                                                /* add direct component */
1688 +        direct(r, dirbrdf, &nd);
1689 +
1690 +        return(1);
1691 + }
1692 + #endif
1693 +
1694 +
1695 +
1696   /*
1697     ==================================================================
1698     The following code is
1699     (c) Lucerne University of Applied Sciences and Arts,
1700     supported by the Swiss National Science Foundation (SNSF, #147053)
1701     ==================================================================
1702 < */  
1702 > */
1703  
1704   static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1705   /* Generate new photon ray for BSDF modifier and recurse. */
# Line 1456 | Line 1732 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1732     /* Get thickness */
1733     nd.thick = 0;
1734     if (hasthick) {
1735 <        nd.thick = evalue(mf -> ep [0]);
1736 <        if ((-FTINY <= nd.thick) & (nd.thick <= FTINY))
1737 <                nd.thick = .0;
1735 >   nd.thick = evalue(mf -> ep [0]);
1736 >   if ((-FTINY <= nd.thick) & (nd.thick <= FTINY))
1737 >      nd.thick = .0;
1738     }
1739  
1740     /* Get BSDF data */
# Line 1472 | Line 1748 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1748                      mat -> oargs.farg [2]);
1749     }    
1750     else if (mat -> oargs.nfargs < 6) {
1751 <        /* Check for absorbing backside */
1752 <        if (!backvis && !nd.sd -> rb && !nd.sd -> tf) {
1753 <           SDfreeCache(nd.sd);                    
1754 <           return 0;
1751 >      /* Check for absorbing backside */
1752 >      if (!backvis && !nd.sd -> rb && !nd.sd -> tf) {
1753 >         SDfreeCache(nd.sd);
1754 >         return 0;
1755        }
1756        
1757        setcolor(nd.rdiff, .0, .0, .0);
# Line 1536 | Line 1812 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1812     }
1813    
1814     /* Determine BSDF resolution */
1815 <   err = SDsizeBSDF(nd.sr_vpsa, nd.vray, NULL, SDqueryMin + SDqueryMax, nd.sd);
1815 >   err = SDsizeBSDF(nd.sr_vpsa, nd.vray, NULL,
1816 >                    SDqueryMin + SDqueryMax, nd.sd);
1817    
1818     if (err)
1819        objerror(mat, USER, transSDError(err));
# Line 1677 | Line 1954 | void initPhotonScatterFuncs ()
1954   {
1955     int i;
1956    
1957 +   /* Catch-all for inconsistencies */
1958     for (i = 0; i < NUMOTYPE; i++)
1959        photonScatter [i] = o_default;
1960        
# Line 1707 | Line 1985 | void initPhotonScatterFuncs ()
1985              photonScatter [TEX_DATA] = pattexPhotonScatter;
1986              
1987     photonScatter [MOD_ALIAS] = aliasPhotonScatter;
1988 +   photonScatter [MAT_BRTDF] = brtdFuncPhotonScatter;
1989     photonScatter [MAT_BSDF] =
1990        photonScatter [MAT_ABSDF] = bsdfPhotonScatter;
1991   }

Diff Legend

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