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.76 by greg, Wed Jan 10 04:08:50 2018 UTC vs.
Revision 2.85 by greg, Thu Dec 5 19:23:43 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 */
59 <        FVECT  vrefl;           /* vector in direction of reflected ray */
57 >        SCOLOR  mcolor;         /* color of this material */
58 >        SCOLOR  scolor;         /* color of specular component */
59          FVECT  prdir;           /* vector in transmitted direction */
60          double  alpha2;         /* roughness squared */
61          double  rdiff, rspec;   /* reflected specular, diffuse */
# Line 71 | Line 70 | static void gaussamp(NORMDAT  *np);
70  
71   static void
72   dirnorm(                /* compute source contribution */
73 <        COLOR  cval,                    /* returned coefficient */
73 >        SCOLOR  scval,                  /* returned coefficient */
74          void  *nnp,                     /* material data */
75          FVECT  ldir,                    /* light source direction */
76          double  omega                   /* light source size */
# Line 82 | Line 81 | dirnorm(               /* compute source contribution */
81          double  lrdiff, ltdiff;
82          double  dtmp, d2, d3, d4;
83          FVECT  vtmp;
84 <        COLOR  ctmp;
84 >        SCOLOR  sctmp;
85  
86 <        setcolor(cval, 0.0, 0.0, 0.0);
86 >        scolorblack(scval);
87  
88          ldot = DOT(np->pnorm, ldir);
89  
# Line 101 | Line 100 | dirnorm(               /* compute source contribution */
100                  ltdiff *= dtmp;
101          }
102  
103 <        if (ldot > FTINY && lrdiff > FTINY) {
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);
109 >                copyscolor(sctmp, np->mcolor);
110                  dtmp = ldot * omega * lrdiff * (1.0/PI);
111 <                scalecolor(ctmp, dtmp);
112 <                addcolor(cval, ctmp);
111 >                scalescolor(sctmp, dtmp);
112 >                saddscolor(scval, sctmp);
113          }
114  
115 <        if (ldot < -FTINY && ltdiff > FTINY) {
115 >        if ((ldot < -FTINY) & (ltdiff > FTINY)) {
116                  /*
117                   *  Compute diffuse transmission.
118                   */
119 <                copycolor(ctmp, np->mcolor);
119 >                copyscolor(sctmp, np->mcolor);
120                  dtmp = -ldot * omega * ltdiff * (1.0/PI);
121 <                scalecolor(ctmp, dtmp);
122 <                addcolor(cval, ctmp);
121 >                scalescolor(sctmp, dtmp);
122 >                saddscolor(scval, sctmp);
123          }
124  
125          if (ambRayInPmap(np->rp))
126                  return;         /* specular already in photon map */
127  
128 <        if (ldot > FTINY && (np->specfl&(SP_REFL|SP_PURE)) == SP_REFL) {
128 >        if ((ldot > FTINY) & ((np->specfl&(SP_REFL|SP_PURE)) == SP_REFL)) {
129                  /*
130                   *  Compute specular reflection coefficient using
131                   *  Gaussian distribution model.
# Line 146 | Line 145 | dirnorm(               /* compute source contribution */
145                  dtmp = exp(-d4/dtmp) * d3 / (PI * d2*d2 * dtmp);
146                                                  /* worth using? */
147                  if (dtmp > FTINY) {
148 <                        copycolor(ctmp, np->scolor);
148 >                        copyscolor(sctmp, np->scolor);
149                          dtmp *= ldot * omega;
150 <                        scalecolor(ctmp, dtmp);
151 <                        addcolor(cval, ctmp);
150 >                        scalescolor(sctmp, dtmp);
151 >                        saddscolor(scval, sctmp);
152                  }
153          }
154          
155  
156 <        if (ldot < -FTINY && (np->specfl&(SP_TRAN|SP_PURE)) == SP_TRAN) {
156 >        if ((ldot < -FTINY) & ((np->specfl&(SP_TRAN|SP_PURE)) == SP_TRAN)) {
157                  /*
158                   *  Compute specular transmission.  Specular transmission
159                   *  is always modified by material color.
# Line 165 | Line 164 | dirnorm(               /* compute source contribution */
164                  dtmp = exp((2.*DOT(np->prdir,ldir)-2.)/dtmp)/(PI*dtmp);
165                                                  /* worth using? */
166                  if (dtmp > FTINY) {
167 <                        copycolor(ctmp, np->mcolor);
167 >                        copyscolor(sctmp, np->mcolor);
168                          dtmp *= np->tspec * omega * sqrt(-ldot/np->pdot);
169 <                        scalecolor(ctmp, dtmp);
170 <                        addcolor(cval, ctmp);
169 >                        scalescolor(sctmp, dtmp);
170 >                        saddscolor(scval, sctmp);
171                  }
172          }
173   }
# Line 182 | Line 181 | m_normal(                      /* color a ray that hit something normal *
181   {
182          NORMDAT  nd;
183          double  fest;
185        double  transtest, transdist;
186        double  mirtest, mirdist;
184          int     hastexture;
185          double  d;
186 <        COLOR  ctmp;
186 >        SCOLOR  sctmp;
187          int  i;
188  
189          /* PMAP: skip transmitted shadow ray if accounted for in photon map */
# Line 213 | Line 210 | m_normal(                      /* color a ray that hit something normal *
210          nd.mp = m;
211          nd.rp = r;
212                                                  /* get material color */
213 <        setcolor(nd.mcolor, m->oargs.farg[0],
213 >        setscolor(nd.mcolor, m->oargs.farg[0],
214                             m->oargs.farg[1],
215                             m->oargs.farg[2]);
216                                                  /* get roughness */
# Line 232 | Line 229 | m_normal(                      /* color a ray that hit something normal *
229                  nd.specfl |= SP_FLAT;
230          if (nd.pdot < .001)
231                  nd.pdot = .001;                 /* non-zero for dirnorm() */
232 <        multcolor(nd.mcolor, r->pcol);          /* modify material color */
236 <        mirtest = transtest = 0;
237 <        mirdist = transdist = r->rot;
232 >        smultscolor(nd.mcolor, r->pcol);        /* modify material color */
233          nd.rspec = m->oargs.farg[3];
234                                                  /* compute Fresnel approx. */
235          if (nd.specfl & SP_PURE && nd.rspec >= FRESTHRESH) {
# Line 255 | Line 250 | m_normal(                      /* color a ray that hit something normal *
250                                  nd.specfl |= SP_TBLT;
251                          if (!hastexture || r->crtype & (SHADOW|AMBIENT)) {
252                                  VCOPY(nd.prdir, r->rdir);
258                                transtest = 2;
253                          } else {
254                                                          /* perturb */
255                                  VSUB(nd.prdir, r->rdir, r->pert);
# Line 267 | Line 261 | m_normal(                      /* color a ray that hit something normal *
261                  }
262          } else
263                  nd.tdiff = nd.tspec = nd.trans = 0.0;
264 +                                                /* diffuse reflection */
265 +        nd.rdiff = 1.0 - nd.trans - nd.rspec;
266                                                  /* transmitted ray */
271
267          if ((nd.specfl&(SP_TRAN|SP_PURE|SP_TBLT)) == (SP_TRAN|SP_PURE)) {
268                  RAY  lr;
269 <                copycolor(lr.rcoef, nd.mcolor); /* modified by color */
270 <                scalecolor(lr.rcoef, nd.tspec);
269 >                copyscolor(lr.rcoef, nd.mcolor);        /* modified by color */
270 >                scalescolor(lr.rcoef, nd.tspec);
271                  if (rayorigin(&lr, TRANS, r, lr.rcoef) == 0) {
272                          VCOPY(lr.rdir, nd.prdir);
273                          rayvalue(&lr);
274 <                        multcolor(lr.rcol, lr.rcoef);
275 <                        addcolor(r->rcol, lr.rcol);
276 <                        transtest *= bright(lr.rcol);
277 <                        transdist = r->rot + lr.rt;
274 >                        smultscolor(lr.rcol, lr.rcoef);
275 >                        saddscolor(r->rcol, lr.rcol);
276 >                        if (nd.tspec >= 1.0-FTINY) {
277 >                                                /* completely transparent */
278 >                                smultscolor(lr.mcol, lr.rcoef);
279 >                                copyscolor(r->mcol, lr.mcol);
280 >                                r->rmt = r->rot + lr.rmt;
281 >                                r->rxt = r->rot + lr.rxt;
282 >                        } else if (nd.tspec > nd.tdiff + nd.rdiff)
283 >                                r->rxt = r->rot + raydistance(&lr);
284                  }
285 <        } else
285 <                transtest = 0;
285 >        }
286  
287 <        if (r->crtype & SHADOW) {               /* the rest is shadow */
288 <                r->rt = transdist;
287 >        if (r->crtype & SHADOW)                 /* the rest is shadow */
288                  return(1);
290        }
289                                                  /* get specular reflection */
290          if (nd.rspec > FTINY) {
291                  nd.specfl |= SP_REFL;
292                                                  /* compute specular color */
293                  if (m->otype != MAT_METAL) {
294 <                        setcolor(nd.scolor, nd.rspec, nd.rspec, nd.rspec);
294 >                        setscolor(nd.scolor, nd.rspec, nd.rspec, nd.rspec);
295                  } else if (fest > FTINY) {
296                          d = m->oargs.farg[3]*(1. - fest);
297 <                        for (i = 0; i < 3; i++)
298 <                                colval(nd.scolor,i) = fest +
301 <                                                colval(nd.mcolor,i)*d;
297 >                        for (i = NCSAMP; i--; )
298 >                                nd.scolor[i] = fest + nd.mcolor[i]*d;
299                  } else {
300 <                        copycolor(nd.scolor, nd.mcolor);
301 <                        scalecolor(nd.scolor, nd.rspec);
300 >                        copyscolor(nd.scolor, nd.mcolor);
301 >                        scalescolor(nd.scolor, nd.rspec);
302                  }
303                                                  /* check threshold */
304                  if (!(nd.specfl & SP_PURE) && specthresh >= nd.rspec-FTINY)
305                          nd.specfl |= SP_RBLT;
309                                                /* compute reflected ray */
310                VSUM(nd.vrefl, r->rdir, nd.pnorm, 2.*nd.pdot);
311                                                /* penetration? */
312                if (hastexture && DOT(nd.vrefl, r->ron) <= FTINY)
313                        VSUM(nd.vrefl, r->rdir, r->ron, 2.*r->rod);
314                checknorm(nd.vrefl);
306          }
307                                                  /* reflected ray */
308          if ((nd.specfl&(SP_REFL|SP_PURE|SP_RBLT)) == (SP_REFL|SP_PURE)) {
309                  RAY  lr;
310                  if (rayorigin(&lr, REFLECTED, r, nd.scolor) == 0) {
311 <                        VCOPY(lr.rdir, nd.vrefl);
311 >                                                /* compute reflected ray */
312 >                        VSUM(lr.rdir, r->rdir, nd.pnorm, 2.*nd.pdot);
313 >                                                /* penetration? */
314 >                        if (hastexture && DOT(lr.rdir, r->ron) <= FTINY)
315 >                                VSUM(lr.rdir, r->rdir, r->ron, 2.*r->rod);
316 >                        checknorm(lr.rdir);
317                          rayvalue(&lr);
318 <                        multcolor(lr.rcol, lr.rcoef);
319 <                        addcolor(r->rcol, lr.rcol);
318 >                        smultscolor(lr.rcol, lr.rcoef);
319 >                        copyscolor(r->mcol, lr.rcol);
320 >                        saddscolor(r->rcol, lr.rcol);
321 >                        r->rmt = r->rot;
322                          if (nd.specfl & SP_FLAT &&
323 <                                        !hastexture | (r->crtype & AMBIENT)) {
324 <                                mirtest = 2.*bright(lr.rcol);
327 <                                mirdist = r->rot + lr.rt;
328 <                        }
323 >                                        !hastexture | (r->crtype & AMBIENT))
324 >                                r->rmt += raydistance(&lr);
325                  }
326          }
331                                                /* diffuse reflection */
332        nd.rdiff = 1.0 - nd.trans - nd.rspec;
327  
328 <        if (nd.specfl & SP_PURE && nd.rdiff <= FTINY && nd.tdiff <= FTINY) {
335 <                if (mirtest > transtest+FTINY)
336 <                        r->rt = mirdist;
337 <                else if (transtest > FTINY)
338 <                        r->rt = transdist;
328 >        if (nd.specfl & SP_PURE && nd.rdiff <= FTINY && nd.tdiff <= FTINY)
329                  return(1);                      /* 100% pure specular */
330 <        }
330 >
331          if (!(nd.specfl & SP_PURE))
332                  gaussamp(&nd);                  /* checks *BLT flags */
333  
334          if (nd.rdiff > FTINY) {         /* ambient from this side */
335 <                copycolor(ctmp, nd.mcolor);     /* modified by material color */
336 <                scalecolor(ctmp, nd.rdiff);
335 >                copyscolor(sctmp, nd.mcolor);   /* modified by material color */
336 >                scalescolor(sctmp, nd.rdiff);
337                  if (nd.specfl & SP_RBLT)        /* add in specular as well? */
338 <                        addcolor(ctmp, nd.scolor);
339 <                multambient(ctmp, r, hastexture ? nd.pnorm : r->ron);
340 <                addcolor(r->rcol, ctmp);        /* add to returned color */
338 >                        saddscolor(sctmp, nd.scolor);
339 >                multambient(sctmp, r, nd.pnorm);
340 >                saddscolor(r->rcol, sctmp);     /* add to returned color */
341          }
342          if (nd.tdiff > FTINY) {         /* ambient from other side */
343 <                copycolor(ctmp, nd.mcolor);     /* modified by color */
344 <                if (nd.specfl & SP_TBLT)
345 <                        scalecolor(ctmp, nd.trans);
346 <                else
347 <                        scalecolor(ctmp, nd.tdiff);
348 <                flipsurface(r);
349 <                if (hastexture) {
350 <                        FVECT  bnorm;
351 <                        bnorm[0] = -nd.pnorm[0];
352 <                        bnorm[1] = -nd.pnorm[1];
353 <                        bnorm[2] = -nd.pnorm[2];
354 <                        multambient(ctmp, r, bnorm);
365 <                } else
366 <                        multambient(ctmp, r, r->ron);
367 <                addcolor(r->rcol, ctmp);
368 <                flipsurface(r);
343 >                FVECT  bnorm;
344 >                copyscolor(sctmp, nd.mcolor);   /* modified by color */
345 >                if (nd.specfl & SP_TBLT) {
346 >                        scalescolor(sctmp, nd.trans);
347 >                } else {
348 >                        scalescolor(sctmp, nd.tdiff);
349 >                }
350 >                bnorm[0] = -nd.pnorm[0];
351 >                bnorm[1] = -nd.pnorm[1];
352 >                bnorm[2] = -nd.pnorm[2];
353 >                multambient(sctmp, r, bnorm);
354 >                saddscolor(r->rcol, sctmp);
355          }
356                                          /* add direct component */
357          direct(r, dirnorm, &nd);
372                                        /* check distance */
373        d = bright(r->rcol);
374        if (transtest > d)
375                r->rt = transdist;
376        else if (mirtest > d)
377                r->rt = mirdist;
358  
359          return(1);
360   }
# Line 389 | Line 369 | gaussamp(                      /* sample Gaussian specular */
369          FVECT  u, v, h;
370          double  rv[2];
371          double  d, sinp, cosp;
372 <        COLOR  scol;
372 >        SCOLOR  scol;
373          int  maxiter, ntrials, nstarget, nstaken;
374          int  i;
375                                          /* quick test */
# Line 401 | Line 381 | gaussamp(                      /* sample Gaussian specular */
381          fcross(v, np->pnorm, u);
382                                          /* compute reflection */
383          if ((np->specfl & (SP_REFL|SP_RBLT)) == SP_REFL &&
384 <                        rayorigin(&sr, SPECULAR, np->rp, np->scolor) == 0) {
384 >                        rayorigin(&sr, RSPECULAR, np->rp, np->scolor) == 0) {
385                  nstarget = 1;
386                  if (specjitter > 1.5) { /* multiple samples? */
387                          nstarget = specjitter*np->rp->rweight + .5;
# Line 409 | Line 389 | gaussamp(                      /* sample Gaussian specular */
389                                  nstarget = sr.rweight/minweight;
390                          if (nstarget > 1) {
391                                  d = 1./nstarget;
392 <                                scalecolor(sr.rcoef, d);
392 >                                scalescolor(sr.rcoef, d);
393                                  sr.rweight *= d;
394                          } else
395                                  nstarget = 1;
396                  }
397 <                setcolor(scol, 0., 0., 0.);
397 >                scolorblack(scol);
398                  dimlist[ndims++] = (int)(size_t)np->mp;
399                  maxiter = MAXITER*nstarget;
400                  for (nstaken = ntrials = 0; nstaken < nstarget &&
# Line 445 | Line 425 | gaussamp(                      /* sample Gaussian specular */
425                                  if (nstaken) rayclear(&sr);
426                                  rayvalue(&sr);
427                                  d = 2./(1. + np->rp->rod/d);
428 <                                scalecolor(sr.rcol, d);
429 <                                addcolor(scol, sr.rcol);
428 >                                scalescolor(sr.rcol, d);
429 >                                saddscolor(scol, sr.rcol);
430                          } else {
431                                  rayvalue(&sr);
432 <                                multcolor(sr.rcol, sr.rcoef);
433 <                                addcolor(np->rp->rcol, sr.rcol);
432 >                                smultscolor(sr.rcol, sr.rcoef);
433 >                                saddscolor(np->rp->rcol, sr.rcol);
434                          }
435                          ++nstaken;
436                  }
437                  if (nstarget > 1) {             /* final W-G-M-D weighting */
438 <                        multcolor(scol, sr.rcoef);
438 >                        smultscolor(scol, sr.rcoef);
439                          d = (double)nstarget/ntrials;
440 <                        scalecolor(scol, d);
441 <                        addcolor(np->rp->rcol, scol);
440 >                        scalescolor(scol, d);
441 >                        saddscolor(np->rp->rcol, scol);
442                  }
443                  ndims--;
444          }
445                                          /* compute transmission */
446 <        copycolor(sr.rcoef, np->mcolor);        /* modified by color */
447 <        scalecolor(sr.rcoef, np->tspec);
446 >        copyscolor(sr.rcoef, np->mcolor);       /* modified by color */
447 >        scalescolor(sr.rcoef, np->tspec);
448          if ((np->specfl & (SP_TRAN|SP_TBLT)) == SP_TRAN &&
449 <                        rayorigin(&sr, SPECULAR, np->rp, sr.rcoef) == 0) {
449 >                        rayorigin(&sr, TSPECULAR, np->rp, sr.rcoef) == 0) {
450                  nstarget = 1;
451                  if (specjitter > 1.5) { /* multiple samples? */
452                          nstarget = specjitter*np->rp->rweight + .5;
# Line 474 | Line 454 | gaussamp(                      /* sample Gaussian specular */
454                                  nstarget = sr.rweight/minweight;
455                          if (nstarget > 1) {
456                                  d = 1./nstarget;
457 <                                scalecolor(sr.rcoef, d);
457 >                                scalescolor(sr.rcoef, d);
458                                  sr.rweight *= d;
459                          } else
460                                  nstarget = 1;
# Line 506 | Line 486 | gaussamp(                      /* sample Gaussian specular */
486                          if (nstaken)            /* multi-sampling */
487                                  rayclear(&sr);
488                          rayvalue(&sr);
489 <                        multcolor(sr.rcol, sr.rcoef);
490 <                        addcolor(np->rp->rcol, sr.rcol);
489 >                        smultscolor(sr.rcol, sr.rcoef);
490 >                        saddscolor(np->rp->rcol, sr.rcol);
491                          ++nstaken;
492                  }
493                  ndims--;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines