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.3 by rschregle, Fri May 8 13:20:23 2015 UTC vs.
Revision 2.7 by rschregle, Wed May 27 17:54:19 2015 UTC

# Line 199 | Line 199 | static int isoSpecPhotonScatter (NORMDAT *nd, RAY *ray
199     int      niter, i = 0;
200    
201     /* Set up sample coordinates */  
202 <   do {
203 <      v [0] = v [1] = v [2] = 0;
204 <      v [i++] = 1;
205 <      fcross(u, v, nd -> pnorm);
206 <   } while (normalize(u) < FTINY);
207 <  
202 >   getperpendicular(u, nd -> pnorm, 1);  
203     fcross(v, nd -> pnorm, u);
204    
205     if (nd -> specfl & SP_REFL) {
# Line 268 | Line 263 | static void diffPhotonScatter (FVECT normal, RAY* rayO
263     int         i = 0;
264  
265     /* Set up sample coordinates */
266 <   do {
272 <      v [0] = v [1] = v [2] = 0;
273 <      v [i++] = 1;
274 <      fcross(u, v, normal);
275 <   } while (normalize(u) < FTINY);
276 <  
266 >   getperpendicular(u, normal, 1);
267     fcross(v, normal, u);
268    
269     /* Convert theta & phi to cartesian */
# Line 324 | Line 314 | static int normalPhotonScatter (OBJREC *mat, RAY *rayI
314        nd.specfl |= SP_FLAT;  
315        
316     /* Perturb normal */
317 <   if ((hastexture = DOT(rayIn -> pert, rayIn -> pert)) > sqr(FTINY))
317 >   if ((hastexture = (DOT(rayIn -> pert, rayIn -> pert) > sqr(FTINY)) ))
318        nd.pdot = raynormal(nd.pnorm, rayIn);
319     else {
320        VCOPY(nd.pnorm, rayIn -> ron);
# Line 753 | Line 743 | static int dielectricPhotonScatter (OBJREC *mat, RAY *
743     /* get modifiers */
744     raytexture(rayIn, mat -> omod);                      
745    
746 <   if ((hastexture = DOT(rayIn -> pert, rayIn -> pert)) > FTINY * FTINY)
746 >   if ((hastexture = (DOT(rayIn -> pert, rayIn -> pert) > FTINY * FTINY)))
747        /* Perturb normal */
748        cos1 = raynormal(dnorm, rayIn);
749     else {
# Line 900 | Line 890 | static int glassPhotonScatter (OBJREC *mat, RAY *rayIn
890     /* reorient if necessary */
891     if (rayIn -> rod < 0)
892        flipsurface(rayIn);
893 <   if ((hastexture = DOT(rayIn -> pert, rayIn -> pert)) > FTINY * FTINY)
893 >   if ((hastexture = (DOT(rayIn -> pert, rayIn -> pert) > FTINY * FTINY) ))
894        pdot = raynormal(pnorm, rayIn);
895     else {
896        VCOPY(pnorm, rayIn -> ron);
# Line 1384 | Line 1374 | static int pattexPhotonScatter (OBJREC *mat, RAY *rayI
1374  
1375  
1376  
1387 – #if 0
1388 –   static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1389 –   /* Generate new photon ray for BSDF modifier and recurse. */
1390 –   {
1391 –      int      hitFront;
1392 –      SDError  err;
1393 –      FVECT        upvec;
1394 –      MFUNC        *mf;
1395 –      BSDFDAT   nd;
1396 –      RAY      rayOut;
1397 –
1398 –      /* Following code adapted from m_bsdf() */
1399 –      /* Check arguments */
1400 –      if (mat -> oargs.nsargs < 6 || mat -> oargs.nfargs > 9 ||
1401 –          mat -> oargs.nfargs % 3)
1402 –         objerror(mat, USER, "bad # arguments");
1403 –        
1404 –      hitFront = (rayIn -> rod > 0);
1405 –
1406 –      /* Load cal file */
1407 –      mf = getfunc(mat, 5, 0x1d, 1);
1408 –      
1409 –      /* Get thickness */
1410 –      nd.thick = evalue(mf -> ep [0]);
1411 –      if ((-FTINY <= nd.thick) & (nd.thick <= FTINY))
1412 –         nd.thick = .0;
1413 –        
1414 –      if (nd.thick != .0 || (!hitFront && !backvis)) {
1415 –         /* Proxy geometry present, so use it instead and transfer ray */
1416 –         photonRay(rayIn, &rayOut, PMAP_XFER, NULL);
1417 –         tracePhoton(&rayOut);
1418 –        
1419 –         return 0;
1420 –      }
1421 –
1422 –      /* Get BSDF data */
1423 –      nd.sd = loadBSDF(mat -> oargs.sarg [1]);
1424 –      
1425 –      /* Diffuse reflectance */
1426 –      if (hitFront) {
1427 –         if (mat -> oargs.nfargs < 3)
1428 –            setcolor(nd.rdiff, .0, .0, .0);
1429 –         else setcolor(nd.rdiff, mat -> oargs.farg [0], mat -> oargs.farg [1],
1430 –                       mat -> oargs.farg [2]);
1431 –      }    
1432 –      else if (mat -> oargs.nfargs < 6) {
1433 –         /* Check for absorbing backside */
1434 –         if (!backvis && !nd.sd -> rb && !nd.sd -> tf) {
1435 –            SDfreeCache(nd.sd);                    
1436 –            return 0;
1437 –         }
1438 –        
1439 –         setcolor(nd.rdiff, .0, .0, .0);
1440 –      }
1441 –      else setcolor(nd.rdiff, mat -> oargs.farg [3], mat -> oargs.farg [4],
1442 –                    mat -> oargs.farg [5]);
1443 –
1444 –      /* Diffuse transmittance */
1445 –      if (mat -> oargs.nfargs < 9)
1446 –         setcolor(nd.tdiff, .0, .0, .0);
1447 –      else setcolor(nd.tdiff, mat -> oargs.farg [6], mat -> oargs.farg [7],
1448 –                    mat -> oargs.farg [8]);
1449 –                  
1450 –      nd.mp = mat;
1451 –      nd.pr = rayIn;
1452 –      
1453 –      /* Get modifiers */
1454 –      raytexture(rayIn, mat -> omod);
1455 –      
1456 –      /* Modify diffuse values */
1457 –      multcolor(nd.rdiff, rayIn -> pcol);
1458 –      multcolor(nd.tdiff, rayIn -> pcol);
1459 –        
1460 –      /* Get up vector & xform to world coords */
1461 –      upvec [0] = evalue(mf -> ep [1]);
1462 –      upvec [1] = evalue(mf -> ep [2]);
1463 –      upvec [2] = evalue(mf -> ep [3]);
1464 –      
1465 –      if (mf -> fxp != &unitxf) {
1466 –         multv3(upvec, upvec, mf -> fxp -> xfm);
1467 –         nd.thick *= mf -> fxp -> sca;
1468 –      }
1469 –      
1470 –      if (rayIn -> rox) {
1471 –         multv3(upvec, upvec, rayIn -> rox -> f.xfm);
1472 –         nd.thick *= rayIn -> rox -> f.sca;
1473 –      }
1474 –      
1475 –      /* Perturb normal */
1476 –      raynormal(nd.pnorm, rayIn);
1477 –      
1478 –      /* Xform incident dir to local BSDF coords */
1479 –      err = SDcompXform(nd.toloc, nd.pnorm, upvec);
1480 –      
1481 –      if (!err) {
1482 –         nd.vray [0] = -rayIn -> rdir [0];
1483 –         nd.vray [1] = -rayIn -> rdir [1];
1484 –         nd.vray [2] = -rayIn -> rdir [2];
1485 –         err = SDmapDir(nd.vray, nd.toloc, nd.vray);
1486 –      }
1487 –      
1488 –      if (!err)
1489 –         err = SDinvXform(nd.fromloc, nd.toloc);
1490 –        
1491 –      if (err) {
1492 –         objerror(mat, WARNING, "Illegal orientation vector");
1493 –         return 0;
1494 –      }
1495 –      
1496 –      /* Determine BSDF resolution */
1497 –      err = SDsizeBSDF(nd.sr_vpsa, nd.vray, NULL, SDqueryMin + SDqueryMax, nd.sd);
1498 –      
1499 –      if (err)
1500 –         objerror(mat, USER, transSDError(err));
1501 –        
1502 –      nd.sr_vpsa [0] = sqrt(nd.sr_vpsa [0]);
1503 –      nd.sr_vpsa [1] = sqrt(nd.sr_vpsa [1]);
1504 –
1505 –      /* Orient perturbed normal towards incident side */
1506 –      if (!hitFront) {                  
1507 –         nd.pnorm [0] = -nd.pnorm [0];
1508 –         nd.pnorm [1] = -nd.pnorm [1];
1509 –         nd.pnorm [2] = -nd.pnorm [2];
1510 –      }
1511 –      
1512 –      /* Following code adapted from SDsampBSDF() */
1513 –      {
1514 –         SDSpectralDF   *rdf, *tdf;
1515 –         SDValue        bsdfVal;
1516 –         double         xi, rhoDiff = 0;
1517 –         float          coef [SDmaxCh];
1518 –         int            i, j, n, nr;
1519 –         SDComponent       *sdc;
1520 –         const SDCDst   **cdarr = NULL;
1521 –        
1522 –         /* Get diffuse albedo (?) */
1523 –         if (hitFront) {
1524 –            bsdfVal = nd.sd -> rLambFront;
1525 –            rdf = nd.sd -> rf;
1526 –            tdf = nd.sd -> tf ? nd.sd -> tf : nd.sd -> tb;
1527 –         }
1528 –         else {
1529 –            bsdfVal = nd.sd -> rLambBack;
1530 –            rdf = nd.sd -> rb;
1531 –            tdf = nd.sd -> tb ? nd.sd -> tb : nd.sd -> tf;
1532 –         }
1533 –        
1534 –         rhoDiff = bsdfVal.cieY;
1535 –         bsdfVal.cieY += nd.sd -> tLamb.cieY;
1536 –        
1537 –         /* Allocate non-diffuse sampling */
1538 –         i = nr = rdf ? rdf -> ncomp : 0;
1539 –         j = tdf ? tdf -> ncomp : 0;
1540 –         n = i + j;
1541 –        
1542 –         if (n > 0 && !(cdarr = (const SDCDst**)malloc(n * sizeof(SDCDst*))))
1543 –            objerror(mat, USER, transSDError(SDEmemory));
1544 –            
1545 –         while (j-- > 0) {
1546 –            /* Sum up non-diffuse transmittance */
1547 –            cdarr [i + j] = (*tdf -> comp [j].func -> getCDist)(nd.vray, &tdf -> comp [j]);
1548 –            
1549 –            if (!cdarr [i + j])
1550 –               cdarr [i + j] = &SDemptyCD;
1551 –            else bsdfVal.cieY += cdarr [i + j] -> cTotal;
1552 –         }
1553 –        
1554 –         while (i-- > 0) {
1555 –            /* Sum up non-diffuse reflectance */
1556 –            cdarr [i] = (*rdf -> comp [i].func -> getCDist)(nd.vray, &rdf -> comp [i]);
1557 –            
1558 –            if (!cdarr [i])
1559 –               cdarr [i] = &SDemptyCD;
1560 –            else bsdfVal.cieY += cdarr [i] -> cTotal;
1561 –         }
1562 –        
1563 –         if (bsdfVal.cieY <= FTINY) {
1564 –            /* Don't bother sampling, just absorb photon */
1565 –            if (cdarr)
1566 –               free(cdarr);
1567 –            return 0;
1568 –         }      
1569 –        
1570 –         /* Insert direct and indirect photon hits if diffuse component */
1571 –         if (rhoDiff > FTINY || nd.sd -> tLamb.cieY > FTINY)
1572 –            addPhotons(rayIn);  
1573 –            
1574 –         xi = pmapRandom(rouletteState);
1575 –        
1576 –         if ((xi -= rhoDiff) <= 0) {
1577 –            /* Diffuse reflection */
1578 –            photonRay(rayIn, &rayOut, PMAP_DIFFREFL, nd.rdiff);
1579 –            diffPhotonScatter(nd.pnorm, &rayOut);
1580 –         }
1581 –         else if ((xi -= nd.sd -> tLamb.cieY) <= 0) {
1582 –            /* Diffuse transmission */
1583 –            flipsurface(rayIn);
1584 –            photonRay(rayIn, &rayOut, PMAP_DIFFTRANS, nd.tdiff);
1585 –            bsdfVal.spec = nd.sd -> tLamb.spec;
1586 –            diffPhotonScatter(nd.pnorm, &rayOut);
1587 –         }
1588 –         else {
1589 –            int rayOutType;
1590 –            COLOR bsdfRGB;
1591 –              
1592 –            /* Non-diffuse CDF inversion (?) */
1593 –            for (i = 0; i < n && (xi -= cdarr [i] -> cTotal) > 0; i++);
1594 –            
1595 –            if (i >= n) {
1596 –               /* Absorbed -- photon went Deer Hunter */
1597 –               if (cdarr)
1598 –                  free(cdarr);
1599 –               return 0;
1600 –            }
1601 –
1602 –            if (i < nr) {
1603 –               /* Non-diffuse reflection */
1604 –               sdc = &rdf -> comp [i];
1605 –               rayOutType = PMAP_SPECREFL;
1606 –            }
1607 –            else {
1608 –               /* Non-diffuse transmission */
1609 –               sdc = &tdf -> comp [i - nr];
1610 –               rayOutType = PMAP_SPECTRANS;
1611 –            }
1612 –            
1613 –            /* Generate non-diff sample dir */
1614 –            VCOPY(rayOut.rdir, nd.vray);
1615 –            err = (*sdc -> func -> sampCDist)
1616 –                  (rayOut.rdir, pmapRandom(scatterState), cdarr [i]);              
1617 –            if (err)
1618 –               objerror(mat, USER, transSDError(SDEinternal));
1619 –
1620 –            /* Get colour */
1621 –            j = (*sdc -> func -> getBSDFs)(coef, rayOut.rdir, nd.vray, sdc);
1622 –            
1623 –            if (j <= 0) {
1624 –               sprintf(SDerrorDetail, "BSDF \"%s\" sampling value error",
1625 –                       nd.sd -> name);
1626 –               objerror(mat, USER, transSDError(SDEinternal));
1627 –            }
1628 –            
1629 –            bsdfVal.spec = sdc -> cspec [0];
1630 –            rhoDiff = coef [0];
1631 –            
1632 –            while (--j) {
1633 –               c_cmix(&bsdfVal.spec, rhoDiff, &bsdfVal.spec, coef [j],
1634 –                      &sdc -> cspec [j]);
1635 –               rhoDiff += coef [j];
1636 –            }
1637 –            
1638 –            /* ? */
1639 –            c_ccvt(&bsdfVal.spec, C_CSXY + C_CSSPEC);
1640 –            ccy2rgb(&bsdfVal.spec, bsdfVal.cieY, bsdfRGB);
1641 –            
1642 –            /* Xform outgoing dir to world coords */
1643 –            if ((err = SDmapDir(rayOut.rdir, nd.fromloc, rayOut.rdir))) {
1644 –               objerror(mat, USER, transSDError(err));
1645 –               return 0;
1646 –            }
1647 –            
1648 –            photonRay(rayIn, &rayOut, rayOutType, bsdfRGB);
1649 –         }
1650 –        
1651 –         if (cdarr)
1652 –            free(cdarr);
1653 –      }
1654 –                          
1655 –      /* Clean up BSDF */
1656 –      SDfreeCache(nd.sd);
1657 –
1658 –      tracePhoton(&rayOut);
1659 –      return 0;
1660 –   }
1661 – #else
1662 –
1377   /*
1378 +   ==================================================================
1379     The following code is
1380     (c) Lucerne University of Applied Sciences and Arts,
1381     supported by the Swiss National Science Foundation (SNSF, #147053)
1382 +   ==================================================================
1383   */  
1384  
1385   static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
# Line 1677 | Line 1393 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1393     BSDFDAT      nd;
1394     RAY      rayOut;
1395     COLOR    bsdfRGB;
1396 +   int      transmitted;
1397     double   prDiff, ptDiff, prDiffSD, ptDiffSD, prSpecSD, ptSpecSD,
1398 <            albedo, xi, xi2;
1399 <   const double patAlb = colorAvg(rayIn -> pcol);
1398 >            albedo, xi;
1399 >   const double patAlb = bright(rayIn -> pcol);
1400    
1401     /* Following code adapted from m_bsdf() */
1402     /* Check arguments */
# Line 1696 | Line 1413 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1413          nd.thick = evalue(mf -> ep [0]);
1414          if ((-FTINY <= nd.thick) & (nd.thick <= FTINY))
1415                  nd.thick = .0;
1699 –                
1700 –   if (nd.thick != .0 || (!hitFront && !backvis)) {
1701 –      /* Proxy geometry present, so use it instead and transfer ray */
1702 –      photonRay(rayIn, &rayOut, PMAP_XFER, NULL);
1703 –      tracePhoton(&rayOut);
1704 –      
1705 –      return 0;
1706 –   }
1416  
1417     /* Get BSDF data */
1418     nd.sd = loadBSDF(mat -> oargs.sarg [1]);
# Line 1817 | Line 1526 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1526     if (prDiff + ptDiff + prDiffSD + ptDiffSD > FTINY)
1527        addPhotons(rayIn);        
1528  
1529 <   xi = xi2 = pmapRandom(rouletteState);
1529 >   xi = pmapRandom(rouletteState);
1530        
1531     if (xi > albedo)
1532        /* Absorbtion */
1533        return 0;
1534    
1535 +   transmitted = 0;
1536 +
1537     if ((xi -= prDiff) <= 0) {
1538        /* Diffuse reflection (extra component in material def) */
1539        photonRay(rayIn, &rayOut, PMAP_DIFFREFL, nd.rdiff);
# Line 1832 | Line 1543 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1543     else if ((xi -= ptDiff) <= 0) {
1544        /* Diffuse transmission (extra component in material def) */
1545        flipsurface(rayIn);
1546 +      nd.thick = -nd.thick;
1547        photonRay(rayIn, &rayOut, PMAP_DIFFTRANS, nd.tdiff);
1548 <      diffPhotonScatter(nd.pnorm, &rayOut);      
1548 >      diffPhotonScatter(nd.pnorm, &rayOut);
1549 >      transmitted = 1;
1550     }
1551 <  
1551 >  
1552     else {   /* Sample SDF */
1553        if ((xi -= prDiffSD) <= 0) {
1554           /* Diffuse SDF reflection (constant component) */
1555 <         if ((err = SDsampBSDF(&bsdfVal, nd.vray, xi2,
1555 >         if ((err = SDsampBSDF(&bsdfVal, nd.vray, pmapRandom(scatterState),
1556                                 SDsampDf | SDsampR, nd.sd)))
1557              objerror(mat, USER, transSDError(err));
1558          
# Line 1851 | Line 1564 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1564  
1565        else if ((xi -= ptDiffSD) <= 0) {
1566           /* Diffuse SDF transmission (constant component) */
1567 <         if ((err = SDsampBSDF(&bsdfVal, nd.vray, xi2,
1567 >         if ((err = SDsampBSDF(&bsdfVal, nd.vray, pmapRandom(scatterState),
1568                                 SDsampDf | SDsampT, nd.sd)))
1569              objerror(mat, USER, transSDError(err));
1570          
# Line 1860 | Line 1573 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1573           multcolor(bsdfRGB, rayIn -> pcol);
1574           addcolor(bsdfRGB, nd.tdiff);      
1575           flipsurface(rayIn);  /* Necessary? */
1576 +         nd.thick = -nd.thick;
1577           photonRay(rayIn, &rayOut, PMAP_DIFFTRANS, bsdfRGB);
1578 +         transmitted = 1;
1579        }
1580  
1581        else if ((xi -= prSpecSD) <= 0) {
1582           /* Non-diffuse ("specular") SDF reflection */
1583 <         if ((err = SDsampBSDF(&bsdfVal, nd.vray, xi2,
1583 >         if ((err = SDsampBSDF(&bsdfVal, nd.vray, pmapRandom(scatterState),
1584                                 SDsampSp | SDsampR, nd.sd)))
1585              objerror(mat, USER, transSDError(err));
1586          
# Line 1875 | Line 1590 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1590        
1591        else {
1592           /* Non-diffuse ("specular") SDF transmission */
1593 <         if ((err = SDsampBSDF(&bsdfVal, nd.vray, xi2,
1593 >         if ((err = SDsampBSDF(&bsdfVal, nd.vray, pmapRandom(scatterState),
1594                                 SDsampSp | SDsampT, nd.sd)))
1595              objerror(mat, USER, transSDError(err));
1596  
# Line 1883 | Line 1598 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1598           ccy2rgb(&bsdfVal.spec, bsdfVal.cieY, bsdfRGB);
1599           multcolor(bsdfRGB, rayIn -> pcol);
1600           flipsurface(rayIn);  /* Necessary? */
1601 +         nd.thick = -nd.thick;
1602           photonRay(rayIn, &rayOut, PMAP_SPECTRANS, bsdfRGB);
1603 +         transmitted = 1;
1604        }      
1605        
1606        /* Xform outgoing dir to world coords */
# Line 1896 | Line 1613 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1613     /* Clean up */
1614     SDfreeCache(nd.sd);
1615  
1616 +   /* Need to offset ray origin to get past detail geometry? */
1617 +   if (transmitted && nd.thick != 0)
1618 +      VSUM(rayOut.rorg, rayOut.rorg, rayIn -> ron, -nd.thick);
1619 +
1620     tracePhoton(&rayOut);
1621     return 0;
1622   }
1902 – #endif
1623  
1624  
1625  

Diff Legend

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