65 |
|
double pdot; /* perturbed dot product */ |
66 |
|
} NORMDAT; /* normal material data */ |
67 |
|
|
68 |
< |
static srcdirf_t dirnorm; |
69 |
< |
static void gaussamp(RAY *r, NORMDAT *np); |
68 |
> |
static void gaussamp(NORMDAT *np); |
69 |
|
|
70 |
|
|
71 |
|
static void |
72 |
|
dirnorm( /* compute source contribution */ |
73 |
|
COLOR cval, /* returned coefficient */ |
74 |
< |
void *nnp, /* material data */ |
74 |
> |
void *nnp, /* material data */ |
75 |
|
FVECT ldir, /* light source direction */ |
76 |
|
double omega /* light source size */ |
77 |
|
) |
78 |
|
{ |
79 |
< |
register NORMDAT *np = nnp; |
79 |
> |
NORMDAT *np = nnp; |
80 |
|
double ldot; |
81 |
|
double lrdiff, ltdiff; |
82 |
|
double dtmp, d2, d3, d4; |
122 |
|
if (np->specfl & SP_FLAT) |
123 |
|
dtmp += omega * (0.25/PI); |
124 |
|
/* half vector */ |
125 |
< |
vtmp[0] = ldir[0] - np->rp->rdir[0]; |
127 |
< |
vtmp[1] = ldir[1] - np->rp->rdir[1]; |
128 |
< |
vtmp[2] = ldir[2] - np->rp->rdir[2]; |
125 |
> |
VSUB(vtmp, ldir, np->rp->rdir); |
126 |
|
d2 = DOT(vtmp, np->pnorm); |
127 |
|
d2 *= d2; |
128 |
|
d3 = DOT(vtmp,vtmp); |
166 |
|
} |
167 |
|
|
168 |
|
|
169 |
< |
extern int |
169 |
> |
int |
170 |
|
m_normal( /* color a ray that hit something normal */ |
171 |
< |
register OBJREC *m, |
172 |
< |
register RAY *r |
171 |
> |
OBJREC *m, |
172 |
> |
RAY *r |
173 |
|
) |
174 |
|
{ |
175 |
|
NORMDAT nd; |
179 |
|
int hastexture; |
180 |
|
double d; |
181 |
|
COLOR ctmp; |
182 |
< |
register int i; |
182 |
> |
int i; |
183 |
|
/* easy shadow test */ |
184 |
|
if (r->crtype & SHADOW && m->otype != MAT_TRANS) |
185 |
|
return(1); |
224 |
|
nd.rspec = m->oargs.farg[3]; |
225 |
|
/* compute Fresnel approx. */ |
226 |
|
if (nd.specfl & SP_PURE && nd.rspec >= FRESTHRESH) { |
227 |
< |
fest = FRESNE(r->rod); |
227 |
> |
fest = FRESNE(nd.pdot); |
228 |
|
nd.rspec += fest*(1. - nd.rspec); |
229 |
|
} else |
230 |
|
fest = 0.; |
318 |
|
return(1); /* 100% pure specular */ |
319 |
|
|
320 |
|
if (!(nd.specfl & SP_PURE)) |
321 |
< |
gaussamp(r, &nd); /* checks *BLT flags */ |
321 |
> |
gaussamp(&nd); /* checks *BLT flags */ |
322 |
|
|
323 |
|
if (nd.rdiff > FTINY) { /* ambient from this side */ |
324 |
|
copycolor(ctmp, nd.mcolor); /* modified by material color */ |
325 |
< |
if (nd.specfl & SP_RBLT) |
326 |
< |
scalecolor(ctmp, 1.0-nd.trans); |
327 |
< |
else |
331 |
< |
scalecolor(ctmp, nd.rdiff); |
325 |
> |
scalecolor(ctmp, nd.rdiff); |
326 |
> |
if (nd.specfl & SP_RBLT) /* add in specular as well? */ |
327 |
> |
addcolor(ctmp, nd.scolor); |
328 |
|
multambient(ctmp, r, hastexture ? nd.pnorm : r->ron); |
329 |
|
addcolor(r->rcol, ctmp); /* add to returned color */ |
330 |
|
} |
361 |
|
|
362 |
|
static void |
363 |
|
gaussamp( /* sample Gaussian specular */ |
364 |
< |
RAY *r, |
369 |
< |
register NORMDAT *np |
364 |
> |
NORMDAT *np |
365 |
|
) |
366 |
|
{ |
367 |
|
RAY sr; |
368 |
|
FVECT u, v, h; |
369 |
|
double rv[2]; |
370 |
|
double d, sinp, cosp; |
371 |
< |
COLOR scol; |
371 |
> |
COLOR scol; |
372 |
|
int maxiter, ntrials, nstarget, nstaken; |
373 |
< |
register int i; |
373 |
> |
int i; |
374 |
|
/* quick test */ |
375 |
|
if ((np->specfl & (SP_REFL|SP_RBLT)) != SP_REFL && |
376 |
|
(np->specfl & (SP_TRAN|SP_TBLT)) != SP_TRAN) |
386 |
|
fcross(v, np->pnorm, u); |
387 |
|
/* compute reflection */ |
388 |
|
if ((np->specfl & (SP_REFL|SP_RBLT)) == SP_REFL && |
389 |
< |
rayorigin(&sr, SPECULAR, r, np->scolor) == 0) { |
389 |
> |
rayorigin(&sr, SPECULAR, np->rp, np->scolor) == 0) { |
390 |
|
nstarget = 1; |
391 |
|
if (specjitter > 1.5) { /* multiple samples? */ |
392 |
< |
nstarget = specjitter*r->rweight + .5; |
392 |
> |
nstarget = specjitter*np->rp->rweight + .5; |
393 |
|
if (sr.rweight <= minweight*nstarget) |
394 |
|
nstarget = sr.rweight/minweight; |
395 |
|
if (nstarget > 1) { |
400 |
|
nstarget = 1; |
401 |
|
} |
402 |
|
setcolor(scol, 0., 0., 0.); |
403 |
< |
dimlist[ndims++] = (int)np->mp; |
403 |
> |
dimlist[ndims++] = (int)(size_t)np->mp; |
404 |
|
maxiter = MAXITER*nstarget; |
405 |
|
for (nstaken = ntrials = 0; nstaken < nstarget && |
406 |
|
ntrials < maxiter; ntrials++) { |
420 |
|
d = sqrt( np->alpha2 * -log(rv[1]) ); |
421 |
|
for (i = 0; i < 3; i++) |
422 |
|
h[i] = np->pnorm[i] + d*(cosp*u[i] + sinp*v[i]); |
423 |
< |
d = -2.0 * DOT(h, r->rdir) / (1.0 + d*d); |
424 |
< |
VSUM(sr.rdir, r->rdir, h, d); |
423 |
> |
d = -2.0 * DOT(h, np->rp->rdir) / (1.0 + d*d); |
424 |
> |
VSUM(sr.rdir, np->rp->rdir, h, d); |
425 |
|
/* sample rejection test */ |
426 |
< |
if ((d = DOT(sr.rdir, r->ron)) <= FTINY) |
426 |
> |
if ((d = DOT(sr.rdir, np->rp->ron)) <= FTINY) |
427 |
|
continue; |
428 |
|
checknorm(sr.rdir); |
429 |
|
if (nstarget > 1) { /* W-G-M-D adjustment */ |
430 |
|
if (nstaken) rayclear(&sr); |
431 |
|
rayvalue(&sr); |
432 |
< |
d = 2./(1. + r->rod/d); |
432 |
> |
d = 2./(1. + np->rp->rod/d); |
433 |
|
scalecolor(sr.rcol, d); |
434 |
|
addcolor(scol, sr.rcol); |
435 |
|
} else { |
436 |
|
rayvalue(&sr); |
437 |
|
multcolor(sr.rcol, sr.rcoef); |
438 |
< |
addcolor(r->rcol, sr.rcol); |
438 |
> |
addcolor(np->rp->rcol, sr.rcol); |
439 |
|
} |
440 |
|
++nstaken; |
441 |
|
} |
443 |
|
multcolor(scol, sr.rcoef); |
444 |
|
d = (double)nstarget/ntrials; |
445 |
|
scalecolor(scol, d); |
446 |
< |
addcolor(r->rcol, scol); |
446 |
> |
addcolor(np->rp->rcol, scol); |
447 |
|
} |
448 |
|
ndims--; |
449 |
|
} |
451 |
|
copycolor(sr.rcoef, np->mcolor); /* modified by color */ |
452 |
|
scalecolor(sr.rcoef, np->tspec); |
453 |
|
if ((np->specfl & (SP_TRAN|SP_TBLT)) == SP_TRAN && |
454 |
< |
rayorigin(&sr, SPECULAR, r, sr.rcoef) == 0) { |
454 |
> |
rayorigin(&sr, SPECULAR, np->rp, sr.rcoef) == 0) { |
455 |
|
nstarget = 1; |
456 |
|
if (specjitter > 1.5) { /* multiple samples? */ |
457 |
< |
nstarget = specjitter*r->rweight + .5; |
457 |
> |
nstarget = specjitter*np->rp->rweight + .5; |
458 |
|
if (sr.rweight <= minweight*nstarget) |
459 |
|
nstarget = sr.rweight/minweight; |
460 |
|
if (nstarget > 1) { |
464 |
|
} else |
465 |
|
nstarget = 1; |
466 |
|
} |
467 |
< |
dimlist[ndims++] = (int)np->mp; |
467 |
> |
dimlist[ndims++] = (int)(size_t)np->mp; |
468 |
|
maxiter = MAXITER*nstarget; |
469 |
|
for (nstaken = ntrials = 0; nstaken < nstarget && |
470 |
|
ntrials < maxiter; ntrials++) { |
485 |
|
for (i = 0; i < 3; i++) |
486 |
|
sr.rdir[i] = np->prdir[i] + d*(cosp*u[i] + sinp*v[i]); |
487 |
|
/* sample rejection test */ |
488 |
< |
if (DOT(sr.rdir, r->ron) >= -FTINY) |
488 |
> |
if (DOT(sr.rdir, np->rp->ron) >= -FTINY) |
489 |
|
continue; |
490 |
|
normalize(sr.rdir); /* OK, normalize */ |
491 |
|
if (nstaken) /* multi-sampling */ |
492 |
|
rayclear(&sr); |
493 |
|
rayvalue(&sr); |
494 |
|
multcolor(sr.rcol, sr.rcoef); |
495 |
< |
addcolor(r->rcol, sr.rcol); |
495 |
> |
addcolor(np->rp->rcol, sr.rcol); |
496 |
|
++nstaken; |
497 |
|
} |
498 |
|
ndims--; |