| 151 |
|
for (li = 0; ndx >= ab->lat[li].nphis; li++) |
| 152 |
|
ndx -= ab->lat[li].nphis; |
| 153 |
|
SDmultiSamp(rx, 2, randX); |
| 154 |
< |
d = (1. - randX)*sq(cos(M_PI/180.*ab->lat[li].tmin)) + |
| 155 |
< |
randX*sq(cos(M_PI/180.*ab->lat[li+1].tmin)); |
| 154 |
> |
d = (1. - rx[0])*sq(cos(M_PI/180.*ab->lat[li].tmin)) + |
| 155 |
> |
rx[0]*sq(cos(M_PI/180.*ab->lat[li+1].tmin)); |
| 156 |
|
v[2] = d = sqrt(d); /* cos(pol) */ |
| 157 |
|
azi = 2.*M_PI*(ndx + rx[1] - .5)/ab->lat[li].nphis; |
| 158 |
|
d = sqrt(1. - d*d); /* sin(pol) */ |
| 171 |
|
|
| 172 |
|
if (v == NULL) |
| 173 |
|
return -1; |
| 174 |
< |
if ((v[2] < 0) | (v[2] > 1.)) |
| 174 |
> |
if ((v[2] < 0) | (v[2] > 1.00001)) |
| 175 |
|
return -1; |
| 176 |
|
pol = 180.0/M_PI*Acos(v[2]); |
| 177 |
|
azi = 180.0/M_PI*atan2(v[1], v[0]); |
| 191 |
|
double |
| 192 |
|
io_getohm(int ndx, void *p) |
| 193 |
|
{ |
| 194 |
+ |
static void *last_p = NULL; |
| 195 |
|
static int last_li = -1; |
| 196 |
|
static double last_ohm; |
| 197 |
|
ANGLE_BASIS *ab = (ANGLE_BASIS *)p; |
| 202 |
|
return -1.; |
| 203 |
|
for (li = 0; ndx >= ab->lat[li].nphis; li++) |
| 204 |
|
ndx -= ab->lat[li].nphis; |
| 205 |
< |
if (li == last_li) /* cached latitude? */ |
| 205 |
> |
if ((p == last_p) & (li == last_li)) /* cached latitude? */ |
| 206 |
|
return last_ohm; |
| 207 |
+ |
last_p = p; |
| 208 |
|
last_li = li; |
| 209 |
|
theta = M_PI/180. * ab->lat[li].tmin; |
| 210 |
|
theta1 = M_PI/180. * ab->lat[li+1].tmin; |
| 296 |
|
{ |
| 297 |
|
C_COLOR cxy; |
| 298 |
|
|
| 299 |
< |
coef[0] = mBSDF_value(dp, i, o); |
| 299 |
> |
coef[0] = mBSDF_value(dp, o, i); |
| 300 |
|
if (dp->chroma == NULL) |
| 301 |
|
return 1; /* grayscale */ |
| 302 |
|
|
| 303 |
< |
c_decodeChroma(&cxy, dp->chroma[o*dp->ninc + i]); |
| 303 |
> |
c_decodeChroma(&cxy, mBSDF_chroma(dp,o,i)); |
| 304 |
|
c_toSharpRGB(&cxy, coef[0], coef); |
| 305 |
|
coef[0] *= mtx_RGB_coef[0]; |
| 306 |
|
coef[1] *= mtx_RGB_coef[1]; |
| 383 |
|
for (i = dp->ninc; i--; ) { |
| 384 |
|
double hemi = .0; |
| 385 |
|
for (o = dp->nout; o--; ) |
| 386 |
< |
hemi += ohma[o] * mBSDF_value(dp, i, o); |
| 386 |
> |
hemi += ohma[o] * mBSDF_value(dp, o, i); |
| 387 |
|
if (hemi > df->maxHemi) |
| 388 |
|
df->maxHemi = hemi; |
| 389 |
|
} |
| 519 |
|
if (rowinc) { |
| 520 |
|
int r = i/dp->nout; |
| 521 |
|
int c = i - r*dp->nout; |
| 522 |
< |
mBSDF_value(dp,r,c) = val; |
| 522 |
> |
mBSDF_value(dp,c,r) = val; |
| 523 |
|
} else |
| 524 |
|
dp->bsdf[i] = val; |
| 525 |
|
sdata = sdnext; |
| 624 |
|
coef[c] = (coef[c] - min_coef[c]) / |
| 625 |
|
mtx_RGB_coef[c]; |
| 626 |
|
if (c_fromSharpRGB(coef, &cxy) > 1e-5) |
| 627 |
< |
sm->chroma[o*sm->ninc + i] = c_encodeChroma(&cxy); |
| 628 |
< |
mBSDF_value(sm,i,o) -= ymin; |
| 627 |
> |
mBSDF_chroma(sm,o,i) = c_encodeChroma(&cxy); |
| 628 |
> |
mBSDF_value(sm,o,i) -= ymin; |
| 629 |
|
} |
| 630 |
|
/* return colored minimum */ |
| 631 |
|
for (i = 3; i--; ) |
| 649 |
|
/* subtract minimum value */ |
| 650 |
|
dv->cieY = subtract_min(&dv->spec, (SDMat *)df->comp[0].dist); |
| 651 |
|
df->maxHemi -= dv->cieY; /* adjust maximum hemispherical */ |
| 652 |
< |
/* make sure everything is set */ |
| 653 |
< |
c_ccvt(&dv->spec, C_CSXY+C_CSSPEC); |
| 652 |
> |
|
| 653 |
> |
c_ccvt(&dv->spec, C_CSXY); /* make sure (x,y) is set */ |
| 654 |
|
return df; |
| 655 |
|
} |
| 656 |
|
|
| 709 |
|
/* separate diffuse components */ |
| 710 |
|
sd->rf = extract_diffuse(&sd->rLambFront, sd->rf); |
| 711 |
|
sd->rb = extract_diffuse(&sd->rLambBack, sd->rb); |
| 712 |
< |
if (sd->tf != NULL) |
| 713 |
< |
sd->tf = extract_diffuse(&sd->tLamb, sd->tf); |
| 714 |
< |
if (sd->tb != NULL) |
| 715 |
< |
sd->tb = extract_diffuse(&sd->tLamb, sd->tb); |
| 712 |
> |
sd->tf = extract_diffuse(&sd->tLambFront, sd->tf); |
| 713 |
> |
if (sd->tb != NULL) { |
| 714 |
> |
sd->tb = extract_diffuse(&sd->tLambBack, sd->tb); |
| 715 |
> |
if (sd->tf == NULL) |
| 716 |
> |
sd->tLambFront = sd->tLambBack; |
| 717 |
> |
} else if (sd->tf != NULL) |
| 718 |
> |
sd->tLambBack = sd->tLambFront; |
| 719 |
|
/* return success */ |
| 720 |
|
return SDEnone; |
| 721 |
|
} |
| 722 |
|
|
| 723 |
|
/* Get Matrix BSDF value */ |
| 724 |
|
static int |
| 725 |
< |
SDgetMtxBSDF(float coef[SDmaxCh], const FVECT outVec, |
| 726 |
< |
const FVECT inVec, SDComponent *sdc) |
| 725 |
> |
SDgetMtxBSDF(float coef[SDmaxCh], const FVECT inVec, |
| 726 |
> |
const FVECT outVec, SDComponent *sdc) |
| 727 |
|
{ |
| 728 |
|
const SDMat *dp; |
| 729 |
|
int i_ndx, o_ndx; |
| 808 |
|
cmtab[0] = .0; |
| 809 |
|
for (o = 0; o < cd->calen; o++) { |
| 810 |
|
if (rev) |
| 811 |
< |
cmtab[o+1] = mBSDF_value(dp, o, cd->indx) * |
| 811 |
> |
cmtab[o+1] = mBSDF_value(dp, cd->indx, o) * |
| 812 |
|
(*dp->ib_ohm)(o, dp->ib_priv); |
| 813 |
|
else |
| 814 |
< |
cmtab[o+1] = mBSDF_value(dp, cd->indx, o) * |
| 814 |
> |
cmtab[o+1] = mBSDF_value(dp, o, cd->indx) * |
| 815 |
|
(*dp->ob_ohm)(o, dp->ob_priv); |
| 816 |
|
cmtab[o+1] += cmtab[o]; |
| 817 |
|
} |
| 854 |
|
reverse = 1; |
| 855 |
|
} |
| 856 |
|
cdlast = NULL; /* check for it in cache list */ |
| 857 |
+ |
/* PLACE MUTEX LOCK HERE FOR THREAD-SAFE */ |
| 858 |
|
for (cd = (SDMatCDst *)sdc->cdList; cd != NULL; |
| 859 |
|
cdlast = cd, cd = cd->next) |
| 860 |
|
if (cd->indx == myCD.indx && (cd->calen == myCD.calen) & |
| 878 |
|
cd->next = (SDMatCDst *)sdc->cdList; |
| 879 |
|
sdc->cdList = (SDCDst *)cd; |
| 880 |
|
} |
| 881 |
+ |
/* END MUTEX LOCK */ |
| 882 |
|
return (SDCDst *)cd; /* ready to go */ |
| 883 |
|
} |
| 884 |
|
|
| 911 |
|
} |
| 912 |
|
|
| 913 |
|
/* Fixed resolution BSDF methods */ |
| 914 |
< |
SDFunc SDhandleMtx = { |
| 914 |
> |
const SDFunc SDhandleMtx = { |
| 915 |
|
&SDgetMtxBSDF, |
| 916 |
|
&SDqueryMtxProjSA, |
| 917 |
|
&SDgetMtxCDist, |
