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

Comparing ray/src/rt/m_brdf.c (file contents):
Revision 2.39 by greg, Fri Apr 19 19:01:32 2019 UTC vs.
Revision 2.40 by greg, Wed Nov 15 18:02:52 2023 UTC

# Line 67 | Line 67 | typedef struct {
67          OBJREC  *mp;            /* material pointer */
68          RAY  *pr;               /* intersected ray */
69          DATARRAY  *dp;          /* data array for PDATA, MDATA or TDATA */
70 <        COLOR  mcolor;          /* material (or pattern) color */
71 <        COLOR  rdiff;           /* diffuse reflection */
72 <        COLOR  tdiff;           /* diffuse transmission */
70 >        SCOLOR  mcolor;         /* material (or pattern) color */
71 >        SCOLOR  rdiff;          /* diffuse reflection */
72 >        SCOLOR  tdiff;          /* diffuse transmission */
73          double  rspec;          /* specular reflectance (1 for BRDTF) */
74          double  trans;          /* transmissivity (.5 for BRDTF) */
75          double  tspec;          /* specular transmittance (1 for BRDTF) */
# Line 83 | Line 83 | static int setbrdfunc(BRDFDAT *np);
83  
84   static void
85   dirbrdf(                /* compute source contribution */
86 <        COLOR  cval,                    /* returned coefficient */
87 <        void  *nnp,             /* material data */
86 >        SCOLOR  scval,                  /* returned coefficient */
87 >        void  *nnp,                     /* material data */
88          FVECT  ldir,                    /* light source direction */
89          double  omega                   /* light source size */
90   )
# Line 92 | Line 92 | dirbrdf(               /* compute source contribution */
92          BRDFDAT *np = nnp;
93          double  ldot;
94          double  dtmp;
95 +        SCOLOR  sctmp;
96          COLOR  ctmp;
97          FVECT  ldx;
98 <        static double  vldx[5], pt[MAXDIM];
98 >        static double  vldx[5], pt[MAXDDIM];
99          char    **sa;
100          int     i;
101   #define lddx (vldx+1)
102  
103 <        setcolor(cval, 0.0, 0.0, 0.0);
103 >        scolorblack(scval);
104          
105          ldot = DOT(np->pnorm, ldir);
106  
# Line 115 | Line 116 | dirbrdf(               /* compute source contribution */
116                   *  color.  The diffuse reflected component will always be
117                   *  modified by the color of the material.
118                   */
119 <                copycolor(ctmp, np->rdiff);
119 >                copyscolor(sctmp, np->rdiff);
120                  dtmp = ldot * omega / PI;
121 <                scalecolor(ctmp, dtmp);
122 <                addcolor(cval, ctmp);
121 >                scalescolor(sctmp, dtmp);
122 >                saddscolor(scval, sctmp);
123          } else {
124                  /*
125                   *  Diffuse transmitted component.
126                   */
127 <                copycolor(ctmp, np->tdiff);
127 >                copyscolor(sctmp, np->tdiff);
128                  dtmp = -ldot * omega / PI;
129 <                scalecolor(ctmp, dtmp);
130 <                addcolor(cval, ctmp);
129 >                scalescolor(sctmp, dtmp);
130 >                saddscolor(scval, sctmp);
131          }
132          if ((ldot > 0.0 ? np->rspec <= FTINY : np->tspec <= FTINY) ||
133                          ambRayInPmap(np->pr))
# Line 177 | Line 178 | dirbrdf(               /* compute source contribution */
178          }
179          if (dtmp <= FTINY)
180                  return;
181 +        setscolor(sctmp, colval(ctmp,RED), colval(ctmp,GRN), colval(ctmp,BLU));
182          if (ldot > 0.0) {
183                  /*
184                   *  Compute reflected non-diffuse component.
185                   */
186                  if ((np->mp->otype == MAT_MFUNC) | (np->mp->otype == MAT_MDATA))
187 <                        multcolor(ctmp, np->mcolor);
187 >                        smultscolor(sctmp, np->mcolor);
188                  dtmp = ldot * omega * np->rspec;
189 <                scalecolor(ctmp, dtmp);
190 <                addcolor(cval, ctmp);
189 >                scalescolor(sctmp, dtmp);
190 >                saddscolor(scval, sctmp);
191          } else {
192                  /*
193                   *  Compute transmitted non-diffuse component.
194                   */
195                  if ((np->mp->otype == MAT_TFUNC) | (np->mp->otype == MAT_TDATA))
196 <                        multcolor(ctmp, np->mcolor);
196 >                        smultscolor(sctmp, np->mcolor);
197                  dtmp = -ldot * omega * np->tspec;
198 <                scalecolor(ctmp, dtmp);
199 <                addcolor(cval, ctmp);
198 >                scalescolor(sctmp, dtmp);
199 >                saddscolor(scval, sctmp);
200          }
201   #undef lddx
202   }
# Line 211 | Line 213 | m_brdf(                        /* color a ray that hit a BRDTfunc material
213          RAY  sr;
214          int  hasrefl, hastrans;
215          int  hastexture;
216 <        COLOR  ctmp;
216 >        SCOLOR  sctmp;
217          FVECT  vtmp;
218          double  d;
219          MFUNC  *mf;
# Line 226 | Line 228 | m_brdf(                        /* color a ray that hit a BRDTfunc material
228          nd.trans = 0.5;
229                                                  /* diffuse reflectance */
230          if (r->rod > 0.0)
231 <                setcolor(nd.rdiff, m->oargs.farg[0],
231 >                setscolor(nd.rdiff, m->oargs.farg[0],
232                                  m->oargs.farg[1],
233                                  m->oargs.farg[2]);
234          else
235 <                setcolor(nd.rdiff, m->oargs.farg[3],
235 >                setscolor(nd.rdiff, m->oargs.farg[3],
236                                  m->oargs.farg[4],
237                                  m->oargs.farg[5]);
238                                                  /* diffuse transmittance */
239 <        setcolor(nd.tdiff, m->oargs.farg[6],
239 >        setscolor(nd.tdiff, m->oargs.farg[6],
240                          m->oargs.farg[7],
241                          m->oargs.farg[8]);
242                                                  /* get modifiers */
# Line 254 | Line 256 | m_brdf(                        /* color a ray that hit a BRDTfunc material
256                  }
257                  hitfront = 0;
258          }
259 <        copycolor(nd.mcolor, r->pcol);          /* get pattern color */
260 <        multcolor(nd.rdiff, nd.mcolor);         /* modify diffuse values */
261 <        multcolor(nd.tdiff, nd.mcolor);
262 <        hasrefl = (bright(nd.rdiff) > FTINY);
263 <        hastrans = (bright(nd.tdiff) > FTINY);
259 >        copyscolor(nd.mcolor, r->pcol);         /* get pattern color */
260 >        smultscolor(nd.rdiff, nd.mcolor);       /* modify diffuse values */
261 >        smultscolor(nd.tdiff, nd.mcolor);
262 >        hasrefl = (sintens(nd.rdiff) > FTINY);
263 >        hastrans = (sintens(nd.tdiff) > FTINY);
264                                                  /* load cal file */
265          nd.dp = NULL;
266          mf = getfunc(m, 9, 0x3f, 0);
267                                                  /* compute transmitted ray */
268          setbrdfunc(&nd);
269          errno = 0;
270 <        setcolor(ctmp, evalue(mf->ep[3]),
270 >        setscolor(sctmp, evalue(mf->ep[3]),
271                          evalue(mf->ep[4]),
272                          evalue(mf->ep[5]));
273          if ((errno == EDOM) | (errno == ERANGE))
274                  objerror(m, WARNING, "compute error");
275 <        else if (rayorigin(&sr, TRANS, r, ctmp) == 0) {
275 >        else if (rayorigin(&sr, TRANS, r, sctmp) == 0) {
276                  if (hastexture && !(r->crtype & (SHADOW|AMBIENT))) {
277                                                  /* perturb direction */
278                          VSUB(sr.rdir, r->rdir, r->pert);
# Line 282 | Line 284 | m_brdf(                        /* color a ray that hit a BRDTfunc material
284                          VCOPY(sr.rdir, r->rdir);
285                  }
286                  rayvalue(&sr);
287 <                multcolor(sr.rcol, sr.rcoef);
288 <                addcolor(r->rcol, sr.rcol);
287 >                smultscolor(sr.rcol, sr.rcoef);
288 >                saddscolor(r->rcol, sr.rcol);
289                  if ((!hastexture || r->crtype & (SHADOW|AMBIENT)) &&
290 <                                nd.tspec > bright(nd.tdiff) + bright(nd.rdiff))
290 >                                nd.tspec > pbright(nd.tdiff) + pbright(nd.rdiff))
291                          r->rxt = r->rot + raydistance(&sr);
292          }
293          if (r->crtype & SHADOW)                 /* the rest is shadow */
# Line 294 | Line 296 | m_brdf(                        /* color a ray that hit a BRDTfunc material
296                                                  /* compute reflected ray */
297          setbrdfunc(&nd);
298          errno = 0;
299 <        setcolor(ctmp, evalue(mf->ep[0]),
299 >        setscolor(sctmp, evalue(mf->ep[0]),
300                          evalue(mf->ep[1]),
301                          evalue(mf->ep[2]));
302          if ((errno == EDOM) | (errno == ERANGE))
303                  objerror(m, WARNING, "compute error");
304 <        else if (rayorigin(&sr, REFLECTED, r, ctmp) == 0) {
304 >        else if (rayorigin(&sr, REFLECTED, r, sctmp) == 0) {
305                  VSUM(sr.rdir, r->rdir, nd.pnorm, 2.*nd.pdot);
306                  checknorm(sr.rdir);
307                  rayvalue(&sr);
308 <                multcolor(sr.rcol, sr.rcoef);
309 <                copycolor(r->mcol, sr.rcol);
310 <                addcolor(r->rcol, sr.rcol);
308 >                smultscolor(sr.rcol, sr.rcoef);
309 >                copyscolor(r->mcol, sr.rcol);
310 >                saddscolor(r->rcol, sr.rcol);
311                  r->rmt = r->rot;
312                  if (r->ro != NULL && isflat(r->ro->otype) &&
313                                  !hastexture | (r->crtype & AMBIENT))
# Line 315 | Line 317 | m_brdf(                        /* color a ray that hit a BRDTfunc material
317          if (hasrefl) {
318                  if (!hitfront)
319                          flipsurface(r);
320 <                copycolor(ctmp, nd.rdiff);
321 <                multambient(ctmp, r, nd.pnorm);
322 <                addcolor(r->rcol, ctmp);        /* add to returned color */
320 >                copyscolor(sctmp, nd.rdiff);
321 >                multambient(sctmp, r, nd.pnorm);
322 >                saddscolor(r->rcol, sctmp);     /* add to returned color */
323                  if (!hitfront)
324                          flipsurface(r);
325          }
# Line 327 | Line 329 | m_brdf(                        /* color a ray that hit a BRDTfunc material
329                  vtmp[0] = -nd.pnorm[0];
330                  vtmp[1] = -nd.pnorm[1];
331                  vtmp[2] = -nd.pnorm[2];
332 <                copycolor(ctmp, nd.tdiff);
333 <                multambient(ctmp, r, vtmp);
334 <                addcolor(r->rcol, ctmp);
332 >                copyscolor(sctmp, nd.tdiff);
333 >                multambient(sctmp, r, vtmp);
334 >                saddscolor(r->rcol, sctmp);
335                  if (hitfront)
336                          flipsurface(r);
337          }
# Line 348 | Line 350 | m_brdf2(                       /* color a ray that hit a BRDF material */
350   )
351   {
352          BRDFDAT  nd;
353 <        COLOR  ctmp;
353 >        SCOLOR  sctmp;
354          FVECT  vtmp;
355          double  dtmp;
356                                                  /* always a shadow */
# Line 372 | Line 374 | m_brdf2(                       /* color a ray that hit a BRDF material */
374          nd.mp = m;
375          nd.pr = r;
376                                                  /* get material color */
377 <        setcolor(nd.mcolor, m->oargs.farg[0],
377 >        setscolor(nd.mcolor, m->oargs.farg[0],
378                          m->oargs.farg[1],
379                          m->oargs.farg[2]);
380                                                  /* get specular component */
# Line 382 | Line 384 | m_brdf2(                       /* color a ray that hit a BRDF material */
384                  nd.trans = m->oargs.farg[4]*(1.0 - nd.rspec);
385                  nd.tspec = nd.trans * m->oargs.farg[5];
386                  dtmp = nd.trans - nd.tspec;
387 <                setcolor(nd.tdiff, dtmp, dtmp, dtmp);
387 >                setscolor(nd.tdiff, dtmp, dtmp, dtmp);
388          } else {
389                  nd.tspec = nd.trans = 0.0;
390 <                setcolor(nd.tdiff, 0.0, 0.0, 0.0);
390 >                scolorblack(nd.tdiff);
391          }
392                                                  /* compute reflectance */
393          dtmp = 1.0 - nd.trans - nd.rspec;
394 <        setcolor(nd.rdiff, dtmp, dtmp, dtmp);
394 >        setscolor(nd.rdiff, dtmp, dtmp, dtmp);
395          nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
396 <        multcolor(nd.mcolor, r->pcol);          /* modify material color */
397 <        multcolor(nd.rdiff, nd.mcolor);
398 <        multcolor(nd.tdiff, nd.mcolor);
396 >        smultscolor(nd.mcolor, r->pcol);        /* modify material color */
397 >        smultscolor(nd.rdiff, nd.mcolor);
398 >        smultscolor(nd.tdiff, nd.mcolor);
399                                                  /* load auxiliary files */
400          if (hasdata(m->otype)) {
401                  nd.dp = getdata(m->oargs.sarg[1]);
# Line 404 | Line 406 | m_brdf2(                       /* color a ray that hit a BRDF material */
406          }
407                                                  /* compute ambient */
408          if (nd.trans < 1.0-FTINY) {
409 <                copycolor(ctmp, nd.mcolor);     /* modified by material color */
410 <                scalecolor(ctmp, 1.0-nd.trans);
411 <                multambient(ctmp, r, nd.pnorm);
412 <                addcolor(r->rcol, ctmp);        /* add to returned color */
409 >                copyscolor(sctmp, nd.mcolor);   /* modified by material color */
410 >                scalescolor(sctmp, 1.0-nd.trans);
411 >                multambient(sctmp, r, nd.pnorm);
412 >                saddscolor(r->rcol, sctmp);     /* add to returned color */
413          }
414          if (nd.trans > FTINY) {                 /* from other side */
415                  flipsurface(r);
416                  vtmp[0] = -nd.pnorm[0];
417                  vtmp[1] = -nd.pnorm[1];
418                  vtmp[2] = -nd.pnorm[2];
419 <                copycolor(ctmp, nd.mcolor);
420 <                scalecolor(ctmp, nd.trans);
421 <                multambient(ctmp, r, vtmp);
422 <                addcolor(r->rcol, ctmp);
419 >                copyscolor(sctmp, nd.mcolor);
420 >                scalescolor(sctmp, nd.trans);
421 >                multambient(sctmp, r, vtmp);
422 >                saddscolor(r->rcol, sctmp);
423                  flipsurface(r);
424          }
425                                                  /* add direct component */
# Line 433 | Line 435 | setbrdfunc(                    /* set up brdf function and variables */
435   )
436   {
437          FVECT  vec;
438 +        COLOR  ctmp;
439  
440          if (setfunc(np->mp, np->pr) == 0)
441                  return(0);      /* it's OK, setfunc says we're done */
# Line 443 | Line 446 | setbrdfunc(                    /* set up brdf function and variables */
446          varset("NzP`", '=', vec[2]/funcxf.sca);
447          varset("RdotP`", '=', np->pdot <= -1.0 ? -1.0 :
448                          np->pdot >= 1.0 ? 1.0 : np->pdot);
449 <        varset("CrP", '=', colval(np->mcolor,RED));
450 <        varset("CgP", '=', colval(np->mcolor,GRN));
451 <        varset("CbP", '=', colval(np->mcolor,BLU));
449 >        scolor_color(ctmp, np->mcolor);         /* should use scolor_rgb()? */
450 >        varset("CrP", '=', colval(ctmp,RED));
451 >        varset("CgP", '=', colval(ctmp,GRN));
452 >        varset("CbP", '=', colval(ctmp,BLU));
453          return(1);
454   }

Diff Legend

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