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 |
|
|
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; |
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) { |
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] + |
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; |
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)) { |
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; |
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); |
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 */ |
569 |
|
} |
570 |
|
} |
571 |
|
|
572 |
< |
return 0; |
572 |
> |
return 0; |
573 |
|
} |
574 |
|
|
575 |
|
else { |
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] + |
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 { |
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 */ |
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++) |
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]; |
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); |
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) { |
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 |
|
|
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 |
|
} |
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 |
|
|
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 |
|
|
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 |
|
|
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. */ |
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 */ |
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); |
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)); |
1954 |
|
{ |
1955 |
|
int i; |
1956 |
|
|
1957 |
+ |
/* Catch-all for inconsistencies */ |
1958 |
|
for (i = 0; i < NUMOTYPE; i++) |
1959 |
|
photonScatter [i] = o_default; |
1960 |
|
|
1985 |
|
photonScatter [TEX_DATA] = pattexPhotonScatter; |
1986 |
|
|
1987 |
|
photonScatter [MOD_ALIAS] = aliasPhotonScatter; |
1988 |
+ |
photonScatter [MAT_BRTDF] = brtdFuncPhotonScatter; |
1989 |
|
photonScatter [MAT_BSDF] = |
1990 |
< |
photonScatter [MAT_SBSDF] = bsdfPhotonScatter; |
1990 |
> |
photonScatter [MAT_ABSDF] = bsdfPhotonScatter; |
1991 |
|
} |