ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/normal.c
Revision: 2.64
Committed: Mon Jul 30 17:46:50 2012 UTC (11 years, 9 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.63: +2 -2 lines
Log Message:
Fixed bug in Fresnel approximation for metals

File Contents

# Content
1 #ifndef lint
2 static const char RCSid[] = "$Id: normal.c,v 2.63 2012/07/29 21:56:16 greg Exp $";
3 #endif
4 /*
5 * normal.c - shading function for normal materials.
6 *
7 * 8/19/85
8 * 12/19/85 - added stuff for metals.
9 * 6/26/87 - improved specular model.
10 * 9/28/87 - added model for translucent materials.
11 * Later changes described in delta comments.
12 */
13
14 #include "copyright.h"
15
16 #include "ray.h"
17 #include "ambient.h"
18 #include "source.h"
19 #include "otypes.h"
20 #include "rtotypes.h"
21 #include "random.h"
22
23 #ifndef MAXITER
24 #define MAXITER 10 /* maximum # specular ray attempts */
25 #endif
26 /* estimate of Fresnel function */
27 #define FRESNE(ci) (exp(-5.85*(ci)) - 0.00287989916)
28 #define FRESTHRESH 0.017999 /* minimum specularity for approx. */
29
30
31 /*
32 * This routine implements the isotropic Gaussian
33 * model described by Ward in Siggraph `92 article.
34 * We orient the surface towards the incoming ray, so a single
35 * surface can be used to represent an infinitely thin object.
36 *
37 * Arguments for MAT_PLASTIC and MAT_METAL are:
38 * red grn blu specular-frac. facet-slope
39 *
40 * Arguments for MAT_TRANS are:
41 * red grn blu rspec rough trans tspec
42 */
43
44 /* specularity flags */
45 #define SP_REFL 01 /* has reflected specular component */
46 #define SP_TRAN 02 /* has transmitted specular */
47 #define SP_PURE 04 /* purely specular (zero roughness) */
48 #define SP_FLAT 010 /* flat reflecting surface */
49 #define SP_RBLT 020 /* reflection below sample threshold */
50 #define SP_TBLT 040 /* transmission below threshold */
51
52 typedef struct {
53 OBJREC *mp; /* material pointer */
54 RAY *rp; /* ray pointer */
55 short specfl; /* specularity flags, defined above */
56 COLOR mcolor; /* color of this material */
57 COLOR scolor; /* color of specular component */
58 FVECT vrefl; /* vector in direction of reflected ray */
59 FVECT prdir; /* vector in transmitted direction */
60 double alpha2; /* roughness squared */
61 double rdiff, rspec; /* reflected specular, diffuse */
62 double trans; /* transmissivity */
63 double tdiff, tspec; /* transmitted specular, diffuse */
64 FVECT pnorm; /* perturbed surface normal */
65 double pdot; /* perturbed dot product */
66 } NORMDAT; /* normal material data */
67
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 */
75 FVECT ldir, /* light source direction */
76 double omega /* light source size */
77 )
78 {
79 NORMDAT *np = nnp;
80 double ldot;
81 double lrdiff, ltdiff;
82 double dtmp, d2, d3, d4;
83 FVECT vtmp;
84 COLOR ctmp;
85
86 setcolor(cval, 0.0, 0.0, 0.0);
87
88 ldot = DOT(np->pnorm, ldir);
89
90 if (ldot < 0.0 ? np->trans <= FTINY : np->trans >= 1.0-FTINY)
91 return; /* wrong side */
92
93 /* Fresnel estimate */
94 lrdiff = np->rdiff;
95 ltdiff = np->tdiff;
96 if (np->specfl & SP_PURE && np->rspec >= FRESTHRESH &&
97 (lrdiff > FTINY) | (ltdiff > FTINY)) {
98 dtmp = 1. - FRESNE(fabs(ldot));
99 lrdiff *= dtmp;
100 ltdiff *= dtmp;
101 }
102
103 if (ldot > FTINY && lrdiff > FTINY) {
104 /*
105 * Compute and add diffuse reflected component to returned
106 * color. The diffuse reflected component will always be
107 * modified by the color of the material.
108 */
109 copycolor(ctmp, np->mcolor);
110 dtmp = ldot * omega * lrdiff * (1.0/PI);
111 scalecolor(ctmp, dtmp);
112 addcolor(cval, ctmp);
113 }
114 if (ldot > FTINY && (np->specfl&(SP_REFL|SP_PURE)) == SP_REFL) {
115 /*
116 * Compute specular reflection coefficient using
117 * Gaussian distribution model.
118 */
119 /* roughness */
120 dtmp = np->alpha2;
121 /* + source if flat */
122 if (np->specfl & SP_FLAT)
123 dtmp += omega * (0.25/PI);
124 /* half vector */
125 VSUB(vtmp, ldir, np->rp->rdir);
126 d2 = DOT(vtmp, np->pnorm);
127 d2 *= d2;
128 d3 = DOT(vtmp,vtmp);
129 d4 = (d3 - d2) / d2;
130 /* new W-G-M-D model */
131 dtmp = exp(-d4/dtmp) * d3 / (PI * d2*d2 * dtmp);
132 /* worth using? */
133 if (dtmp > FTINY) {
134 copycolor(ctmp, np->scolor);
135 dtmp *= ldot * omega;
136 scalecolor(ctmp, dtmp);
137 addcolor(cval, ctmp);
138 }
139 }
140 if (ldot < -FTINY && ltdiff > FTINY) {
141 /*
142 * Compute diffuse transmission.
143 */
144 copycolor(ctmp, np->mcolor);
145 dtmp = -ldot * omega * ltdiff * (1.0/PI);
146 scalecolor(ctmp, dtmp);
147 addcolor(cval, ctmp);
148 }
149 if (ldot < -FTINY && (np->specfl&(SP_TRAN|SP_PURE)) == SP_TRAN) {
150 /*
151 * Compute specular transmission. Specular transmission
152 * is always modified by material color.
153 */
154 /* roughness + source */
155 dtmp = np->alpha2 + omega*(1.0/PI);
156 /* Gaussian */
157 dtmp = exp((2.*DOT(np->prdir,ldir)-2.)/dtmp)/(PI*dtmp);
158 /* worth using? */
159 if (dtmp > FTINY) {
160 copycolor(ctmp, np->mcolor);
161 dtmp *= np->tspec * omega * sqrt(-ldot/np->pdot);
162 scalecolor(ctmp, dtmp);
163 addcolor(cval, ctmp);
164 }
165 }
166 }
167
168
169 int
170 m_normal( /* color a ray that hit something normal */
171 OBJREC *m,
172 RAY *r
173 )
174 {
175 NORMDAT nd;
176 double fest;
177 double transtest, transdist;
178 double mirtest, mirdist;
179 int hastexture;
180 double d;
181 COLOR ctmp;
182 int i;
183 /* easy shadow test */
184 if (r->crtype & SHADOW && m->otype != MAT_TRANS)
185 return(1);
186
187 if (m->oargs.nfargs != (m->otype == MAT_TRANS ? 7 : 5))
188 objerror(m, USER, "bad number of arguments");
189 /* check for back side */
190 if (r->rod < 0.0) {
191 if (!backvis && m->otype != MAT_TRANS) {
192 raytrans(r);
193 return(1);
194 }
195 raytexture(r, m->omod);
196 flipsurface(r); /* reorient if backvis */
197 } else
198 raytexture(r, m->omod);
199 nd.mp = m;
200 nd.rp = r;
201 /* get material color */
202 setcolor(nd.mcolor, m->oargs.farg[0],
203 m->oargs.farg[1],
204 m->oargs.farg[2]);
205 /* get roughness */
206 nd.specfl = 0;
207 nd.alpha2 = m->oargs.farg[4];
208 if ((nd.alpha2 *= nd.alpha2) <= FTINY)
209 nd.specfl |= SP_PURE;
210
211 if ( (hastexture = (DOT(r->pert,r->pert) > FTINY*FTINY)) ) {
212 nd.pdot = raynormal(nd.pnorm, r); /* perturb normal */
213 } else {
214 VCOPY(nd.pnorm, r->ron);
215 nd.pdot = r->rod;
216 }
217 if (r->ro != NULL && isflat(r->ro->otype))
218 nd.specfl |= SP_FLAT;
219 if (nd.pdot < .001)
220 nd.pdot = .001; /* non-zero for dirnorm() */
221 multcolor(nd.mcolor, r->pcol); /* modify material color */
222 mirtest = transtest = 0;
223 mirdist = transdist = r->rot;
224 nd.rspec = m->oargs.farg[3];
225 /* compute Fresnel approx. */
226 if (nd.specfl & SP_PURE && nd.rspec >= FRESTHRESH) {
227 fest = FRESNE(nd.pdot);
228 nd.rspec += fest*(1. - nd.rspec);
229 } else
230 fest = 0.;
231 /* compute transmission */
232 if (m->otype == MAT_TRANS) {
233 nd.trans = m->oargs.farg[5]*(1.0 - nd.rspec);
234 nd.tspec = nd.trans * m->oargs.farg[6];
235 nd.tdiff = nd.trans - nd.tspec;
236 if (nd.tspec > FTINY) {
237 nd.specfl |= SP_TRAN;
238 /* check threshold */
239 if (!(nd.specfl & SP_PURE) &&
240 specthresh >= nd.tspec-FTINY)
241 nd.specfl |= SP_TBLT;
242 if (!hastexture || r->crtype & SHADOW) {
243 VCOPY(nd.prdir, r->rdir);
244 transtest = 2;
245 } else {
246 for (i = 0; i < 3; i++) /* perturb */
247 nd.prdir[i] = r->rdir[i] - r->pert[i];
248 if (DOT(nd.prdir, r->ron) < -FTINY)
249 normalize(nd.prdir); /* OK */
250 else
251 VCOPY(nd.prdir, r->rdir);
252 }
253 }
254 } else
255 nd.tdiff = nd.tspec = nd.trans = 0.0;
256 /* transmitted ray */
257 if ((nd.specfl&(SP_TRAN|SP_PURE|SP_TBLT)) == (SP_TRAN|SP_PURE)) {
258 RAY lr;
259 copycolor(lr.rcoef, nd.mcolor); /* modified by color */
260 scalecolor(lr.rcoef, nd.tspec);
261 if (rayorigin(&lr, TRANS, r, lr.rcoef) == 0) {
262 VCOPY(lr.rdir, nd.prdir);
263 rayvalue(&lr);
264 multcolor(lr.rcol, lr.rcoef);
265 addcolor(r->rcol, lr.rcol);
266 transtest *= bright(lr.rcol);
267 transdist = r->rot + lr.rt;
268 }
269 } else
270 transtest = 0;
271
272 if (r->crtype & SHADOW) { /* the rest is shadow */
273 r->rt = transdist;
274 return(1);
275 }
276 /* get specular reflection */
277 if (nd.rspec > FTINY) {
278 nd.specfl |= SP_REFL;
279 /* compute specular color */
280 if (m->otype != MAT_METAL) {
281 setcolor(nd.scolor, nd.rspec, nd.rspec, nd.rspec);
282 } else if (fest > FTINY) {
283 d = m->oargs.farg[3]*(1. - fest);
284 for (i = 0; i < 3; i++)
285 nd.scolor[i] = fest + nd.mcolor[i]*d;
286 } else {
287 copycolor(nd.scolor, nd.mcolor);
288 scalecolor(nd.scolor, nd.rspec);
289 }
290 /* check threshold */
291 if (!(nd.specfl & SP_PURE) && specthresh >= nd.rspec-FTINY)
292 nd.specfl |= SP_RBLT;
293 /* compute reflected ray */
294 VSUM(nd.vrefl, r->rdir, nd.pnorm, 2.*nd.pdot);
295 /* penetration? */
296 if (hastexture && DOT(nd.vrefl, r->ron) <= FTINY)
297 VSUM(nd.vrefl, r->rdir, r->ron, 2.*r->rod);
298 checknorm(nd.vrefl);
299 }
300 /* reflected ray */
301 if ((nd.specfl&(SP_REFL|SP_PURE|SP_RBLT)) == (SP_REFL|SP_PURE)) {
302 RAY lr;
303 if (rayorigin(&lr, REFLECTED, r, nd.scolor) == 0) {
304 VCOPY(lr.rdir, nd.vrefl);
305 rayvalue(&lr);
306 multcolor(lr.rcol, lr.rcoef);
307 addcolor(r->rcol, lr.rcol);
308 if (!hastexture && nd.specfl & SP_FLAT) {
309 mirtest = 2.*bright(lr.rcol);
310 mirdist = r->rot + lr.rt;
311 }
312 }
313 }
314 /* diffuse reflection */
315 nd.rdiff = 1.0 - nd.trans - nd.rspec;
316
317 if (nd.specfl & SP_PURE && nd.rdiff <= FTINY && nd.tdiff <= FTINY)
318 return(1); /* 100% pure specular */
319
320 if (!(nd.specfl & SP_PURE))
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 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 }
331 if (nd.tdiff > FTINY) { /* ambient from other side */
332 copycolor(ctmp, nd.mcolor); /* modified by color */
333 if (nd.specfl & SP_TBLT)
334 scalecolor(ctmp, nd.trans);
335 else
336 scalecolor(ctmp, nd.tdiff);
337 flipsurface(r);
338 if (hastexture) {
339 FVECT bnorm;
340 bnorm[0] = -nd.pnorm[0];
341 bnorm[1] = -nd.pnorm[1];
342 bnorm[2] = -nd.pnorm[2];
343 multambient(ctmp, r, bnorm);
344 } else
345 multambient(ctmp, r, r->ron);
346 addcolor(r->rcol, ctmp);
347 flipsurface(r);
348 }
349 /* add direct component */
350 direct(r, dirnorm, &nd);
351 /* check distance */
352 d = bright(r->rcol);
353 if (transtest > d)
354 r->rt = transdist;
355 else if (mirtest > d)
356 r->rt = mirdist;
357
358 return(1);
359 }
360
361
362 static void
363 gaussamp( /* sample Gaussian specular */
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;
372 int maxiter, ntrials, nstarget, nstaken;
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)
377 return;
378 /* set up sample coordinates */
379 v[0] = v[1] = v[2] = 0.0;
380 for (i = 0; i < 3; i++)
381 if (np->pnorm[i] < 0.6 && np->pnorm[i] > -0.6)
382 break;
383 v[i] = 1.0;
384 fcross(u, v, np->pnorm);
385 normalize(u);
386 fcross(v, np->pnorm, u);
387 /* compute reflection */
388 if ((np->specfl & (SP_REFL|SP_RBLT)) == SP_REFL &&
389 rayorigin(&sr, SPECULAR, np->rp, np->scolor) == 0) {
390 nstarget = 1;
391 if (specjitter > 1.5) { /* multiple samples? */
392 nstarget = specjitter*np->rp->rweight + .5;
393 if (sr.rweight <= minweight*nstarget)
394 nstarget = sr.rweight/minweight;
395 if (nstarget > 1) {
396 d = 1./nstarget;
397 scalecolor(sr.rcoef, d);
398 sr.rweight *= d;
399 } else
400 nstarget = 1;
401 }
402 setcolor(scol, 0., 0., 0.);
403 dimlist[ndims++] = (int)(size_t)np->mp;
404 maxiter = MAXITER*nstarget;
405 for (nstaken = ntrials = 0; nstaken < nstarget &&
406 ntrials < maxiter; ntrials++) {
407 if (ntrials)
408 d = frandom();
409 else
410 d = urand(ilhash(dimlist,ndims)+samplendx);
411 multisamp(rv, 2, d);
412 d = 2.0*PI * rv[0];
413 cosp = tcos(d);
414 sinp = tsin(d);
415 if ((0. <= specjitter) & (specjitter < 1.))
416 rv[1] = 1.0 - specjitter*rv[1];
417 if (rv[1] <= FTINY)
418 d = 1.0;
419 else
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, 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, 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. + 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(np->rp->rcol, sr.rcol);
439 }
440 ++nstaken;
441 }
442 if (nstarget > 1) { /* final W-G-M-D weighting */
443 multcolor(scol, sr.rcoef);
444 d = (double)nstarget/ntrials;
445 scalecolor(scol, d);
446 addcolor(np->rp->rcol, scol);
447 }
448 ndims--;
449 }
450 /* compute transmission */
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, np->rp, sr.rcoef) == 0) {
455 nstarget = 1;
456 if (specjitter > 1.5) { /* multiple samples? */
457 nstarget = specjitter*np->rp->rweight + .5;
458 if (sr.rweight <= minweight*nstarget)
459 nstarget = sr.rweight/minweight;
460 if (nstarget > 1) {
461 d = 1./nstarget;
462 scalecolor(sr.rcoef, d);
463 sr.rweight *= d;
464 } else
465 nstarget = 1;
466 }
467 dimlist[ndims++] = (int)(size_t)np->mp;
468 maxiter = MAXITER*nstarget;
469 for (nstaken = ntrials = 0; nstaken < nstarget &&
470 ntrials < maxiter; ntrials++) {
471 if (ntrials)
472 d = frandom();
473 else
474 d = urand(ilhash(dimlist,ndims)+samplendx);
475 multisamp(rv, 2, d);
476 d = 2.0*PI * rv[0];
477 cosp = tcos(d);
478 sinp = tsin(d);
479 if ((0. <= specjitter) & (specjitter < 1.))
480 rv[1] = 1.0 - specjitter*rv[1];
481 if (rv[1] <= FTINY)
482 d = 1.0;
483 else
484 d = sqrt( np->alpha2 * -log(rv[1]) );
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, 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(np->rp->rcol, sr.rcol);
496 ++nstaken;
497 }
498 ndims--;
499 }
500 }