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.8 by greg, Tue Aug 24 12:59:25 1993 UTC vs.
Revision 2.38 by greg, Wed Feb 13 02:38:26 2019 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1991 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   *  Shading for materials with arbitrary BRDF's
6   */
7  
8 < #include  "ray.h"
8 > #include "copyright.h"
9  
10 + #include  "ray.h"
11 + #include  "ambient.h"
12   #include  "data.h"
13 <
13 > #include  "source.h"
14   #include  "otypes.h"
15 <
15 > #include  "rtotypes.h"
16   #include  "func.h"
17 + #include  "pmapmat.h"
18  
19   /*
20   *      Arguments to this material include the color and specularity.
# Line 39 | Line 39 | static char SCCSid[] = "$SunId$ LBL";
39   *  Arguments for MAT_TFUNC are:
40   *      2+      func    funcfile        transform
41   *      0
42 < *      4+      red     grn     blu     rspec   trans   tspec   A7 ..
42 > *      6+      red     grn     blu     rspec   trans   tspec   A7 ..
43   *
44   *  Arguments for MAT_TDATA are:
45   *      4+      func    datafile        funcfile        v0 ..   transform
46   *      0
47 < *      4+      red     grn     blu     rspec   trans   tspec   A7 ..
47 > *      6+      red     grn     blu     rspec   trans   tspec   A7 ..
48   *
49   *  Arguments for the more general MAT_BRTDF are:
50   *      10+     rrefl   grefl   brefl
# Line 78 | Line 78 | typedef struct {
78   }  BRDFDAT;             /* BRDF material data */
79  
80  
81 < dirbrdf(cval, np, ldir, omega)          /* compute source contribution */
82 < COLOR  cval;                    /* returned coefficient */
83 < register BRDFDAT  *np;          /* material data */
84 < FVECT  ldir;                    /* light source direction */
85 < double  omega;                  /* light source size */
81 > static int setbrdfunc(BRDFDAT *np);
82 >
83 >
84 > static void
85 > dirbrdf(                /* compute source contribution */
86 >        COLOR  cval,                    /* returned coefficient */
87 >        void  *nnp,             /* material data */
88 >        FVECT  ldir,                    /* light source direction */
89 >        double  omega                   /* light source size */
90 > )
91   {
92 +        BRDFDAT *np = nnp;
93          double  ldot;
94          double  dtmp;
95          COLOR  ctmp;
96          FVECT  ldx;
97 <        double  lddx[3], pt[MAXDIM];
98 <        double  vldx[4];
99 <        register char   **sa;
100 <        register int    i;
97 >        static double  vldx[5], pt[MAXDIM];
98 >        char    **sa;
99 >        int     i;
100 > #define lddx (vldx+1)
101  
102          setcolor(cval, 0.0, 0.0, 0.0);
103          
# Line 122 | Line 128 | double  omega;                 /* light source size */
128                  scalecolor(ctmp, dtmp);
129                  addcolor(cval, ctmp);
130          }
131 <        if (ldot > 0.0 ? np->rspec <= FTINY : np->tspec <= FTINY)
132 <                return;         /* no specular component */
131 >        if ((ldot > 0.0 ? np->rspec <= FTINY : np->tspec <= FTINY) ||
132 >                        ambRayInPmap(np->pr))
133 >                return;         /* diffuse only */
134                                          /* set up function */
135          setbrdfunc(np);
136          sa = np->mp->oargs.sarg;
# Line 132 | Line 139 | double  omega;                 /* light source size */
139          multv3(ldx, ldir, funcxf.xfm);
140          for (i = 0; i < 3; i++)
141                  lddx[i] = ldx[i]/funcxf.sca;
142 +        lddx[3] = omega;
143                                          /* compute BRTDF */
144          if (np->mp->otype == MAT_BRTDF) {
145 <                if (sa[6][0] == '0')            /* special case */
145 >                if (sa[6][0] == '0' && !sa[6][1])       /* special case */
146                          colval(ctmp,RED) = 0.0;
147                  else
148 <                        colval(ctmp,RED) = funvalue(sa[6], 3, lddx);
149 <                if (!strcmp(sa[7],sa[6]))
148 >                        colval(ctmp,RED) = funvalue(sa[6], 4, lddx);
149 >                if (sa[7][0] == '0' && !sa[7][1])
150 >                        colval(ctmp,GRN) = 0.0;
151 >                else if (!strcmp(sa[7],sa[6]))
152                          colval(ctmp,GRN) = colval(ctmp,RED);
153                  else
154 <                        colval(ctmp,GRN) = funvalue(sa[7], 3, lddx);
155 <                if (!strcmp(sa[8],sa[6]))
154 >                        colval(ctmp,GRN) = funvalue(sa[7], 4, lddx);
155 >                if (sa[8][0] == '0' && !sa[8][1])
156 >                        colval(ctmp,BLU) = 0.0;
157 >                else if (!strcmp(sa[8],sa[6]))
158                          colval(ctmp,BLU) = colval(ctmp,RED);
159                  else if (!strcmp(sa[8],sa[7]))
160                          colval(ctmp,BLU) = colval(ctmp,GRN);
161                  else
162 <                        colval(ctmp,BLU) = funvalue(sa[8], 3, lddx);
162 >                        colval(ctmp,BLU) = funvalue(sa[8], 4, lddx);
163                  dtmp = bright(ctmp);
164          } else if (np->dp == NULL) {
165 <                dtmp = funvalue(sa[0], 3, lddx);
165 >                dtmp = funvalue(sa[0], 4, lddx);
166                  setcolor(ctmp, dtmp, dtmp, dtmp);
167          } else {
168                  for (i = 0; i < np->dp->nd; i++)
169 <                        pt[i] = funvalue(sa[3+i], 3, lddx);
169 >                        pt[i] = funvalue(sa[3+i], 4, lddx);
170                  vldx[0] = datavalue(np->dp, pt);
171 <                vldx[1] = lddx[0]; vldx[2] = lddx[1]; vldx[3] = lddx[2];
160 <                dtmp = funvalue(sa[0], 4, vldx);
171 >                dtmp = funvalue(sa[0], 5, vldx);
172                  setcolor(ctmp, dtmp, dtmp, dtmp);
173          }
174 <        if (errno) {
174 >        if ((errno == EDOM) | (errno == ERANGE)) {
175                  objerror(np->mp, WARNING, "compute error");
176                  return;
177          }
# Line 170 | Line 181 | double  omega;                 /* light source size */
181                  /*
182                   *  Compute reflected non-diffuse component.
183                   */
184 <                if (np->mp->otype == MAT_MFUNC | np->mp->otype == MAT_MDATA)
184 >                if ((np->mp->otype == MAT_MFUNC) | (np->mp->otype == MAT_MDATA))
185                          multcolor(ctmp, np->mcolor);
186                  dtmp = ldot * omega * np->rspec;
187                  scalecolor(ctmp, dtmp);
# Line 179 | Line 190 | double  omega;                 /* light source size */
190                  /*
191                   *  Compute transmitted non-diffuse component.
192                   */
193 <                if (np->mp->otype == MAT_TFUNC | np->mp->otype == MAT_TDATA)
193 >                if ((np->mp->otype == MAT_TFUNC) | (np->mp->otype == MAT_TDATA))
194                          multcolor(ctmp, np->mcolor);
195                  dtmp = -ldot * omega * np->tspec;
196                  scalecolor(ctmp, dtmp);
197                  addcolor(cval, ctmp);
198          }
199 + #undef lddx
200   }
201  
202  
203 < m_brdf(m, r)                    /* color a ray which hit a BRDTF material */
204 < register OBJREC  *m;
205 < register RAY  *r;
203 > int
204 > m_brdf(                 /* color a ray that hit a BRDTfunc material */
205 >        OBJREC  *m,
206 >        RAY  *r
207 > )
208   {
209 +        int  hitfront = 1;
210          BRDFDAT  nd;
211          RAY  sr;
197 –        double  transtest, transdist;
212          int  hasrefl, hastrans;
213 +        int  hastexture;
214          COLOR  ctmp;
215 <        double  dtmp;
216 <        register MFUNC  *mf;
217 <        register int  i;
215 >        FVECT  vtmp;
216 >        double  d;
217 >        MFUNC  *mf;
218 >        int  i;
219                                                  /* check arguments */
220 <        if (m->oargs.nsargs < 10 | m->oargs.nfargs < 9)
220 >        if ((m->oargs.nsargs < 10) | (m->oargs.nfargs < 9))
221                  objerror(m, USER, "bad # arguments");
222          nd.mp = m;
223          nd.pr = r;
# Line 221 | Line 237 | register RAY  *r;
237          setcolor(nd.tdiff, m->oargs.farg[6],
238                          m->oargs.farg[7],
239                          m->oargs.farg[8]);
240 <                                        /* get modifiers */
240 >                                                /* get modifiers */
241          raytexture(r, m->omod);
242 <        nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
242 >        hastexture = (DOT(r->pert,r->pert) > FTINY*FTINY);
243 >        if (hastexture) {                       /* perturb normal */
244 >                nd.pdot = raynormal(nd.pnorm, r);
245 >        } else {
246 >                VCOPY(nd.pnorm, r->ron);
247 >                nd.pdot = r->rod;
248 >        }
249          if (r->rod < 0.0) {                     /* orient perturbed values */
250                  nd.pdot = -nd.pdot;
251                  for (i = 0; i < 3; i++) {
252                          nd.pnorm[i] = -nd.pnorm[i];
253                          r->pert[i] = -r->pert[i];
254                  }
255 +                hitfront = 0;
256          }
257          copycolor(nd.mcolor, r->pcol);          /* get pattern color */
258          multcolor(nd.rdiff, nd.mcolor);         /* modify diffuse values */
259          multcolor(nd.tdiff, nd.mcolor);
260 <        hasrefl = bright(nd.rdiff) > FTINY;
261 <        hastrans = bright(nd.tdiff) > FTINY;
260 >        hasrefl = (bright(nd.rdiff) > FTINY);
261 >        hastrans = (bright(nd.tdiff) > FTINY);
262                                                  /* load cal file */
263          nd.dp = NULL;
264          mf = getfunc(m, 9, 0x3f, 0);
265                                                  /* compute transmitted ray */
266          setbrdfunc(&nd);
244 –        transtest = 0;
245 –        transdist = r->rot;
267          errno = 0;
268          setcolor(ctmp, evalue(mf->ep[3]),
269                          evalue(mf->ep[4]),
270                          evalue(mf->ep[5]));
271 <        if (errno)
271 >        if ((errno == EDOM) | (errno == ERANGE))
272                  objerror(m, WARNING, "compute error");
273 <        else if (rayorigin(&sr, r, TRANS, bright(ctmp)) == 0) {
274 <                if (!(r->crtype & SHADOW) &&
275 <                                DOT(r->pert,r->pert) > FTINY*FTINY) {
276 <                        for (i = 0; i < 3; i++) /* perturb direction */
256 <                                sr.rdir[i] = r->rdir[i] - .75*r->pert[i];
273 >        else if (rayorigin(&sr, TRANS, r, ctmp) == 0) {
274 >                if (hastexture && !(r->crtype & (SHADOW|AMBIENT))) {
275 >                                                /* perturb direction */
276 >                        VSUB(sr.rdir, r->rdir, r->pert);
277                          if (normalize(sr.rdir) == 0.0) {
278                                  objerror(m, WARNING, "illegal perturbation");
279                                  VCOPY(sr.rdir, r->rdir);
280                          }
281                  } else {
282                          VCOPY(sr.rdir, r->rdir);
263 –                        transtest = 2;
283                  }
284                  rayvalue(&sr);
285 <                multcolor(sr.rcol, ctmp);
285 >                multcolor(sr.rcol, sr.rcoef);
286                  addcolor(r->rcol, sr.rcol);
287 <                transtest *= bright(sr.rcol);
288 <                transdist = r->rot + sr.rt;
287 >                if ((!hastexture || r->crtype & (SHADOW|AMBIENT)) &&
288 >                                nd.tspec > bright(nd.tdiff) + bright(nd.rdiff))
289 >                        r->rxt = r->rot + raydistance(&sr);
290          }
291          if (r->crtype & SHADOW)                 /* the rest is shadow */
292 <                return;
292 >                return(1);
293 >
294                                                  /* compute reflected ray */
295          setbrdfunc(&nd);
296          errno = 0;
297          setcolor(ctmp, evalue(mf->ep[0]),
298                          evalue(mf->ep[1]),
299                          evalue(mf->ep[2]));
300 <        if (errno)
300 >        if ((errno == EDOM) | (errno == ERANGE))
301                  objerror(m, WARNING, "compute error");
302 <        else if (rayorigin(&sr, r, REFLECTED, bright(ctmp)) == 0) {
303 <                for (i = 0; i < 3; i++)
304 <                        sr.rdir[i] = r->rdir[i] + 2.0*nd.pdot*nd.pnorm[i];
302 >        else if (rayorigin(&sr, REFLECTED, r, ctmp) == 0) {
303 >                VSUM(sr.rdir, r->rdir, nd.pnorm, 2.*nd.pdot);
304 >                checknorm(sr.rdir);
305                  rayvalue(&sr);
306 <                multcolor(sr.rcol, ctmp);
306 >                multcolor(sr.rcol, sr.rcoef);
307 >                copycolor(r->mcol, sr.rcol);
308                  addcolor(r->rcol, sr.rcol);
309 +                if (r->ro != NULL && isflat(r->ro->otype) &&
310 +                                !hastexture | (r->crtype & AMBIENT))
311 +                        r->rmt = r->rot + raydistance(&sr);
312          }
313                                                  /* compute ambient */
314          if (hasrefl) {
315 <                if (nd.pdot < 0.0)
315 >                if (!hitfront)
316                          flipsurface(r);
317 <                ambient(ctmp, r);
318 <                multcolor(ctmp, nd.rdiff);
317 >                copycolor(ctmp, nd.rdiff);
318 >                multambient(ctmp, r, nd.pnorm);
319                  addcolor(r->rcol, ctmp);        /* add to returned color */
320 <                if (nd.pdot < 0.0)
320 >                if (!hitfront)
321                          flipsurface(r);
322          }
323          if (hastrans) {                         /* from other side */
324 <                if (nd.pdot > 0.0)
324 >                if (hitfront)
325                          flipsurface(r);
326 <                ambient(ctmp, r);
327 <                multcolor(ctmp, nd.tdiff);
326 >                vtmp[0] = -nd.pnorm[0];
327 >                vtmp[1] = -nd.pnorm[1];
328 >                vtmp[2] = -nd.pnorm[2];
329 >                copycolor(ctmp, nd.tdiff);
330 >                multambient(ctmp, r, vtmp);
331                  addcolor(r->rcol, ctmp);
332 <                if (nd.pdot > 0.0)
332 >                if (hitfront)
333                          flipsurface(r);
334          }
335          if (hasrefl | hastrans || m->oargs.sarg[6][0] != '0')
336                  direct(r, dirbrdf, &nd);        /* add direct component */
337 <                                                /* check distance */
338 <        if (transtest > bright(r->rcol))
311 <                r->rt = transdist;
337 >
338 >        return(1);
339   }
340  
341  
342  
343 < m_brdf2(m, r)                   /* color a ray which hit a BRDF material */
344 < register OBJREC  *m;
345 < register RAY  *r;
343 > int
344 > m_brdf2(                        /* color a ray that hit a BRDF material */
345 >        OBJREC  *m,
346 >        RAY  *r
347 > )
348   {
349          BRDFDAT  nd;
350          COLOR  ctmp;
351 +        FVECT  vtmp;
352          double  dtmp;
353                                                  /* always a shadow */
354          if (r->crtype & SHADOW)
355 <                return;
355 >                return(1);
356                                                  /* check arguments */
357 <        if (m->oargs.nsargs < (hasdata(m->otype)?4:2) | m->oargs.nfargs <
358 <                        (m->otype==MAT_TFUNC|m->otype==MAT_TDATA?6:4))
357 >        if ((m->oargs.nsargs < (hasdata(m->otype)?4:2)) | (m->oargs.nfargs <
358 >                        ((m->otype==MAT_TFUNC)|(m->otype==MAT_TDATA)?6:4)))
359                  objerror(m, USER, "bad # arguments");
360 +                                                /* check for back side */
361 +        if (r->rod < 0.0) {
362 +                if (!backvis) {
363 +                        raytrans(r);
364 +                        return(1);
365 +                }
366 +                raytexture(r, m->omod);
367 +                flipsurface(r);                 /* reorient if backvis */
368 +        } else
369 +                raytexture(r, m->omod);
370 +
371          nd.mp = m;
372          nd.pr = r;
373                                                  /* get material color */
# Line 336 | Line 377 | register RAY  *r;
377                                                  /* get specular component */
378          nd.rspec = m->oargs.farg[3];
379                                                  /* compute transmittance */
380 <        if (m->otype == MAT_TFUNC | m->otype == MAT_TDATA) {
380 >        if ((m->otype == MAT_TFUNC) | (m->otype == MAT_TDATA)) {
381                  nd.trans = m->oargs.farg[4]*(1.0 - nd.rspec);
382                  nd.tspec = nd.trans * m->oargs.farg[5];
383                  dtmp = nd.trans - nd.tspec;
# Line 348 | Line 389 | register RAY  *r;
389                                                  /* compute reflectance */
390          dtmp = 1.0 - nd.trans - nd.rspec;
391          setcolor(nd.rdiff, dtmp, dtmp, dtmp);
351 –                                                /* fix orientation */
352 –        if (r->rod < 0.0)
353 –                flipsurface(r);
354 –                                                /* get modifiers */
355 –        raytexture(r, m->omod);
392          nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
393          multcolor(nd.mcolor, r->pcol);          /* modify material color */
394          multcolor(nd.rdiff, nd.mcolor);
# Line 367 | Line 403 | register RAY  *r;
403          }
404                                                  /* compute ambient */
405          if (nd.trans < 1.0-FTINY) {
406 <                ambient(ctmp, r);
406 >                copycolor(ctmp, nd.mcolor);     /* modified by material color */
407                  scalecolor(ctmp, 1.0-nd.trans);
408 <                multcolor(ctmp, nd.mcolor);     /* modified by material color */
408 >                multambient(ctmp, r, nd.pnorm);
409                  addcolor(r->rcol, ctmp);        /* add to returned color */
410          }
411 <        if (nd.trans > FTINY) {         /* from other side */
411 >        if (nd.trans > FTINY) {                 /* from other side */
412                  flipsurface(r);
413 <                ambient(ctmp, r);
413 >                vtmp[0] = -nd.pnorm[0];
414 >                vtmp[1] = -nd.pnorm[1];
415 >                vtmp[2] = -nd.pnorm[2];
416 >                copycolor(ctmp, nd.mcolor);
417                  scalecolor(ctmp, nd.trans);
418 <                multcolor(ctmp, nd.mcolor);
418 >                multambient(ctmp, r, vtmp);
419                  addcolor(r->rcol, ctmp);
420                  flipsurface(r);
421          }
422                                                  /* add direct component */
423          direct(r, dirbrdf, &nd);
424 +
425 +        return(1);
426   }
427  
428  
429 < setbrdfunc(np)                  /* set up brdf function and variables */
430 < register BRDFDAT  *np;
429 > static int
430 > setbrdfunc(                     /* set up brdf function and variables */
431 >        BRDFDAT  *np
432 > )
433   {
434          FVECT  vec;
435  
# Line 394 | Line 437 | register BRDFDAT  *np;
437                  return(0);      /* it's OK, setfunc says we're done */
438                                  /* else (re)assign special variables */
439          multv3(vec, np->pnorm, funcxf.xfm);
440 <        varset("NxP", '=', vec[0]/funcxf.sca);
441 <        varset("NyP", '=', vec[1]/funcxf.sca);
442 <        varset("NzP", '=', vec[2]/funcxf.sca);
443 <        varset("RdotP", '=', np->pdot <= -1.0 ? -1.0 :
440 >        varset("NxP`", '=', vec[0]/funcxf.sca);
441 >        varset("NyP`", '=', vec[1]/funcxf.sca);
442 >        varset("NzP`", '=', vec[2]/funcxf.sca);
443 >        varset("RdotP`", '=', np->pdot <= -1.0 ? -1.0 :
444                          np->pdot >= 1.0 ? 1.0 : np->pdot);
445          varset("CrP", '=', colval(np->mcolor,RED));
446          varset("CgP", '=', colval(np->mcolor,GRN));

Diff Legend

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