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.82 by greg, Tue Mar 7 02:24:44 2023 UTC vs.
Revision 2.83 by greg, Wed Nov 15 18:02:53 2023 UTC

# 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 184 | Line 184 | m_normal(                      /* color a ray that hit something normal *
184          double  fest;
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 */
# 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 */
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 267 | Line 267 | m_normal(                      /* color a ray that hit something normal *
267                                                  /* transmitted ray */
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);
275 >                        smultscolor(lr.rcol, lr.rcoef);
276 >                        saddscolor(r->rcol, lr.rcol);
277                          if (nd.tspec >= 1.0-FTINY) {
278                                                  /* completely transparent */
279 <                                multcolor(lr.mcol, lr.rcoef);
280 <                                copycolor(r->mcol, lr.mcol);
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)
# Line 292 | Line 292 | m_normal(                      /* color a ray that hit something normal *
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 +
300 <                                                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 318 | 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 <                        copycolor(r->mcol, lr.rcol);
322 <                        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))
# Line 335 | 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, hastexture ? nd.pnorm : r->ron);
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);
345 >                copyscolor(sctmp, nd.mcolor);   /* modified by color */
346 >                if (nd.specfl & SP_TBLT) {
347 >                        scalescolor(sctmp, nd.trans);
348 >                } else {
349 >                        scalescolor(sctmp, nd.tdiff);
350 >                }
351                  flipsurface(r);
352                  if (hastexture) {
353                          FVECT  bnorm;
354                          bnorm[0] = -nd.pnorm[0];
355                          bnorm[1] = -nd.pnorm[1];
356                          bnorm[2] = -nd.pnorm[2];
357 <                        multambient(ctmp, r, bnorm);
357 >                        multambient(sctmp, r, bnorm);
358                  } else
359 <                        multambient(ctmp, r, r->ron);
360 <                addcolor(r->rcol, ctmp);
359 >                        multambient(sctmp, r, r->ron);
360 >                saddscolor(r->rcol, sctmp);
361                  flipsurface(r);
362          }
363                                          /* add direct component */
# Line 376 | Line 376 | gaussamp(                      /* sample Gaussian specular */
376          FVECT  u, v, h;
377          double  rv[2];
378          double  d, sinp, cosp;
379 <        COLOR  scol;
379 >        SCOLOR  scol;
380          int  maxiter, ntrials, nstarget, nstaken;
381          int  i;
382                                          /* quick test */
# Line 396 | Line 396 | gaussamp(                      /* sample Gaussian specular */
396                                  nstarget = sr.rweight/minweight;
397                          if (nstarget > 1) {
398                                  d = 1./nstarget;
399 <                                scalecolor(sr.rcoef, d);
399 >                                scalescolor(sr.rcoef, d);
400                                  sr.rweight *= d;
401                          } else
402                                  nstarget = 1;
403                  }
404 <                setcolor(scol, 0., 0., 0.);
404 >                scolorblack(scol);
405                  dimlist[ndims++] = (int)(size_t)np->mp;
406                  maxiter = MAXITER*nstarget;
407                  for (nstaken = ntrials = 0; nstaken < nstarget &&
# Line 432 | Line 432 | gaussamp(                      /* sample Gaussian specular */
432                                  if (nstaken) rayclear(&sr);
433                                  rayvalue(&sr);
434                                  d = 2./(1. + np->rp->rod/d);
435 <                                scalecolor(sr.rcol, d);
436 <                                addcolor(scol, sr.rcol);
435 >                                scalescolor(sr.rcol, d);
436 >                                saddscolor(scol, sr.rcol);
437                          } else {
438                                  rayvalue(&sr);
439 <                                multcolor(sr.rcol, sr.rcoef);
440 <                                addcolor(np->rp->rcol, sr.rcol);
439 >                                smultscolor(sr.rcol, sr.rcoef);
440 >                                saddscolor(np->rp->rcol, sr.rcol);
441                          }
442                          ++nstaken;
443                  }
444                  if (nstarget > 1) {             /* final W-G-M-D weighting */
445 <                        multcolor(scol, sr.rcoef);
445 >                        smultscolor(scol, sr.rcoef);
446                          d = (double)nstarget/ntrials;
447 <                        scalecolor(scol, d);
448 <                        addcolor(np->rp->rcol, scol);
447 >                        scalescolor(scol, d);
448 >                        saddscolor(np->rp->rcol, scol);
449                  }
450                  ndims--;
451          }
452                                          /* compute transmission */
453 <        copycolor(sr.rcoef, np->mcolor);        /* modified by color */
454 <        scalecolor(sr.rcoef, np->tspec);
453 >        copyscolor(sr.rcoef, np->mcolor);       /* modified by color */
454 >        scalescolor(sr.rcoef, np->tspec);
455          if ((np->specfl & (SP_TRAN|SP_TBLT)) == SP_TRAN &&
456                          rayorigin(&sr, SPECULAR, np->rp, sr.rcoef) == 0) {
457                  nstarget = 1;
# Line 461 | Line 461 | gaussamp(                      /* sample Gaussian specular */
461                                  nstarget = sr.rweight/minweight;
462                          if (nstarget > 1) {
463                                  d = 1./nstarget;
464 <                                scalecolor(sr.rcoef, d);
464 >                                scalescolor(sr.rcoef, d);
465                                  sr.rweight *= d;
466                          } else
467                                  nstarget = 1;
# Line 493 | Line 493 | gaussamp(                      /* sample Gaussian specular */
493                          if (nstaken)            /* multi-sampling */
494                                  rayclear(&sr);
495                          rayvalue(&sr);
496 <                        multcolor(sr.rcol, sr.rcoef);
497 <                        addcolor(np->rp->rcol, sr.rcol);
496 >                        smultscolor(sr.rcol, sr.rcoef);
497 >                        saddscolor(np->rp->rcol, sr.rcol);
498                          ++nstaken;
499                  }
500                  ndims--;

Diff Legend

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