ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/normal.c
(Generate patch)

Comparing ray/src/rt/normal.c (file contents):
Revision 2.73 by greg, Wed Oct 28 15:45:58 2015 UTC vs.
Revision 2.84 by greg, Fri Apr 5 01:10:26 2024 UTC

# Line 25 | Line 25 | static const char RCSid[] = "$Id$";
25   #define  MAXITER        10              /* maximum # specular ray attempts */
26   #endif
27                                          /* estimate of Fresnel function */
28 < #define  FRESNE(ci)     (exp(-5.85*(ci)) - 0.00287989916)
28 > #define  FRESNE(ci)     (exp(-5.85*(ci)) - 0.00202943064)
29   #define  FRESTHRESH     0.017999        /* minimum specularity for approx. */
30  
31  
# Line 54 | Line 54 | typedef struct {
54          OBJREC  *mp;            /* material pointer */
55          RAY  *rp;               /* ray pointer */
56          short  specfl;          /* specularity flags, defined above */
57 <        COLOR  mcolor;          /* color of this material */
58 <        COLOR  scolor;          /* color of specular component */
57 >        SCOLOR  mcolor;         /* color of this material */
58 >        SCOLOR  scolor;         /* color of specular component */
59          FVECT  vrefl;           /* vector in direction of reflected ray */
60          FVECT  prdir;           /* vector in transmitted direction */
61          double  alpha2;         /* roughness squared */
# Line 71 | Line 71 | static void gaussamp(NORMDAT  *np);
71  
72   static void
73   dirnorm(                /* compute source contribution */
74 <        COLOR  cval,                    /* returned coefficient */
74 >        SCOLOR  scval,                  /* returned coefficient */
75          void  *nnp,                     /* material data */
76          FVECT  ldir,                    /* light source direction */
77          double  omega                   /* light source size */
# Line 82 | Line 82 | dirnorm(               /* compute source contribution */
82          double  lrdiff, ltdiff;
83          double  dtmp, d2, d3, d4;
84          FVECT  vtmp;
85 <        COLOR  ctmp;
85 >        SCOLOR  sctmp;
86  
87 <        setcolor(cval, 0.0, 0.0, 0.0);
87 >        scolorblack(scval);
88  
89          ldot = DOT(np->pnorm, ldir);
90  
# Line 101 | Line 101 | dirnorm(               /* compute source contribution */
101                  ltdiff *= dtmp;
102          }
103  
104 <        if (ldot > FTINY && lrdiff > FTINY) {
104 >        if ((ldot > FTINY) & (lrdiff > FTINY)) {
105                  /*
106                   *  Compute and add diffuse reflected component to returned
107                   *  color.  The diffuse reflected component will always be
108                   *  modified by the color of the material.
109                   */
110 <                copycolor(ctmp, np->mcolor);
110 >                copyscolor(sctmp, np->mcolor);
111                  dtmp = ldot * omega * lrdiff * (1.0/PI);
112 <                scalecolor(ctmp, dtmp);
113 <                addcolor(cval, ctmp);
112 >                scalescolor(sctmp, dtmp);
113 >                saddscolor(scval, sctmp);
114          }
115  
116 <        if (ldot < -FTINY && ltdiff > FTINY) {
116 >        if ((ldot < -FTINY) & (ltdiff > FTINY)) {
117                  /*
118                   *  Compute diffuse transmission.
119                   */
120 <                copycolor(ctmp, np->mcolor);
120 >                copyscolor(sctmp, np->mcolor);
121                  dtmp = -ldot * omega * ltdiff * (1.0/PI);
122 <                scalecolor(ctmp, dtmp);
123 <                addcolor(cval, ctmp);
122 >                scalescolor(sctmp, dtmp);
123 >                saddscolor(scval, sctmp);
124          }
125  
126          if (ambRayInPmap(np->rp))
127                  return;         /* specular already in photon map */
128  
129 <        if (ldot > FTINY && (np->specfl&(SP_REFL|SP_PURE)) == SP_REFL) {
129 >        if ((ldot > FTINY) & ((np->specfl&(SP_REFL|SP_PURE)) == SP_REFL)) {
130                  /*
131                   *  Compute specular reflection coefficient using
132                   *  Gaussian distribution model.
# Line 146 | Line 146 | dirnorm(               /* compute source contribution */
146                  dtmp = exp(-d4/dtmp) * d3 / (PI * d2*d2 * dtmp);
147                                                  /* worth using? */
148                  if (dtmp > FTINY) {
149 <                        copycolor(ctmp, np->scolor);
149 >                        copyscolor(sctmp, np->scolor);
150                          dtmp *= ldot * omega;
151 <                        scalecolor(ctmp, dtmp);
152 <                        addcolor(cval, ctmp);
151 >                        scalescolor(sctmp, dtmp);
152 >                        saddscolor(scval, sctmp);
153                  }
154          }
155          
156  
157 <        if (ldot < -FTINY && (np->specfl&(SP_TRAN|SP_PURE)) == SP_TRAN) {
157 >        if ((ldot < -FTINY) & ((np->specfl&(SP_TRAN|SP_PURE)) == SP_TRAN)) {
158                  /*
159                   *  Compute specular transmission.  Specular transmission
160                   *  is always modified by material color.
# Line 165 | Line 165 | dirnorm(               /* compute source contribution */
165                  dtmp = exp((2.*DOT(np->prdir,ldir)-2.)/dtmp)/(PI*dtmp);
166                                                  /* worth using? */
167                  if (dtmp > FTINY) {
168 <                        copycolor(ctmp, np->mcolor);
168 >                        copyscolor(sctmp, np->mcolor);
169                          dtmp *= np->tspec * omega * sqrt(-ldot/np->pdot);
170 <                        scalecolor(ctmp, dtmp);
171 <                        addcolor(cval, ctmp);
170 >                        scalescolor(sctmp, dtmp);
171 >                        saddscolor(scval, sctmp);
172                  }
173          }
174   }
# Line 182 | Line 182 | m_normal(                      /* color a ray that hit something normal *
182   {
183          NORMDAT  nd;
184          double  fest;
185 –        double  transtest, transdist;
186 –        double  mirtest, mirdist;
185          int     hastexture;
186          double  d;
187 <        COLOR  ctmp;
187 >        SCOLOR  sctmp;
188          int  i;
189  
190          /* PMAP: skip transmitted shadow ray if accounted for in photon map */
191 +        /* No longer needed?
192          if (shadowRayInPmap(r) || ambRayInPmap(r))
193 <                return(1);
193 >                return(1); */          
194 >                
195                                                  /* easy shadow test */
196          if (r->crtype & SHADOW && m->otype != MAT_TRANS)
197                  return(1);
# Line 211 | Line 211 | m_normal(                      /* color a ray that hit something normal *
211          nd.mp = m;
212          nd.rp = r;
213                                                  /* get material color */
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 */
# Line 230 | Line 230 | m_normal(                      /* color a ray that hit something normal *
230                  nd.specfl |= SP_FLAT;
231          if (nd.pdot < .001)
232                  nd.pdot = .001;                 /* non-zero for dirnorm() */
233 <        multcolor(nd.mcolor, r->pcol);          /* modify material color */
234 <        mirtest = transtest = 0;
235 <        mirdist = transdist = r->rot;
233 >        smultscolor(nd.mcolor, r->pcol);        /* modify material color */
234          nd.rspec = m->oargs.farg[3];
235                                                  /* compute Fresnel approx. */
236          if (nd.specfl & SP_PURE && nd.rspec >= FRESTHRESH) {
# Line 253 | Line 251 | m_normal(                      /* color a ray that hit something normal *
251                                  nd.specfl |= SP_TBLT;
252                          if (!hastexture || r->crtype & (SHADOW|AMBIENT)) {
253                                  VCOPY(nd.prdir, r->rdir);
256 –                                transtest = 2;
254                          } else {
255 <                                for (i = 0; i < 3; i++)         /* perturb */
256 <                                        nd.prdir[i] = r->rdir[i] - r->pert[i];
255 >                                                        /* perturb */
256 >                                VSUB(nd.prdir, r->rdir, r->pert);
257                                  if (DOT(nd.prdir, r->ron) < -FTINY)
258                                          normalize(nd.prdir);    /* OK */
259                                  else
# Line 265 | Line 262 | m_normal(                      /* color a ray that hit something normal *
262                  }
263          } else
264                  nd.tdiff = nd.tspec = nd.trans = 0.0;
265 +                                                /* diffuse reflection */
266 +        nd.rdiff = 1.0 - nd.trans - nd.rspec;
267                                                  /* transmitted ray */
269 –
268          if ((nd.specfl&(SP_TRAN|SP_PURE|SP_TBLT)) == (SP_TRAN|SP_PURE)) {
269                  RAY  lr;
270 <                copycolor(lr.rcoef, nd.mcolor); /* modified by color */
271 <                scalecolor(lr.rcoef, nd.tspec);
270 >                copyscolor(lr.rcoef, nd.mcolor);        /* modified by color */
271 >                scalescolor(lr.rcoef, nd.tspec);
272                  if (rayorigin(&lr, TRANS, r, lr.rcoef) == 0) {
273                          VCOPY(lr.rdir, nd.prdir);
274                          rayvalue(&lr);
275 <                        multcolor(lr.rcol, lr.rcoef);
276 <                        addcolor(r->rcol, lr.rcol);
277 <                        transtest *= bright(lr.rcol);
278 <                        transdist = r->rot + lr.rt;
275 >                        smultscolor(lr.rcol, lr.rcoef);
276 >                        saddscolor(r->rcol, lr.rcol);
277 >                        if (nd.tspec >= 1.0-FTINY) {
278 >                                                /* completely transparent */
279 >                                smultscolor(lr.mcol, lr.rcoef);
280 >                                copyscolor(r->mcol, lr.mcol);
281 >                                r->rmt = r->rot + lr.rmt;
282 >                                r->rxt = r->rot + lr.rxt;
283 >                        } else if (nd.tspec > nd.tdiff + nd.rdiff)
284 >                                r->rxt = r->rot + raydistance(&lr);
285                  }
286 <        } else
283 <                transtest = 0;
286 >        }
287  
288 <        if (r->crtype & SHADOW) {               /* the rest is shadow */
286 <                r->rt = transdist;
288 >        if (r->crtype & SHADOW)                 /* the rest is shadow */
289                  return(1);
288 –        }
290                                                  /* get specular reflection */
291          if (nd.rspec > FTINY) {
292                  nd.specfl |= SP_REFL;
293                                                  /* compute specular color */
294                  if (m->otype != MAT_METAL) {
295 <                        setcolor(nd.scolor, nd.rspec, nd.rspec, nd.rspec);
295 >                        setscolor(nd.scolor, nd.rspec, nd.rspec, nd.rspec);
296                  } else if (fest > FTINY) {
297                          d = m->oargs.farg[3]*(1. - fest);
298 <                        for (i = 0; i < 3; i++)
299 <                                colval(nd.scolor,i) = fest +
299 <                                                colval(nd.mcolor,i)*d;
298 >                        for (i = NCSAMP; i--; )
299 >                                nd.scolor[i] = fest + nd.mcolor[i]*d;
300                  } else {
301 <                        copycolor(nd.scolor, nd.mcolor);
302 <                        scalecolor(nd.scolor, nd.rspec);
301 >                        copyscolor(nd.scolor, nd.mcolor);
302 >                        scalescolor(nd.scolor, nd.rspec);
303                  }
304                                                  /* check threshold */
305                  if (!(nd.specfl & SP_PURE) && specthresh >= nd.rspec-FTINY)
# Line 317 | Line 317 | m_normal(                      /* color a ray that hit something normal *
317                  if (rayorigin(&lr, REFLECTED, r, nd.scolor) == 0) {
318                          VCOPY(lr.rdir, nd.vrefl);
319                          rayvalue(&lr);
320 <                        multcolor(lr.rcol, lr.rcoef);
321 <                        addcolor(r->rcol, lr.rcol);
320 >                        smultscolor(lr.rcol, lr.rcoef);
321 >                        copyscolor(r->mcol, lr.rcol);
322 >                        saddscolor(r->rcol, lr.rcol);
323 >                        r->rmt = r->rot;
324                          if (nd.specfl & SP_FLAT &&
325 <                                        !hastexture | (r->crtype & AMBIENT)) {
326 <                                mirtest = 2.*bright(lr.rcol);
325 <                                mirdist = r->rot + lr.rt;
326 <                        }
325 >                                        !hastexture | (r->crtype & AMBIENT))
326 >                                r->rmt += raydistance(&lr);
327                  }
328          }
329 –                                                /* diffuse reflection */
330 –        nd.rdiff = 1.0 - nd.trans - nd.rspec;
329  
330          if (nd.specfl & SP_PURE && nd.rdiff <= FTINY && nd.tdiff <= FTINY)
331                  return(1);                      /* 100% pure specular */
# Line 336 | Line 334 | m_normal(                      /* color a ray that hit something normal *
334                  gaussamp(&nd);                  /* checks *BLT flags */
335  
336          if (nd.rdiff > FTINY) {         /* ambient from this side */
337 <                copycolor(ctmp, nd.mcolor);     /* modified by material color */
338 <                scalecolor(ctmp, nd.rdiff);
337 >                copyscolor(sctmp, nd.mcolor);   /* modified by material color */
338 >                scalescolor(sctmp, nd.rdiff);
339                  if (nd.specfl & SP_RBLT)        /* add in specular as well? */
340 <                        addcolor(ctmp, nd.scolor);
341 <                multambient(ctmp, r, hastexture ? nd.pnorm : r->ron);
342 <                addcolor(r->rcol, ctmp);        /* add to returned color */
340 >                        saddscolor(sctmp, nd.scolor);
341 >                multambient(sctmp, r, nd.pnorm);
342 >                saddscolor(r->rcol, sctmp);     /* add to returned color */
343          }
344          if (nd.tdiff > FTINY) {         /* ambient from other side */
345 <                copycolor(ctmp, nd.mcolor);     /* modified by color */
346 <                if (nd.specfl & SP_TBLT)
347 <                        scalecolor(ctmp, nd.trans);
348 <                else
349 <                        scalecolor(ctmp, nd.tdiff);
350 <                flipsurface(r);
351 <                if (hastexture) {
352 <                        FVECT  bnorm;
353 <                        bnorm[0] = -nd.pnorm[0];
354 <                        bnorm[1] = -nd.pnorm[1];
355 <                        bnorm[2] = -nd.pnorm[2];
356 <                        multambient(ctmp, r, bnorm);
359 <                } else
360 <                        multambient(ctmp, r, r->ron);
361 <                addcolor(r->rcol, ctmp);
362 <                flipsurface(r);
345 >                FVECT  bnorm;
346 >                copyscolor(sctmp, nd.mcolor);   /* modified by color */
347 >                if (nd.specfl & SP_TBLT) {
348 >                        scalescolor(sctmp, nd.trans);
349 >                } else {
350 >                        scalescolor(sctmp, nd.tdiff);
351 >                }
352 >                bnorm[0] = -nd.pnorm[0];
353 >                bnorm[1] = -nd.pnorm[1];
354 >                bnorm[2] = -nd.pnorm[2];
355 >                multambient(sctmp, r, bnorm);
356 >                saddscolor(r->rcol, sctmp);
357          }
358                                          /* add direct component */
359          direct(r, dirnorm, &nd);
366 –                                        /* check distance */
367 –        d = bright(r->rcol);
368 –        if (transtest > d)
369 –                r->rt = transdist;
370 –        else if (mirtest > d)
371 –                r->rt = mirdist;
360  
361          return(1);
362   }
# Line 383 | Line 371 | gaussamp(                      /* sample Gaussian specular */
371          FVECT  u, v, h;
372          double  rv[2];
373          double  d, sinp, cosp;
374 <        COLOR  scol;
374 >        SCOLOR  scol;
375          int  maxiter, ntrials, nstarget, nstaken;
376          int  i;
377                                          /* quick test */
# Line 395 | Line 383 | gaussamp(                      /* sample Gaussian specular */
383          fcross(v, np->pnorm, u);
384                                          /* compute reflection */
385          if ((np->specfl & (SP_REFL|SP_RBLT)) == SP_REFL &&
386 <                        rayorigin(&sr, SPECULAR, np->rp, np->scolor) == 0) {
386 >                        rayorigin(&sr, RSPECULAR, np->rp, np->scolor) == 0) {
387                  nstarget = 1;
388                  if (specjitter > 1.5) { /* multiple samples? */
389                          nstarget = specjitter*np->rp->rweight + .5;
# Line 403 | Line 391 | gaussamp(                      /* sample Gaussian specular */
391                                  nstarget = sr.rweight/minweight;
392                          if (nstarget > 1) {
393                                  d = 1./nstarget;
394 <                                scalecolor(sr.rcoef, d);
394 >                                scalescolor(sr.rcoef, d);
395                                  sr.rweight *= d;
396                          } else
397                                  nstarget = 1;
398                  }
399 <                setcolor(scol, 0., 0., 0.);
399 >                scolorblack(scol);
400                  dimlist[ndims++] = (int)(size_t)np->mp;
401                  maxiter = MAXITER*nstarget;
402                  for (nstaken = ntrials = 0; nstaken < nstarget &&
# Line 439 | Line 427 | gaussamp(                      /* sample Gaussian specular */
427                                  if (nstaken) rayclear(&sr);
428                                  rayvalue(&sr);
429                                  d = 2./(1. + np->rp->rod/d);
430 <                                scalecolor(sr.rcol, d);
431 <                                addcolor(scol, sr.rcol);
430 >                                scalescolor(sr.rcol, d);
431 >                                saddscolor(scol, sr.rcol);
432                          } else {
433                                  rayvalue(&sr);
434 <                                multcolor(sr.rcol, sr.rcoef);
435 <                                addcolor(np->rp->rcol, sr.rcol);
434 >                                smultscolor(sr.rcol, sr.rcoef);
435 >                                saddscolor(np->rp->rcol, sr.rcol);
436                          }
437                          ++nstaken;
438                  }
439                  if (nstarget > 1) {             /* final W-G-M-D weighting */
440 <                        multcolor(scol, sr.rcoef);
440 >                        smultscolor(scol, sr.rcoef);
441                          d = (double)nstarget/ntrials;
442 <                        scalecolor(scol, d);
443 <                        addcolor(np->rp->rcol, scol);
442 >                        scalescolor(scol, d);
443 >                        saddscolor(np->rp->rcol, scol);
444                  }
445                  ndims--;
446          }
447                                          /* compute transmission */
448 <        copycolor(sr.rcoef, np->mcolor);        /* modified by color */
449 <        scalecolor(sr.rcoef, np->tspec);
448 >        copyscolor(sr.rcoef, np->mcolor);       /* modified by color */
449 >        scalescolor(sr.rcoef, np->tspec);
450          if ((np->specfl & (SP_TRAN|SP_TBLT)) == SP_TRAN &&
451 <                        rayorigin(&sr, SPECULAR, np->rp, sr.rcoef) == 0) {
451 >                        rayorigin(&sr, TSPECULAR, np->rp, sr.rcoef) == 0) {
452                  nstarget = 1;
453                  if (specjitter > 1.5) { /* multiple samples? */
454                          nstarget = specjitter*np->rp->rweight + .5;
# Line 468 | Line 456 | gaussamp(                      /* sample Gaussian specular */
456                                  nstarget = sr.rweight/minweight;
457                          if (nstarget > 1) {
458                                  d = 1./nstarget;
459 <                                scalecolor(sr.rcoef, d);
459 >                                scalescolor(sr.rcoef, d);
460                                  sr.rweight *= d;
461                          } else
462                                  nstarget = 1;
# Line 500 | Line 488 | gaussamp(                      /* sample Gaussian specular */
488                          if (nstaken)            /* multi-sampling */
489                                  rayclear(&sr);
490                          rayvalue(&sr);
491 <                        multcolor(sr.rcol, sr.rcoef);
492 <                        addcolor(np->rp->rcol, sr.rcol);
491 >                        smultscolor(sr.rcol, sr.rcoef);
492 >                        saddscolor(np->rp->rcol, sr.rcol);
493                          ++nstaken;
494                  }
495                  ndims--;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines