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

Comparing ray/src/rt/aniso.c (file contents):
Revision 2.61 by greg, Wed Sep 2 18:59:01 2015 UTC vs.
Revision 2.62 by greg, Wed Nov 15 18:02:52 2023 UTC

# Line 47 | Line 47 | typedef struct {
47          OBJREC  *mp;            /* material pointer */
48          RAY  *rp;               /* ray pointer */
49          short  specfl;          /* specularity flags, defined above */
50 <        COLOR  mcolor;          /* color of this material */
51 <        COLOR  scolor;          /* color of specular component */
50 >        SCOLOR  mcolor;         /* color of this material */
51 >        SCOLOR  scolor;         /* color of specular component */
52          FVECT  vrefl;           /* vector in reflected direction */
53          FVECT  prdir;           /* vector in transmitted direction */
54          FVECT  u, v;            /* u and v vectors orienting anisotropy */
# Line 67 | Line 67 | static void agaussamp(ANISODAT  *np);
67  
68   static void
69   diraniso(               /* compute source contribution */
70 <        COLOR  cval,                    /* returned coefficient */
70 >        SCOLOR  scval,                  /* returned coefficient */
71          void  *nnp,                     /* material data */
72          FVECT  ldir,                    /* light source direction */
73          double  omega                   /* light source size */
# Line 78 | Line 78 | diraniso(              /* compute source contribution */
78          double  dtmp, dtmp1, dtmp2;
79          FVECT  h;
80          double  au2, av2;
81 <        COLOR  ctmp;
81 >        SCOLOR  sctmp;
82  
83 <        setcolor(cval, 0.0, 0.0, 0.0);
83 >        scolorblack(scval);
84  
85          ldot = DOT(np->pnorm, ldir);
86  
# Line 93 | Line 93 | diraniso(              /* compute source contribution */
93                   *  color.  The diffuse reflected component will always be
94                   *  modified by the color of the material.
95                   */
96 <                copycolor(ctmp, np->mcolor);
96 >                copyscolor(sctmp, np->mcolor);
97                  dtmp = ldot * omega * np->rdiff * (1.0/PI);
98 <                scalecolor(ctmp, dtmp);
99 <                addcolor(cval, ctmp);
98 >                scalescolor(sctmp, dtmp);
99 >                saddscolor(scval, sctmp);
100          }
101  
102          if ((ldot < -FTINY) & (np->tdiff > FTINY)) {
103                  /*
104                   *  Compute diffuse transmission.
105                   */
106 <                copycolor(ctmp, np->mcolor);
106 >                copyscolor(sctmp, np->mcolor);
107                  dtmp = -ldot * omega * np->tdiff * (1.0/PI);
108 <                scalecolor(ctmp, dtmp);
109 <                addcolor(cval, ctmp);
108 >                scalescolor(sctmp, dtmp);
109 >                saddscolor(scval, sctmp);
110          }
111          
112          if (ambRayInPmap(np->rp))
# Line 139 | Line 139 | diraniso(              /* compute source contribution */
139                                  (PI * dtmp*dtmp * sqrt(au2*av2));
140                                                  /* worth using? */
141                  if (dtmp > FTINY) {
142 <                        copycolor(ctmp, np->scolor);
142 >                        copyscolor(sctmp, np->scolor);
143                          dtmp *= ldot * omega;
144 <                        scalecolor(ctmp, dtmp);
145 <                        addcolor(cval, ctmp);
144 >                        scalescolor(sctmp, dtmp);
145 >                        saddscolor(scval, sctmp);
146                  }
147          }
148          
# Line 174 | Line 174 | diraniso(              /* compute source contribution */
174                  dtmp = exp(-dtmp) * (1.0/PI) * sqrt(-ldot/(np->pdot*au2*av2));
175                                                  /* worth using? */
176                  if (dtmp > FTINY) {
177 <                        copycolor(ctmp, np->mcolor);
177 >                        copyscolor(sctmp, np->mcolor);
178                          dtmp *= np->tspec * omega;
179 <                        scalecolor(ctmp, dtmp);
180 <                        addcolor(cval, ctmp);
179 >                        scalescolor(sctmp, dtmp);
180 >                        saddscolor(scval, sctmp);
181                  }
182          }
183   }
# Line 190 | Line 190 | m_aniso(                       /* shade ray that hit something anisotropic
190   )
191   {
192          ANISODAT  nd;
193 <        COLOR  ctmp;
193 >        SCOLOR  sctmp;
194          int  i;
195                                                  /* easy shadow test */
196          if (r->crtype & SHADOW)
# Line 211 | Line 211 | m_aniso(                       /* shade ray that hit something anisotropic
211                                                  /* get material color */
212          nd.mp = m;
213          nd.rp = r;
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 224 | Line 224 | m_aniso(                       /* shade ray that hit something anisotropic
224          nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
225          if (nd.pdot < .001)
226                  nd.pdot = .001;                 /* non-zero for diraniso() */
227 <        multcolor(nd.mcolor, r->pcol);          /* modify material color */
227 >        smultscolor(nd.mcolor, r->pcol);        /* modify material color */
228                                                  /* get specular component */
229          if ((nd.rspec = m->oargs.farg[3]) > FTINY) {
230                  nd.specfl |= SP_REFL;
231                                                  /* compute specular color */
232                  if (m->otype == MAT_METAL2)
233 <                        copycolor(nd.scolor, nd.mcolor);
233 >                        copyscolor(nd.scolor, nd.mcolor);
234                  else
235 <                        setcolor(nd.scolor, 1.0, 1.0, 1.0);
236 <                scalecolor(nd.scolor, nd.rspec);
235 >                        setscolor(nd.scolor, 1.0, 1.0, 1.0);
236 >                scalescolor(nd.scolor, nd.rspec);
237                                                  /* check threshold */
238                  if (specthresh >= nd.rspec-FTINY)
239                          nd.specfl |= SP_RBLT;
# Line 278 | Line 278 | m_aniso(                       /* shade ray that hit something anisotropic
278                  agaussamp(&nd);
279  
280          if (nd.rdiff > FTINY) {         /* ambient from this side */
281 <                copycolor(ctmp, nd.mcolor);     /* modified by material color */
282 <                scalecolor(ctmp, nd.rdiff);
281 >                copyscolor(sctmp, nd.mcolor);   /* modified by material color */
282 >                scalescolor(sctmp, nd.rdiff);
283                  if (nd.specfl & SP_RBLT)        /* add in specular as well? */
284 <                        addcolor(ctmp, nd.scolor);
285 <                multambient(ctmp, r, nd.pnorm);
286 <                addcolor(r->rcol, ctmp);        /* add to returned color */
284 >                        saddscolor(sctmp, nd.scolor);
285 >                multambient(sctmp, r, nd.pnorm);
286 >                saddscolor(r->rcol, sctmp);     /* add to returned color */
287          }
288          
289          if (nd.tdiff > FTINY) {         /* ambient from other side */
# Line 293 | Line 293 | m_aniso(                       /* shade ray that hit something anisotropic
293                  bnorm[0] = -nd.pnorm[0];
294                  bnorm[1] = -nd.pnorm[1];
295                  bnorm[2] = -nd.pnorm[2];
296 <                copycolor(ctmp, nd.mcolor);     /* modified by color */
297 <                if (nd.specfl & SP_TBLT)
298 <                        scalecolor(ctmp, nd.trans);
299 <                else
300 <                        scalecolor(ctmp, nd.tdiff);
301 <                multambient(ctmp, r, bnorm);
302 <                addcolor(r->rcol, ctmp);
296 >                copyscolor(sctmp, nd.mcolor);   /* modified by color */
297 >                if (nd.specfl & SP_TBLT) {
298 >                        scalescolor(sctmp, nd.trans);
299 >                } else {
300 >                        scalescolor(sctmp, nd.tdiff);
301 >                }
302 >                multambient(sctmp, r, bnorm);
303 >                saddscolor(r->rcol, sctmp);
304                  flipsurface(r);
305          }
306                                          /* add direct component */
# Line 347 | Line 348 | agaussamp(             /* sample anisotropic Gaussian specular */
348          FVECT  h;
349          double  rv[2];
350          double  d, sinp, cosp;
351 <        COLOR   scol;
351 >        SCOLOR  scol;
352          int  maxiter, ntrials, nstarget, nstaken;
353          int  i;
354                                          /* compute reflection */
# Line 365 | Line 366 | agaussamp(             /* sample anisotropic Gaussian specular */
366                          } else
367                                  nstarget = 1;
368                  }
369 <                setcolor(scol, 0., 0., 0.);
369 >                scolorblack(scol);
370                  dimlist[ndims++] = (int)(size_t)np->mp;
371                  maxiter = MAXITER*nstarget;
372                  for (nstaken = ntrials = 0; nstaken < nstarget &&
# Line 402 | Line 403 | agaussamp(             /* sample anisotropic Gaussian specular */
403                                  if (nstaken) rayclear(&sr);
404                                  rayvalue(&sr);
405                                  d = 2./(1. + np->rp->rod/d);
406 <                                scalecolor(sr.rcol, d);
407 <                                addcolor(scol, sr.rcol);
406 >                                scalescolor(sr.rcol, d);
407 >                                saddscolor(scol, sr.rcol);
408                          } else {
409                                  rayvalue(&sr);
410 <                                multcolor(sr.rcol, sr.rcoef);
411 <                                addcolor(np->rp->rcol, sr.rcol);
410 >                                smultscolor(sr.rcol, sr.rcoef);
411 >                                saddscolor(np->rp->rcol, sr.rcol);
412                          }
413                          ++nstaken;
414                  }
415                  if (nstarget > 1) {             /* final W-G-M-D weighting */
416 <                        multcolor(scol, sr.rcoef);
416 >                        smultscolor(scol, sr.rcoef);
417                          d = (double)nstarget/ntrials;
418 <                        scalecolor(scol, d);
419 <                        addcolor(np->rp->rcol, scol);
418 >                        scalescolor(scol, d);
419 >                        saddscolor(np->rp->rcol, scol);
420                  }
421                  ndims--;
422          }
423                                          /* compute transmission */
424 <        copycolor(sr.rcoef, np->mcolor);                /* modify by material color */
425 <        scalecolor(sr.rcoef, np->tspec);
424 >        copyscolor(sr.rcoef, np->mcolor);               /* modify by material color */
425 >        scalescolor(sr.rcoef, np->tspec);
426          if ((np->specfl & (SP_TRAN|SP_TBLT)) == SP_TRAN &&
427                          rayorigin(&sr, SPECULAR, np->rp, sr.rcoef) == 0) {
428                  nstarget = 1;
# Line 468 | Line 469 | agaussamp(             /* sample anisotropic Gaussian specular */
469                          if (nstaken)            /* multi-sampling */
470                                  rayclear(&sr);
471                          rayvalue(&sr);
472 <                        multcolor(sr.rcol, sr.rcoef);
473 <                        addcolor(np->rp->rcol, sr.rcol);
472 >                        smultscolor(sr.rcol, sr.rcoef);
473 >                        saddscolor(np->rp->rcol, sr.rcol);
474                          ++nstaken;
475                  }
476                  ndims--;

Diff Legend

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