47 |
|
OBJREC *mp; /* material pointer */ |
48 |
|
RAY *rp; /* ray pointer */ |
49 |
|
short specfl; /* specularity flags, defined above */ |
50 |
< |
COLOR mcolor; /* color of this material */ |
51 |
< |
COLOR scolor; /* color of specular component */ |
50 |
> |
SCOLOR mcolor; /* color of this material */ |
51 |
> |
SCOLOR scolor; /* color of specular component */ |
52 |
|
FVECT vrefl; /* vector in reflected direction */ |
53 |
|
FVECT prdir; /* vector in transmitted direction */ |
54 |
|
FVECT u, v; /* u and v vectors orienting anisotropy */ |
67 |
|
|
68 |
|
static void |
69 |
|
diraniso( /* compute source contribution */ |
70 |
< |
COLOR cval, /* returned coefficient */ |
70 |
> |
SCOLOR scval, /* returned coefficient */ |
71 |
|
void *nnp, /* material data */ |
72 |
|
FVECT ldir, /* light source direction */ |
73 |
|
double omega /* light source size */ |
78 |
|
double dtmp, dtmp1, dtmp2; |
79 |
|
FVECT h; |
80 |
|
double au2, av2; |
81 |
< |
COLOR ctmp; |
81 |
> |
SCOLOR sctmp; |
82 |
|
|
83 |
< |
setcolor(cval, 0.0, 0.0, 0.0); |
83 |
> |
scolorblack(scval); |
84 |
|
|
85 |
|
ldot = DOT(np->pnorm, ldir); |
86 |
|
|
93 |
|
* color. The diffuse reflected component will always be |
94 |
|
* modified by the color of the material. |
95 |
|
*/ |
96 |
< |
copycolor(ctmp, np->mcolor); |
96 |
> |
copyscolor(sctmp, np->mcolor); |
97 |
|
dtmp = ldot * omega * np->rdiff * (1.0/PI); |
98 |
< |
scalecolor(ctmp, dtmp); |
99 |
< |
addcolor(cval, ctmp); |
98 |
> |
scalescolor(sctmp, dtmp); |
99 |
> |
saddscolor(scval, sctmp); |
100 |
|
} |
101 |
|
|
102 |
|
if ((ldot < -FTINY) & (np->tdiff > FTINY)) { |
103 |
|
/* |
104 |
|
* Compute diffuse transmission. |
105 |
|
*/ |
106 |
< |
copycolor(ctmp, np->mcolor); |
106 |
> |
copyscolor(sctmp, np->mcolor); |
107 |
|
dtmp = -ldot * omega * np->tdiff * (1.0/PI); |
108 |
< |
scalecolor(ctmp, dtmp); |
109 |
< |
addcolor(cval, ctmp); |
108 |
> |
scalescolor(sctmp, dtmp); |
109 |
> |
saddscolor(scval, sctmp); |
110 |
|
} |
111 |
– |
|
112 |
– |
/* PMAP: skip direct specular refl via ambient bounce if already |
113 |
– |
* accounted for in photon map */ |
114 |
– |
if (ambRayInPmap(np->rp)) |
115 |
– |
return; |
111 |
|
|
112 |
+ |
if (ambRayInPmap(np->rp)) |
113 |
+ |
return; /* specular accounted for in photon map */ |
114 |
+ |
|
115 |
|
if (ldot > FTINY && np->specfl&SP_REFL) { |
116 |
|
/* |
117 |
|
* Compute specular reflection coefficient using |
139 |
|
(PI * dtmp*dtmp * sqrt(au2*av2)); |
140 |
|
/* worth using? */ |
141 |
|
if (dtmp > FTINY) { |
142 |
< |
copycolor(ctmp, np->scolor); |
142 |
> |
copyscolor(sctmp, np->scolor); |
143 |
|
dtmp *= ldot * omega; |
144 |
< |
scalecolor(ctmp, dtmp); |
145 |
< |
addcolor(cval, ctmp); |
144 |
> |
scalescolor(sctmp, dtmp); |
145 |
> |
saddscolor(scval, sctmp); |
146 |
|
} |
147 |
|
} |
148 |
|
|
174 |
|
dtmp = exp(-dtmp) * (1.0/PI) * sqrt(-ldot/(np->pdot*au2*av2)); |
175 |
|
/* worth using? */ |
176 |
|
if (dtmp > FTINY) { |
177 |
< |
copycolor(ctmp, np->mcolor); |
177 |
> |
copyscolor(sctmp, np->mcolor); |
178 |
|
dtmp *= np->tspec * omega; |
179 |
< |
scalecolor(ctmp, dtmp); |
180 |
< |
addcolor(cval, ctmp); |
179 |
> |
scalescolor(sctmp, dtmp); |
180 |
> |
saddscolor(scval, sctmp); |
181 |
|
} |
182 |
|
} |
183 |
|
} |
190 |
|
) |
191 |
|
{ |
192 |
|
ANISODAT nd; |
193 |
< |
COLOR ctmp; |
193 |
> |
SCOLOR sctmp; |
194 |
|
int i; |
195 |
|
/* easy shadow test */ |
196 |
|
if (r->crtype & SHADOW) |
211 |
|
/* get material color */ |
212 |
|
nd.mp = m; |
213 |
|
nd.rp = r; |
214 |
< |
setcolor(nd.mcolor, m->oargs.farg[0], |
214 |
> |
setscolor(nd.mcolor, m->oargs.farg[0], |
215 |
|
m->oargs.farg[1], |
216 |
|
m->oargs.farg[2]); |
217 |
|
/* get roughness */ |
224 |
|
nd.pdot = raynormal(nd.pnorm, r); /* perturb normal */ |
225 |
|
if (nd.pdot < .001) |
226 |
|
nd.pdot = .001; /* non-zero for diraniso() */ |
227 |
< |
multcolor(nd.mcolor, r->pcol); /* modify material color */ |
227 |
> |
smultscolor(nd.mcolor, r->pcol); /* modify material color */ |
228 |
|
/* get specular component */ |
229 |
|
if ((nd.rspec = m->oargs.farg[3]) > FTINY) { |
230 |
|
nd.specfl |= SP_REFL; |
231 |
|
/* compute specular color */ |
232 |
|
if (m->otype == MAT_METAL2) |
233 |
< |
copycolor(nd.scolor, nd.mcolor); |
233 |
> |
copyscolor(nd.scolor, nd.mcolor); |
234 |
|
else |
235 |
< |
setcolor(nd.scolor, 1.0, 1.0, 1.0); |
236 |
< |
scalecolor(nd.scolor, nd.rspec); |
235 |
> |
setscolor(nd.scolor, 1.0, 1.0, 1.0); |
236 |
> |
scalescolor(nd.scolor, nd.rspec); |
237 |
|
/* check threshold */ |
238 |
|
if (specthresh >= nd.rspec-FTINY) |
239 |
|
nd.specfl |= SP_RBLT; |
274 |
|
|
275 |
|
getacoords(&nd); /* set up coordinates */ |
276 |
|
|
277 |
< |
/* PMAP: skip indirect specular via ambient bounce if already accounted |
280 |
< |
* for in photon map */ |
281 |
< |
if (!ambRayInPmap(r) && nd.specfl & (SP_REFL|SP_TRAN)) |
277 |
> |
if (nd.specfl & (SP_REFL|SP_TRAN)) |
278 |
|
agaussamp(&nd); |
279 |
|
|
280 |
|
if (nd.rdiff > FTINY) { /* ambient from this side */ |
281 |
< |
copycolor(ctmp, nd.mcolor); /* modified by material color */ |
282 |
< |
scalecolor(ctmp, nd.rdiff); |
281 |
> |
copyscolor(sctmp, nd.mcolor); /* modified by material color */ |
282 |
> |
scalescolor(sctmp, nd.rdiff); |
283 |
|
if (nd.specfl & SP_RBLT) /* add in specular as well? */ |
284 |
< |
addcolor(ctmp, nd.scolor); |
285 |
< |
multambient(ctmp, r, nd.pnorm); |
286 |
< |
addcolor(r->rcol, ctmp); /* add to returned color */ |
284 |
> |
saddscolor(sctmp, nd.scolor); |
285 |
> |
multambient(sctmp, r, nd.pnorm); |
286 |
> |
saddscolor(r->rcol, sctmp); /* add to returned color */ |
287 |
|
} |
288 |
|
|
289 |
|
if (nd.tdiff > FTINY) { /* ambient from other side */ |
290 |
|
FVECT bnorm; |
295 |
– |
|
296 |
– |
flipsurface(r); |
291 |
|
bnorm[0] = -nd.pnorm[0]; |
292 |
|
bnorm[1] = -nd.pnorm[1]; |
293 |
|
bnorm[2] = -nd.pnorm[2]; |
294 |
< |
copycolor(ctmp, nd.mcolor); /* modified by color */ |
295 |
< |
if (nd.specfl & SP_TBLT) |
296 |
< |
scalecolor(ctmp, nd.trans); |
297 |
< |
else |
298 |
< |
scalecolor(ctmp, nd.tdiff); |
299 |
< |
multambient(ctmp, r, bnorm); |
300 |
< |
addcolor(r->rcol, ctmp); |
301 |
< |
flipsurface(r); |
294 |
> |
copyscolor(sctmp, nd.mcolor); /* modified by color */ |
295 |
> |
if (nd.specfl & SP_TBLT) { |
296 |
> |
scalescolor(sctmp, nd.trans); |
297 |
> |
} else { |
298 |
> |
scalescolor(sctmp, nd.tdiff); |
299 |
> |
} |
300 |
> |
multambient(sctmp, r, bnorm); |
301 |
> |
saddscolor(r->rcol, sctmp); |
302 |
|
} |
303 |
|
/* add direct component */ |
304 |
|
direct(r, diraniso, &nd); |
327 |
|
if (normalize(np->v) == 0.0) { |
328 |
|
if (fabs(np->u_alpha - np->v_alpha) > 0.001) |
329 |
|
objerror(np->mp, WARNING, "illegal orientation vector"); |
330 |
< |
getperpendicular(np->u, np->pnorm); /* punting */ |
330 |
> |
getperpendicular(np->u, np->pnorm, 1); /* punting */ |
331 |
|
fcross(np->v, np->pnorm, np->u); |
332 |
|
np->u_alpha = np->v_alpha = sqrt( 0.5 * |
333 |
|
(np->u_alpha*np->u_alpha + np->v_alpha*np->v_alpha) ); |
345 |
|
FVECT h; |
346 |
|
double rv[2]; |
347 |
|
double d, sinp, cosp; |
348 |
< |
COLOR scol; |
348 |
> |
SCOLOR scol; |
349 |
|
int maxiter, ntrials, nstarget, nstaken; |
350 |
|
int i; |
351 |
|
/* compute reflection */ |
352 |
|
if ((np->specfl & (SP_REFL|SP_RBLT)) == SP_REFL && |
353 |
< |
rayorigin(&sr, SPECULAR, np->rp, np->scolor) == 0) { |
353 |
> |
rayorigin(&sr, RSPECULAR, np->rp, np->scolor) == 0) { |
354 |
|
nstarget = 1; |
355 |
|
if (specjitter > 1.5) { /* multiple samples? */ |
356 |
|
nstarget = specjitter*np->rp->rweight + .5; |
358 |
|
nstarget = sr.rweight/minweight; |
359 |
|
if (nstarget > 1) { |
360 |
|
d = 1./nstarget; |
361 |
< |
scalecolor(sr.rcoef, d); |
361 |
> |
scalescolor(sr.rcoef, d); |
362 |
|
sr.rweight *= d; |
363 |
|
} else |
364 |
|
nstarget = 1; |
365 |
|
} |
366 |
< |
setcolor(scol, 0., 0., 0.); |
366 |
> |
scolorblack(scol); |
367 |
|
dimlist[ndims++] = (int)(size_t)np->mp; |
368 |
|
maxiter = MAXITER*nstarget; |
369 |
|
for (nstaken = ntrials = 0; nstaken < nstarget && |
400 |
|
if (nstaken) rayclear(&sr); |
401 |
|
rayvalue(&sr); |
402 |
|
d = 2./(1. + np->rp->rod/d); |
403 |
< |
scalecolor(sr.rcol, d); |
404 |
< |
addcolor(scol, sr.rcol); |
403 |
> |
scalescolor(sr.rcol, d); |
404 |
> |
saddscolor(scol, sr.rcol); |
405 |
|
} else { |
406 |
|
rayvalue(&sr); |
407 |
< |
multcolor(sr.rcol, sr.rcoef); |
408 |
< |
addcolor(np->rp->rcol, sr.rcol); |
407 |
> |
smultscolor(sr.rcol, sr.rcoef); |
408 |
> |
saddscolor(np->rp->rcol, sr.rcol); |
409 |
|
} |
410 |
|
++nstaken; |
411 |
|
} |
412 |
|
if (nstarget > 1) { /* final W-G-M-D weighting */ |
413 |
< |
multcolor(scol, sr.rcoef); |
413 |
> |
smultscolor(scol, sr.rcoef); |
414 |
|
d = (double)nstarget/ntrials; |
415 |
< |
scalecolor(scol, d); |
416 |
< |
addcolor(np->rp->rcol, scol); |
415 |
> |
scalescolor(scol, d); |
416 |
> |
saddscolor(np->rp->rcol, scol); |
417 |
|
} |
418 |
|
ndims--; |
419 |
|
} |
420 |
|
/* compute transmission */ |
421 |
< |
copycolor(sr.rcoef, np->mcolor); /* modify by material color */ |
422 |
< |
scalecolor(sr.rcoef, np->tspec); |
421 |
> |
copyscolor(sr.rcoef, np->mcolor); /* modify by material color */ |
422 |
> |
scalescolor(sr.rcoef, np->tspec); |
423 |
|
if ((np->specfl & (SP_TRAN|SP_TBLT)) == SP_TRAN && |
424 |
< |
rayorigin(&sr, SPECULAR, np->rp, sr.rcoef) == 0) { |
424 |
> |
rayorigin(&sr, TSPECULAR, np->rp, sr.rcoef) == 0) { |
425 |
|
nstarget = 1; |
426 |
|
if (specjitter > 1.5) { /* multiple samples? */ |
427 |
|
nstarget = specjitter*np->rp->rweight + .5; |
429 |
|
nstarget = sr.rweight/minweight; |
430 |
|
if (nstarget > 1) { |
431 |
|
d = 1./nstarget; |
432 |
< |
scalecolor(sr.rcoef, d); |
432 |
> |
scalescolor(sr.rcoef, d); |
433 |
|
sr.rweight *= d; |
434 |
|
} else |
435 |
|
nstarget = 1; |
466 |
|
if (nstaken) /* multi-sampling */ |
467 |
|
rayclear(&sr); |
468 |
|
rayvalue(&sr); |
469 |
< |
multcolor(sr.rcol, sr.rcoef); |
470 |
< |
addcolor(np->rp->rcol, sr.rcol); |
469 |
> |
smultscolor(sr.rcol, sr.rcoef); |
470 |
> |
saddscolor(np->rp->rcol, sr.rcol); |
471 |
|
++nstaken; |
472 |
|
} |
473 |
|
ndims--; |