| 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 */ |
| 91 |
|
SDData *sd; /* loaded BSDF data */ |
| 92 |
|
COLOR rdiff; /* diffuse reflection */ |
| 93 |
|
COLOR runsamp; /* BSDF hemispherical reflection */ |
| 117 |
|
static void |
| 118 |
|
compute_through(BSDFDAT *ndp) |
| 119 |
|
{ |
| 120 |
< |
#define NDIR2CHECK 13 |
| 120 |
> |
#define NDIR2CHECK 29 |
| 121 |
|
static const float dir2check[NDIR2CHECK][2] = { |
| 122 |
< |
{0, 0}, |
| 123 |
< |
{-0.8, 0}, |
| 124 |
< |
{0, 0.8}, |
| 125 |
< |
{0, -0.8}, |
| 126 |
< |
{0.8, 0}, |
| 127 |
< |
{-0.8, 0.8}, |
| 128 |
< |
{-0.8, -0.8}, |
| 129 |
< |
{0.8, 0.8}, |
| 130 |
< |
{0.8, -0.8}, |
| 131 |
< |
{-1.6, 0}, |
| 131 |
< |
{0, 1.6}, |
| 132 |
< |
{0, -1.6}, |
| 133 |
< |
{1.6, 0}, |
| 122 |
> |
{0, 0}, {-0.6, 0}, {0, 0.6}, |
| 123 |
> |
{0, -0.6}, {0.6, 0}, {-0.6, 0.6}, |
| 124 |
> |
{-0.6, -0.6}, {0.6, 0.6}, {0.6, -0.6}, |
| 125 |
> |
{-1.2, 0}, {0, 1.2}, {0, -1.2}, |
| 126 |
> |
{1.2, 0}, {-1.2, 1.2}, {-1.2, -1.2}, |
| 127 |
> |
{1.2, 1.2}, {1.2, -1.2}, {-1.8, 0}, |
| 128 |
> |
{0, 1.8}, {0, -1.8}, {1.8, 0}, |
| 129 |
> |
{-1.8, 1.8}, {-1.8, -1.8}, {1.8, 1.8}, |
| 130 |
> |
{1.8, -1.8}, {-2.4, 0}, {0, 2.4}, |
| 131 |
> |
{0, -2.4}, {2.4, 0}, |
| 132 |
|
}; |
| 133 |
|
const double peak_over = 1.5; |
| 134 |
|
PEAKSAMP psamp[NDIR2CHECK]; |
| 135 |
|
SDSpectralDF *dfp; |
| 136 |
|
FVECT pdir; |
| 137 |
|
double tomega, srchrad; |
| 138 |
< |
double tomsum; |
| 139 |
< |
COLOR vpeak; |
| 140 |
< |
double vypeak, vysum; |
| 141 |
< |
int i, ns, ntot; |
| 138 |
> |
double tomsum, tomsurr; |
| 139 |
> |
COLOR vpeak, vsurr; |
| 140 |
> |
double vypeak; |
| 141 |
> |
int i, ns; |
| 142 |
|
SDError ec; |
| 143 |
|
|
| 144 |
|
if (ndp->pr->rod > 0) |
| 151 |
|
if (bright(ndp->pr->pcol) <= FTINY) |
| 152 |
|
return; /* pattern is black, here */ |
| 153 |
|
srchrad = sqrt(dfp->minProjSA); /* else evaluate peak */ |
| 156 |
– |
vysum = 0; |
| 154 |
|
for (i = 0; i < NDIR2CHECK; i++) { |
| 155 |
|
SDValue sv; |
| 156 |
|
psamp[i].tdir[0] = -ndp->vray[0] + dir2check[i][0]*srchrad; |
| 161 |
|
if (ec) |
| 162 |
|
goto baderror; |
| 163 |
|
cvt_sdcolor(psamp[i].vcol, &sv); |
| 164 |
< |
vysum += psamp[i].vy = sv.cieY; |
| 164 |
> |
psamp[i].vy = sv.cieY; |
| 165 |
|
} |
| 169 |
– |
if (vysum <= FTINY) /* zero neighborhood? */ |
| 170 |
– |
return; |
| 166 |
|
qsort(psamp, NDIR2CHECK, sizeof(PEAKSAMP), cmp_psamp); |
| 167 |
+ |
if (psamp[0].vy <= FTINY) |
| 168 |
+ |
return; /* zero area */ |
| 169 |
|
setcolor(vpeak, 0, 0, 0); |
| 170 |
< |
vypeak = tomsum = 0; /* combine top unique values */ |
| 171 |
< |
ns = 0; ntot = NDIR2CHECK; |
| 170 |
> |
setcolor(vsurr, 0, 0, 0); |
| 171 |
> |
vypeak = tomsum = tomsurr = 0; /* combine top unique values */ |
| 172 |
> |
ns = 0; |
| 173 |
|
for (i = 0; i < NDIR2CHECK; i++) { |
| 174 |
< |
if (i) { |
| 175 |
< |
if (psamp[i].vy == psamp[i-1].vy) { |
| 176 |
< |
vysum -= psamp[i].vy; |
| 179 |
< |
--ntot; |
| 180 |
< |
continue; /* assume duplicate sample */ |
| 181 |
< |
} |
| 182 |
< |
if (vypeak > 8.*psamp[i].vy*ns) |
| 183 |
< |
continue; /* peak cut-off */ |
| 184 |
< |
} |
| 174 |
> |
if (i && psamp[i].vy == psamp[i-1].vy) |
| 175 |
> |
continue; /* assume duplicate sample */ |
| 176 |
> |
|
| 177 |
|
ec = SDsizeBSDF(&tomega, psamp[i].tdir, ndp->vray, |
| 178 |
|
SDqueryMin, ndp->sd); |
| 179 |
|
if (ec) |
| 180 |
|
goto baderror; |
| 181 |
< |
if (tomega > 1.5*dfp->minProjSA) { |
| 182 |
< |
if (!i) return; /* not really a peak? */ |
| 181 |
> |
/* not really a peak? */ |
| 182 |
> |
if (tomega > 1.5*dfp->minProjSA || |
| 183 |
> |
vypeak > 8.*psamp[i].vy*ns) { |
| 184 |
> |
if (!i) return; /* abort */ |
| 185 |
> |
scalecolor(psamp[i].vcol, tomega); |
| 186 |
> |
addcolor(vsurr, psamp[i].vcol); |
| 187 |
> |
tomsurr += tomega; |
| 188 |
|
continue; |
| 189 |
|
} |
| 190 |
|
scalecolor(psamp[i].vcol, tomega); |
| 193 |
|
vypeak += psamp[i].vy; |
| 194 |
|
++ns; |
| 195 |
|
} |
| 196 |
< |
if (vypeak*(ntot-ns) < peak_over*(vysum-vypeak)*ns) |
| 196 |
> |
if (vypeak*tomsurr < peak_over*bright(vsurr)*ns) |
| 197 |
|
return; /* peak not peaky enough */ |
| 198 |
|
if ((vypeak/ns - ndp->sd->tLamb.cieY*(1./PI))*tomsum <= .001) |
| 199 |
|
return; /* < 0.1% transmission */ |
| 200 |
|
copycolor(ndp->cthru, vpeak); /* already scaled by omega */ |
| 201 |
|
multcolor(ndp->cthru, ndp->pr->pcol); /* modify by pattern */ |
| 202 |
+ |
if (tomsurr > FTINY) { /* surround contribution? */ |
| 203 |
+ |
scalecolor(vsurr, 1./tomsurr); /* this one is avg. BTDF */ |
| 204 |
+ |
copycolor(ndp->cthru_surr, vsurr); |
| 205 |
+ |
multcolor(ndp->cthru_surr, ndp->pr->pcol); |
| 206 |
+ |
} |
| 207 |
|
return; |
| 208 |
|
baderror: |
| 209 |
|
objerror(ndp->mp, USER, transSDError(ec)); |
| 279 |
|
((ndp->sd->tb != NULL) ? ndp->sd->tb : ndp->sd->tf) ; |
| 280 |
|
|
| 281 |
|
if (dx*dx + dy*dy <= (2.5*4./PI)*(omega + dfp->minProjSA + |
| 282 |
< |
2.*sqrt(omega*dfp->minProjSA))) |
| 283 |
< |
return(0); |
| 282 |
> |
2.*sqrt(omega*dfp->minProjSA))) { |
| 283 |
> |
if (bright(ndp->cthru_surr) <= FTINY) |
| 284 |
> |
return(0); |
| 285 |
> |
copycolor(cval, ndp->cthru_surr); |
| 286 |
> |
return(1); /* return non-zero surround BTDF */ |
| 287 |
> |
} |
| 288 |
|
} |
| 289 |
|
ec = SDsizeBSDF(&tomega, ndp->vray, vsrc, SDqueryMin, ndp->sd); |
| 290 |
|
if (ec) |
| 736 |
|
return(1); |
| 737 |
|
} |
| 738 |
|
setcolor(nd.cthru, 0, 0, 0); /* consider through component */ |
| 739 |
+ |
setcolor(nd.cthru_surr, 0, 0, 0); |
| 740 |
|
if (m->otype == MAT_ABSDF) { |
| 741 |
|
compute_through(&nd); |
| 742 |
|
if (r->crtype & SHADOW) { |
