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.22 by greg, Thu Sep 9 15:40:02 2004 UTC vs.
Revision 2.33 by greg, Wed Sep 2 18:59:01 2015 UTC

# Line 14 | Line 14 | static const char      RCSid[] = "$Id$";
14   #include  "otypes.h"
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 38 | Line 39 | static const char      RCSid[] = "$Id$";
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 77 | Line 78 | typedef struct {
78   }  BRDFDAT;             /* BRDF material data */
79  
80  
81 < static srcdirf_t dirbrdf;
81 < static int setbrdfunc(BRDFDAT  *np);
81 > static int setbrdfunc(BRDFDAT *np);
82  
83  
84   static void
# Line 89 | Line 89 | dirbrdf(               /* compute source contribution */
89          double  omega                   /* light source size */
90   )
91   {
92 <        register BRDFDAT *np = nnp;
92 >        BRDFDAT *np = nnp;
93          double  ldot;
94          double  dtmp;
95          COLOR  ctmp;
96          FVECT  ldx;
97          static double  vldx[5], pt[MAXDIM];
98 <        register char   **sa;
99 <        register int    i;
98 >        char    **sa;
99 >        int     i;
100   #define lddx (vldx+1)
101  
102          setcolor(cval, 0.0, 0.0, 0.0);
# Line 128 | Line 128 | dirbrdf(               /* compute source contribution */
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 141 | Line 142 | dirbrdf(               /* compute source contribution */
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], 4, lddx);
149 <                if (!strcmp(sa[7],sa[6]))
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], 4, lddx);
155 <                if (!strcmp(sa[8],sa[6]))
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);
# Line 166 | Line 171 | dirbrdf(               /* compute source contribution */
171                  dtmp = funvalue(sa[0], 5, vldx);
172                  setcolor(ctmp, dtmp, dtmp, dtmp);
173          }
174 <        if (errno == EDOM || errno == ERANGE) {
174 >        if ((errno == EDOM) | (errno == ERANGE)) {
175                  objerror(np->mp, WARNING, "compute error");
176                  return;
177          }
# Line 195 | Line 200 | dirbrdf(               /* compute source contribution */
200   }
201  
202  
203 < extern int
203 > int
204   m_brdf(                 /* color a ray that hit a BRDTfunc material */
205 <        register OBJREC  *m,
206 <        register RAY  *r
205 >        OBJREC  *m,
206 >        RAY  *r
207   )
208   {
209          int  hitfront = 1;
210          BRDFDAT  nd;
211          RAY  sr;
212          double  mirtest=0, mirdist=0;
213 <        double  transtest, transdist;
213 >        double  transtest=0, transdist=0;
214          int  hasrefl, hastrans;
215          int  hastexture;
216          COLOR  ctmp;
217          FVECT  vtmp;
218          double  d;
219 <        register MFUNC  *mf;
220 <        register int  i;
219 >        MFUNC  *mf;
220 >        int  i;
221                                                  /* check arguments */
222          if ((m->oargs.nsargs < 10) | (m->oargs.nfargs < 9))
223                  objerror(m, USER, "bad # arguments");
# Line 265 | Line 270 | m_brdf(                        /* color a ray that hit a BRDTfunc material
270          setcolor(ctmp, evalue(mf->ep[3]),
271                          evalue(mf->ep[4]),
272                          evalue(mf->ep[5]));
273 <        if (errno == EDOM || errno == ERANGE)
273 >        if ((errno == EDOM) | (errno == ERANGE))
274                  objerror(m, WARNING, "compute error");
275 <        else if (rayorigin(&sr, r, TRANS, bright(ctmp)) == 0) {
275 >        else if (rayorigin(&sr, TRANS, r, ctmp) == 0) {
276                  if (!(r->crtype & SHADOW) && hastexture) {
277 <                        for (i = 0; i < 3; i++) /* perturb direction */
278 <                                sr.rdir[i] = r->rdir[i] - .75*r->pert[i];
277 >                                                /* perturb direction */
278 >                        VSUM(sr.rdir, r->rdir, r->pert, -.75);
279                          if (normalize(sr.rdir) == 0.0) {
280                                  objerror(m, WARNING, "illegal perturbation");
281                                  VCOPY(sr.rdir, r->rdir);
# Line 279 | 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, ctmp);
287 >                multcolor(sr.rcol, sr.rcoef);
288                  addcolor(r->rcol, sr.rcol);
289                  if (!hastexture) {
290                          transtest = 2.0*bright(sr.rcol);
# Line 294 | Line 299 | m_brdf(                        /* color a ray that hit a BRDTfunc material
299          setcolor(ctmp, evalue(mf->ep[0]),
300                          evalue(mf->ep[1]),
301                          evalue(mf->ep[2]));
302 <        if (errno == EDOM || errno == ERANGE)
302 >        if ((errno == EDOM) | (errno == ERANGE))
303                  objerror(m, WARNING, "compute error");
304 <        else if (rayorigin(&sr, r, REFLECTED, bright(ctmp)) == 0) {
305 <                for (i = 0; i < 3; i++)
306 <                        sr.rdir[i] = r->rdir[i] + 2.0*nd.pdot*nd.pnorm[i];
304 >        else if (rayorigin(&sr, REFLECTED, r, ctmp) == 0) {
305 >                VSUM(sr.rdir, r->rdir, nd.pnorm, 2.*nd.pdot);
306 >                checknorm(sr.rdir);
307                  rayvalue(&sr);
308 <                multcolor(sr.rcol, ctmp);
308 >                multcolor(sr.rcol, sr.rcoef);
309                  addcolor(r->rcol, sr.rcol);
310                  if (!hastexture && r->ro != NULL && isflat(r->ro->otype)) {
311                          mirtest = 2.0*bright(sr.rcol);
# Line 311 | Line 316 | m_brdf(                        /* color a ray that hit a BRDTfunc material
316          if (hasrefl) {
317                  if (!hitfront)
318                          flipsurface(r);
319 <                ambient(ctmp, r, nd.pnorm);
320 <                multcolor(ctmp, nd.rdiff);
319 >                copycolor(ctmp, nd.rdiff);
320 >                multambient(ctmp, r, nd.pnorm);
321                  addcolor(r->rcol, ctmp);        /* add to returned color */
322                  if (!hitfront)
323                          flipsurface(r);
# Line 323 | Line 328 | m_brdf(                        /* color a ray that hit a BRDTfunc material
328                  vtmp[0] = -nd.pnorm[0];
329                  vtmp[1] = -nd.pnorm[1];
330                  vtmp[2] = -nd.pnorm[2];
331 <                ambient(ctmp, r, vtmp);
332 <                multcolor(ctmp, nd.tdiff);
331 >                copycolor(ctmp, nd.tdiff);
332 >                multambient(ctmp, r, vtmp);
333                  addcolor(r->rcol, ctmp);
334                  if (hitfront)
335                          flipsurface(r);
# Line 343 | Line 348 | m_brdf(                        /* color a ray that hit a BRDTfunc material
348  
349  
350  
351 < extern int
351 > int
352   m_brdf2(                        /* color a ray that hit a BRDF material */
353 <        register OBJREC  *m,
354 <        register RAY  *r
353 >        OBJREC  *m,
354 >        RAY  *r
355   )
356   {
357          BRDFDAT  nd;
# Line 362 | Line 367 | m_brdf2(                       /* color a ray that hit a BRDF material */
367                  objerror(m, USER, "bad # arguments");
368                                                  /* check for back side */
369          if (r->rod < 0.0) {
370 <                if (!backvis && m->otype != MAT_TFUNC
366 <                                && m->otype != MAT_TDATA) {
370 >                if (!backvis) {
371                          raytrans(r);
372                          return(1);
373                  }
# Line 407 | Line 411 | m_brdf2(                       /* color a ray that hit a BRDF material */
411          }
412                                                  /* compute ambient */
413          if (nd.trans < 1.0-FTINY) {
414 <                ambient(ctmp, r, nd.pnorm);
414 >                copycolor(ctmp, nd.mcolor);     /* modified by material color */
415                  scalecolor(ctmp, 1.0-nd.trans);
416 <                multcolor(ctmp, nd.mcolor);     /* modified by material color */
416 >                multambient(ctmp, r, nd.pnorm);
417                  addcolor(r->rcol, ctmp);        /* add to returned color */
418          }
419          if (nd.trans > FTINY) {         /* from other side */
# Line 417 | Line 421 | m_brdf2(                       /* color a ray that hit a BRDF material */
421                  vtmp[0] = -nd.pnorm[0];
422                  vtmp[1] = -nd.pnorm[1];
423                  vtmp[2] = -nd.pnorm[2];
424 <                ambient(ctmp, r, vtmp);
424 >                copycolor(ctmp, nd.mcolor);
425                  scalecolor(ctmp, nd.trans);
426 <                multcolor(ctmp, nd.mcolor);
426 >                multambient(ctmp, r, vtmp);
427                  addcolor(r->rcol, ctmp);
428                  flipsurface(r);
429          }
# Line 432 | Line 436 | m_brdf2(                       /* color a ray that hit a BRDF material */
436  
437   static int
438   setbrdfunc(                     /* set up brdf function and variables */
439 <        register BRDFDAT  *np
439 >        BRDFDAT  *np
440   )
441   {
442          FVECT  vec;

Diff Legend

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