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.2 by rschregle, Wed Apr 22 15:50:44 2015 UTC vs.
Revision 2.12 by rschregle, Tue Feb 23 12:42:41 2016 UTC

# Line 1 | Line 1
1 + #ifndef lint
2 + static const char RCSid[] = "$Id$";
3 + #endif
4   /*
5     ==================================================================
6     Photon map support routines for scattering by materials.
7  
8     Roland Schregle (roland.schregle@{hslu.ch, gmail.com})
9     (c) Fraunhofer Institute for Solar Energy Systems,
10 <       Lucerne University of Applied Sciences & Arts
10 >   (c) Lucerne University of Applied Sciences and Arts,
11 >   supported by the Swiss National Science Foundation (SNSF, #147053)
12     ==================================================================
13    
10 –   $Id$
14   */
15  
16  
# Line 198 | Line 201 | static int isoSpecPhotonScatter (NORMDAT *nd, RAY *ray
201     int      niter, i = 0;
202    
203     /* Set up sample coordinates */  
204 <   do {
202 <      v [0] = v [1] = v [2] = 0;
203 <      v [i++] = 1;
204 <      fcross(u, v, nd -> pnorm);
205 <   } while (normalize(u) < FTINY);
206 <  
204 >   getperpendicular(u, nd -> pnorm, 1);  
205     fcross(v, nd -> pnorm, u);
206    
207     if (nd -> specfl & SP_REFL) {
# Line 267 | Line 265 | static void diffPhotonScatter (FVECT normal, RAY* rayO
265     int         i = 0;
266  
267     /* Set up sample coordinates */
268 <   do {
271 <      v [0] = v [1] = v [2] = 0;
272 <      v [i++] = 1;
273 <      fcross(u, v, normal);
274 <   } while (normalize(u) < FTINY);
275 <  
268 >   getperpendicular(u, normal, 1);
269     fcross(v, normal, u);
270    
271     /* Convert theta & phi to cartesian */
# Line 323 | Line 316 | static int normalPhotonScatter (OBJREC *mat, RAY *rayI
316        nd.specfl |= SP_FLAT;  
317        
318     /* Perturb normal */
319 <   if ((hastexture = DOT(rayIn -> pert, rayIn -> pert)) > sqr(FTINY))
319 >   if ((hastexture = (DOT(rayIn -> pert, rayIn -> pert) > sqr(FTINY)) ))
320        nd.pdot = raynormal(nd.pnorm, rayIn);
321     else {
322        VCOPY(nd.pnorm, rayIn -> ron);
# Line 752 | Line 745 | static int dielectricPhotonScatter (OBJREC *mat, RAY *
745     /* get modifiers */
746     raytexture(rayIn, mat -> omod);                      
747    
748 <   if ((hastexture = DOT(rayIn -> pert, rayIn -> pert)) > FTINY * FTINY)
748 >   if ((hastexture = (DOT(rayIn -> pert, rayIn -> pert) > FTINY * FTINY)))
749        /* Perturb normal */
750        cos1 = raynormal(dnorm, rayIn);
751     else {
# Line 899 | Line 892 | static int glassPhotonScatter (OBJREC *mat, RAY *rayIn
892     /* reorient if necessary */
893     if (rayIn -> rod < 0)
894        flipsurface(rayIn);
895 <   if ((hastexture = DOT(rayIn -> pert, rayIn -> pert)) > FTINY * FTINY)
895 >   if ((hastexture = (DOT(rayIn -> pert, rayIn -> pert) > FTINY * FTINY) ))
896        pdot = raynormal(pnorm, rayIn);
897     else {
898        VCOPY(pnorm, rayIn -> ron);
# Line 985 | Line 978 | static int aliasPhotonScatter (OBJREC *mat, RAY *rayIn
978    
979     /* Straight replacement? */
980     if (!mat -> oargs.nsargs) {
981 <      mat = objptr(mat -> omod);
982 <      photonScatter [mat -> otype] (mat, rayIn);
981 >      /* Skip void modifier! */
982 >      if (mat -> omod != OVOID) {
983 >         mat = objptr(mat -> omod);
984 >         photonScatter [mat -> otype] (mat, rayIn);
985 >      }
986        
987        return 0;
988     }
# Line 1257 | Line 1253 | static int mx_dataPhotonScatter (OBJREC *mat, RAY *ray
1253     if (errno)
1254        objerror(mat, WARNING, "compute error");
1255     else {
1256 <      mat = objptr(mod [pmapRandom(rouletteState) < coef ? 0 : 1]);
1257 <      photonScatter [mat -> otype] (mat, rayIn);
1256 >      OBJECT mxMod = mod [pmapRandom(rouletteState) < coef ? 0 : 1];
1257 >      
1258 >      if (mxMod != OVOID) {
1259 >         mat = objptr(mxMod);
1260 >         photonScatter [mat -> otype] (mat, rayIn);
1261 >      }
1262 >      else {
1263 >         /* Transfer ray if no modifier */
1264 >         RAY rayOut;
1265 >        
1266 >         photonRay(rayIn, &rayOut, PMAP_XFER, NULL);
1267 >         tracePhoton(&rayOut);      
1268 >      }            
1269     }
1270    
1271     return 0;
# Line 1310 | Line 1317 | static int mx_pdataPhotonScatter (OBJREC *mat, RAY *ra
1317     if (errno)
1318        objerror(mat, WARNING, "compute error");
1319     else {
1320 <      mat = objptr(mod [pmapRandom(rouletteState) < coef ? 0 : 1]);
1321 <      photonScatter [mat -> otype] (mat, rayIn);
1320 >      OBJECT mxMod = mod [pmapRandom(rouletteState) < coef ? 0 : 1];
1321 >      
1322 >      if (mxMod != OVOID) {
1323 >         mat = objptr(mxMod);
1324 >         photonScatter [mat -> otype] (mat, rayIn);
1325 >      }
1326 >      else {
1327 >         /* Transfer ray if no modifier */
1328 >         RAY rayOut;
1329 >        
1330 >         photonRay(rayIn, &rayOut, PMAP_XFER, NULL);
1331 >         tracePhoton(&rayOut);      
1332 >      }      
1333     }  
1334    
1335     return 0;
# Line 1350 | Line 1368 | static int mx_funcPhotonScatter (OBJREC *mat, RAY *ray
1368     if (errno)
1369        objerror(mat, WARNING, "compute error");
1370     else {        
1371 <      mat = objptr(mod [pmapRandom(rouletteState) < coef ? 0 : 1]);
1372 <      photonScatter [mat -> otype] (mat, rayIn);
1371 >      OBJECT mxMod = mod [pmapRandom(rouletteState) < coef ? 0 : 1];
1372 >      
1373 >      if (mxMod != OVOID) {
1374 >         mat = objptr(mxMod);
1375 >         photonScatter [mat -> otype] (mat, rayIn);
1376 >      }
1377 >      else {
1378 >         /* Transfer ray if no modifier */
1379 >         RAY rayOut;
1380 >        
1381 >         photonRay(rayIn, &rayOut, PMAP_XFER, NULL);
1382 >         tracePhoton(&rayOut);      
1383 >      }
1384     }
1385    
1386     return 0;
# Line 1383 | Line 1412 | static int pattexPhotonScatter (OBJREC *mat, RAY *rayI
1412  
1413  
1414  
1415 < #if 0
1416 <   static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1417 <   /* Generate new photon ray for BSDF modifier and recurse. */
1418 <   {
1419 <      int      hitFront;
1420 <      SDError  err;
1421 <      FVECT        upvec;
1393 <      MFUNC        *mf;
1394 <      BSDFDAT   nd;
1395 <      RAY      rayOut;
1415 > /*
1416 >   ==================================================================
1417 >   The following code is
1418 >   (c) Lucerne University of Applied Sciences and Arts,
1419 >   supported by the Swiss National Science Foundation (SNSF, #147053)
1420 >   ==================================================================
1421 > */  
1422  
1397 –      /* Following code adapted from m_bsdf() */
1398 –      /* Check arguments */
1399 –      if (mat -> oargs.nsargs < 6 || mat -> oargs.nfargs > 9 ||
1400 –          mat -> oargs.nfargs % 3)
1401 –         objerror(mat, USER, "bad # arguments");
1402 –        
1403 –      hitFront = (rayIn -> rod > 0);
1404 –
1405 –      /* Load cal file */
1406 –      mf = getfunc(mat, 5, 0x1d, 1);
1407 –      
1408 –      /* Get thickness */
1409 –      nd.thick = evalue(mf -> ep [0]);
1410 –      if ((-FTINY <= nd.thick) & (nd.thick <= FTINY))
1411 –         nd.thick = .0;
1412 –        
1413 –      if (nd.thick != .0 || (!hitFront && !backvis)) {
1414 –         /* Proxy geometry present, so use it instead and transfer ray */
1415 –         photonRay(rayIn, &rayOut, PMAP_XFER, NULL);
1416 –         tracePhoton(&rayOut);
1417 –        
1418 –         return 0;
1419 –      }
1420 –
1421 –      /* Get BSDF data */
1422 –      nd.sd = loadBSDF(mat -> oargs.sarg [1]);
1423 –      
1424 –      /* Diffuse reflectance */
1425 –      if (hitFront) {
1426 –         if (mat -> oargs.nfargs < 3)
1427 –            setcolor(nd.rdiff, .0, .0, .0);
1428 –         else setcolor(nd.rdiff, mat -> oargs.farg [0], mat -> oargs.farg [1],
1429 –                       mat -> oargs.farg [2]);
1430 –      }    
1431 –      else if (mat -> oargs.nfargs < 6) {
1432 –         /* Check for absorbing backside */
1433 –         if (!backvis && !nd.sd -> rb && !nd.sd -> tf) {
1434 –            SDfreeCache(nd.sd);                    
1435 –            return 0;
1436 –         }
1437 –        
1438 –         setcolor(nd.rdiff, .0, .0, .0);
1439 –      }
1440 –      else setcolor(nd.rdiff, mat -> oargs.farg [3], mat -> oargs.farg [4],
1441 –                    mat -> oargs.farg [5]);
1442 –
1443 –      /* Diffuse transmittance */
1444 –      if (mat -> oargs.nfargs < 9)
1445 –         setcolor(nd.tdiff, .0, .0, .0);
1446 –      else setcolor(nd.tdiff, mat -> oargs.farg [6], mat -> oargs.farg [7],
1447 –                    mat -> oargs.farg [8]);
1448 –                  
1449 –      nd.mp = mat;
1450 –      nd.pr = rayIn;
1451 –      
1452 –      /* Get modifiers */
1453 –      raytexture(rayIn, mat -> omod);
1454 –      
1455 –      /* Modify diffuse values */
1456 –      multcolor(nd.rdiff, rayIn -> pcol);
1457 –      multcolor(nd.tdiff, rayIn -> pcol);
1458 –        
1459 –      /* Get up vector & xform to world coords */
1460 –      upvec [0] = evalue(mf -> ep [1]);
1461 –      upvec [1] = evalue(mf -> ep [2]);
1462 –      upvec [2] = evalue(mf -> ep [3]);
1463 –      
1464 –      if (mf -> fxp != &unitxf) {
1465 –         multv3(upvec, upvec, mf -> fxp -> xfm);
1466 –         nd.thick *= mf -> fxp -> sca;
1467 –      }
1468 –      
1469 –      if (rayIn -> rox) {
1470 –         multv3(upvec, upvec, rayIn -> rox -> f.xfm);
1471 –         nd.thick *= rayIn -> rox -> f.sca;
1472 –      }
1473 –      
1474 –      /* Perturb normal */
1475 –      raynormal(nd.pnorm, rayIn);
1476 –      
1477 –      /* Xform incident dir to local BSDF coords */
1478 –      err = SDcompXform(nd.toloc, nd.pnorm, upvec);
1479 –      
1480 –      if (!err) {
1481 –         nd.vray [0] = -rayIn -> rdir [0];
1482 –         nd.vray [1] = -rayIn -> rdir [1];
1483 –         nd.vray [2] = -rayIn -> rdir [2];
1484 –         err = SDmapDir(nd.vray, nd.toloc, nd.vray);
1485 –      }
1486 –      
1487 –      if (!err)
1488 –         err = SDinvXform(nd.fromloc, nd.toloc);
1489 –        
1490 –      if (err) {
1491 –         objerror(mat, WARNING, "Illegal orientation vector");
1492 –         return 0;
1493 –      }
1494 –      
1495 –      /* Determine BSDF resolution */
1496 –      err = SDsizeBSDF(nd.sr_vpsa, nd.vray, NULL, SDqueryMin + SDqueryMax, nd.sd);
1497 –      
1498 –      if (err)
1499 –         objerror(mat, USER, transSDError(err));
1500 –        
1501 –      nd.sr_vpsa [0] = sqrt(nd.sr_vpsa [0]);
1502 –      nd.sr_vpsa [1] = sqrt(nd.sr_vpsa [1]);
1503 –
1504 –      /* Orient perturbed normal towards incident side */
1505 –      if (!hitFront) {                  
1506 –         nd.pnorm [0] = -nd.pnorm [0];
1507 –         nd.pnorm [1] = -nd.pnorm [1];
1508 –         nd.pnorm [2] = -nd.pnorm [2];
1509 –      }
1510 –      
1511 –      /* Following code adapted from SDsampBSDF() */
1512 –      {
1513 –         SDSpectralDF   *rdf, *tdf;
1514 –         SDValue        bsdfVal;
1515 –         double         xi, rhoDiff = 0;
1516 –         float          coef [SDmaxCh];
1517 –         int            i, j, n, nr;
1518 –         SDComponent       *sdc;
1519 –         const SDCDst   **cdarr = NULL;
1520 –        
1521 –         /* Get diffuse albedo (?) */
1522 –         if (hitFront) {
1523 –            bsdfVal = nd.sd -> rLambFront;
1524 –            rdf = nd.sd -> rf;
1525 –            tdf = nd.sd -> tf ? nd.sd -> tf : nd.sd -> tb;
1526 –         }
1527 –         else {
1528 –            bsdfVal = nd.sd -> rLambBack;
1529 –            rdf = nd.sd -> rb;
1530 –            tdf = nd.sd -> tb ? nd.sd -> tb : nd.sd -> tf;
1531 –         }
1532 –        
1533 –         rhoDiff = bsdfVal.cieY;
1534 –         bsdfVal.cieY += nd.sd -> tLamb.cieY;
1535 –        
1536 –         /* Allocate non-diffuse sampling */
1537 –         i = nr = rdf ? rdf -> ncomp : 0;
1538 –         j = tdf ? tdf -> ncomp : 0;
1539 –         n = i + j;
1540 –        
1541 –         if (n > 0 && !(cdarr = (const SDCDst**)malloc(n * sizeof(SDCDst*))))
1542 –            objerror(mat, USER, transSDError(SDEmemory));
1543 –            
1544 –         while (j-- > 0) {
1545 –            /* Sum up non-diffuse transmittance */
1546 –            cdarr [i + j] = (*tdf -> comp [j].func -> getCDist)(nd.vray, &tdf -> comp [j]);
1547 –            
1548 –            if (!cdarr [i + j])
1549 –               cdarr [i + j] = &SDemptyCD;
1550 –            else bsdfVal.cieY += cdarr [i + j] -> cTotal;
1551 –         }
1552 –        
1553 –         while (i-- > 0) {
1554 –            /* Sum up non-diffuse reflectance */
1555 –            cdarr [i] = (*rdf -> comp [i].func -> getCDist)(nd.vray, &rdf -> comp [i]);
1556 –            
1557 –            if (!cdarr [i])
1558 –               cdarr [i] = &SDemptyCD;
1559 –            else bsdfVal.cieY += cdarr [i] -> cTotal;
1560 –         }
1561 –        
1562 –         if (bsdfVal.cieY <= FTINY) {
1563 –            /* Don't bother sampling, just absorb photon */
1564 –            if (cdarr)
1565 –               free(cdarr);
1566 –            return 0;
1567 –         }      
1568 –        
1569 –         /* Insert direct and indirect photon hits if diffuse component */
1570 –         if (rhoDiff > FTINY || nd.sd -> tLamb.cieY > FTINY)
1571 –            addPhotons(rayIn);  
1572 –            
1573 –         xi = pmapRandom(rouletteState);
1574 –        
1575 –         if ((xi -= rhoDiff) <= 0) {
1576 –            /* Diffuse reflection */
1577 –            photonRay(rayIn, &rayOut, PMAP_DIFFREFL, nd.rdiff);
1578 –            diffPhotonScatter(nd.pnorm, &rayOut);
1579 –         }
1580 –         else if ((xi -= nd.sd -> tLamb.cieY) <= 0) {
1581 –            /* Diffuse transmission */
1582 –            flipsurface(rayIn);
1583 –            photonRay(rayIn, &rayOut, PMAP_DIFFTRANS, nd.tdiff);
1584 –            bsdfVal.spec = nd.sd -> tLamb.spec;
1585 –            diffPhotonScatter(nd.pnorm, &rayOut);
1586 –         }
1587 –         else {
1588 –            int rayOutType;
1589 –            COLOR bsdfRGB;
1590 –              
1591 –            /* Non-diffuse CDF inversion (?) */
1592 –            for (i = 0; i < n && (xi -= cdarr [i] -> cTotal) > 0; i++);
1593 –            
1594 –            if (i >= n) {
1595 –               /* Absorbed -- photon went Deer Hunter */
1596 –               if (cdarr)
1597 –                  free(cdarr);
1598 –               return 0;
1599 –            }
1600 –
1601 –            if (i < nr) {
1602 –               /* Non-diffuse reflection */
1603 –               sdc = &rdf -> comp [i];
1604 –               rayOutType = PMAP_SPECREFL;
1605 –            }
1606 –            else {
1607 –               /* Non-diffuse transmission */
1608 –               sdc = &tdf -> comp [i - nr];
1609 –               rayOutType = PMAP_SPECTRANS;
1610 –            }
1611 –            
1612 –            /* Generate non-diff sample dir */
1613 –            VCOPY(rayOut.rdir, nd.vray);
1614 –            err = (*sdc -> func -> sampCDist)
1615 –                  (rayOut.rdir, pmapRandom(scatterState), cdarr [i]);              
1616 –            if (err)
1617 –               objerror(mat, USER, transSDError(SDEinternal));
1618 –
1619 –            /* Get colour */
1620 –            j = (*sdc -> func -> getBSDFs)(coef, rayOut.rdir, nd.vray, sdc);
1621 –            
1622 –            if (j <= 0) {
1623 –               sprintf(SDerrorDetail, "BSDF \"%s\" sampling value error",
1624 –                       nd.sd -> name);
1625 –               objerror(mat, USER, transSDError(SDEinternal));
1626 –            }
1627 –            
1628 –            bsdfVal.spec = sdc -> cspec [0];
1629 –            rhoDiff = coef [0];
1630 –            
1631 –            while (--j) {
1632 –               c_cmix(&bsdfVal.spec, rhoDiff, &bsdfVal.spec, coef [j],
1633 –                      &sdc -> cspec [j]);
1634 –               rhoDiff += coef [j];
1635 –            }
1636 –            
1637 –            /* ? */
1638 –            c_ccvt(&bsdfVal.spec, C_CSXY + C_CSSPEC);
1639 –            ccy2rgb(&bsdfVal.spec, bsdfVal.cieY, bsdfRGB);
1640 –            
1641 –            /* Xform outgoing dir to world coords */
1642 –            if ((err = SDmapDir(rayOut.rdir, nd.fromloc, rayOut.rdir))) {
1643 –               objerror(mat, USER, transSDError(err));
1644 –               return 0;
1645 –            }
1646 –            
1647 –            photonRay(rayIn, &rayOut, rayOutType, bsdfRGB);
1648 –         }
1649 –        
1650 –         if (cdarr)
1651 –            free(cdarr);
1652 –      }
1653 –                          
1654 –      /* Clean up BSDF */
1655 –      SDfreeCache(nd.sd);
1656 –
1657 –      tracePhoton(&rayOut);
1658 –      return 0;
1659 –   }
1660 – #else
1661 –
1423   static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1424   /* Generate new photon ray for BSDF modifier and recurse. */
1425   {
# Line 1670 | Line 1431 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1431     BSDFDAT      nd;
1432     RAY      rayOut;
1433     COLOR    bsdfRGB;
1434 +   int      transmitted;
1435     double   prDiff, ptDiff, prDiffSD, ptDiffSD, prSpecSD, ptSpecSD,
1436 <            albedo, xi, xi2;
1437 <   const double patAlb = colorAvg(rayIn -> pcol);
1436 >            albedo, xi;
1437 >   const double patAlb = bright(rayIn -> pcol);
1438    
1439     /* Following code adapted from m_bsdf() */
1440     /* Check arguments */
# Line 1689 | Line 1451 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1451          nd.thick = evalue(mf -> ep [0]);
1452          if ((-FTINY <= nd.thick) & (nd.thick <= FTINY))
1453                  nd.thick = .0;
1692 –                
1693 –   if (nd.thick != .0 || (!hitFront && !backvis)) {
1694 –      /* Proxy geometry present, so use it instead and transfer ray */
1695 –      photonRay(rayIn, &rayOut, PMAP_XFER, NULL);
1696 –      tracePhoton(&rayOut);
1697 –      
1698 –      return 0;
1699 –   }
1454  
1455     /* Get BSDF data */
1456     nd.sd = loadBSDF(mat -> oargs.sarg [1]);
# Line 1810 | Line 1564 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1564     if (prDiff + ptDiff + prDiffSD + ptDiffSD > FTINY)
1565        addPhotons(rayIn);        
1566  
1567 <   xi = xi2 = pmapRandom(rouletteState);
1567 >   xi = pmapRandom(rouletteState);
1568        
1569     if (xi > albedo)
1570        /* Absorbtion */
1571        return 0;
1572    
1573 +   transmitted = 0;
1574 +
1575     if ((xi -= prDiff) <= 0) {
1576        /* Diffuse reflection (extra component in material def) */
1577        photonRay(rayIn, &rayOut, PMAP_DIFFREFL, nd.rdiff);
# Line 1825 | Line 1581 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1581     else if ((xi -= ptDiff) <= 0) {
1582        /* Diffuse transmission (extra component in material def) */
1583        flipsurface(rayIn);
1584 +      nd.thick = -nd.thick;
1585        photonRay(rayIn, &rayOut, PMAP_DIFFTRANS, nd.tdiff);
1586 <      diffPhotonScatter(nd.pnorm, &rayOut);      
1586 >      diffPhotonScatter(nd.pnorm, &rayOut);
1587 >      transmitted = 1;
1588     }
1589 <  
1589 >  
1590     else {   /* Sample SDF */
1591        if ((xi -= prDiffSD) <= 0) {
1592           /* Diffuse SDF reflection (constant component) */
1593 <         if ((err = SDsampBSDF(&bsdfVal, nd.vray, xi2,
1593 >         if ((err = SDsampBSDF(&bsdfVal, nd.vray, pmapRandom(scatterState),
1594                                 SDsampDf | SDsampR, nd.sd)))
1595              objerror(mat, USER, transSDError(err));
1596          
# Line 1844 | Line 1602 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1602  
1603        else if ((xi -= ptDiffSD) <= 0) {
1604           /* Diffuse SDF transmission (constant component) */
1605 <         if ((err = SDsampBSDF(&bsdfVal, nd.vray, xi2,
1605 >         if ((err = SDsampBSDF(&bsdfVal, nd.vray, pmapRandom(scatterState),
1606                                 SDsampDf | SDsampT, nd.sd)))
1607              objerror(mat, USER, transSDError(err));
1608          
# Line 1853 | Line 1611 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1611           multcolor(bsdfRGB, rayIn -> pcol);
1612           addcolor(bsdfRGB, nd.tdiff);      
1613           flipsurface(rayIn);  /* Necessary? */
1614 +         nd.thick = -nd.thick;
1615           photonRay(rayIn, &rayOut, PMAP_DIFFTRANS, bsdfRGB);
1616 +         transmitted = 1;
1617        }
1618  
1619        else if ((xi -= prSpecSD) <= 0) {
1620           /* Non-diffuse ("specular") SDF reflection */
1621 <         if ((err = SDsampBSDF(&bsdfVal, nd.vray, xi2,
1621 >         if ((err = SDsampBSDF(&bsdfVal, nd.vray, pmapRandom(scatterState),
1622                                 SDsampSp | SDsampR, nd.sd)))
1623              objerror(mat, USER, transSDError(err));
1624          
# Line 1868 | Line 1628 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1628        
1629        else {
1630           /* Non-diffuse ("specular") SDF transmission */
1631 <         if ((err = SDsampBSDF(&bsdfVal, nd.vray, xi2,
1631 >         if ((err = SDsampBSDF(&bsdfVal, nd.vray, pmapRandom(scatterState),
1632                                 SDsampSp | SDsampT, nd.sd)))
1633              objerror(mat, USER, transSDError(err));
1634  
# Line 1876 | Line 1636 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1636           ccy2rgb(&bsdfVal.spec, bsdfVal.cieY, bsdfRGB);
1637           multcolor(bsdfRGB, rayIn -> pcol);
1638           flipsurface(rayIn);  /* Necessary? */
1639 +         nd.thick = -nd.thick;
1640           photonRay(rayIn, &rayOut, PMAP_SPECTRANS, bsdfRGB);
1641 +         transmitted = 1;
1642        }      
1643        
1644        /* Xform outgoing dir to world coords */
# Line 1889 | Line 1651 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1651     /* Clean up */
1652     SDfreeCache(nd.sd);
1653  
1654 +   /* Need to offset ray origin to get past detail geometry? */
1655 +   if (transmitted && nd.thick != 0)
1656 +      VSUM(rayOut.rorg, rayOut.rorg, rayIn -> ron, -nd.thick);
1657 +
1658     tracePhoton(&rayOut);
1659     return 0;
1660   }
1895 – #endif
1661  
1662  
1663  

Diff Legend

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