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 1.13 by greg, Wed Jul 10 09:35:26 1991 UTC vs.
Revision 2.10 by greg, Wed Jan 12 16:46:35 1994 UTC

# Line 14 | Line 14 | static char SCCSid[] = "$SunId$ LBL";
14  
15   #include  "otypes.h"
16  
17 + #include  "func.h"
18 +
19   /*
20   *      Arguments to this material include the color and specularity.
21   *  String arguments include the reflection function and files.
22   *  The BRDF is currently used just for the specular component to light
23   *  sources.  Reflectance values or data coordinates are functions
24 < *  of the direction to the light source.
24 > *  of the direction to the light source.  (Data modification functions
25 > *  are passed the source direction as args 2-4.)
26   *      We orient the surface towards the incoming ray, so a single
27   *  surface can be used to represent an infinitely thin object.
28   *
# Line 49 | Line 52 | static char SCCSid[] = "$SunId$ LBL";
52   *              rbrtd   gbrtd   bbrtd
53   *              funcfile        transform
54   *      0
55 < *      6+      red     grn     blu     rspec   trans   tspec   A7 ..
55 > *      9+      rdf     gdf     bdf
56 > *              rdb     gdb     bdb
57 > *              rdt     gdt     bdt     A10 ..
58   *
59   *      In addition to the normal variables available to functions,
60   *  we define the following:
61   *              NxP, NyP, NzP -         perturbed surface normal
62   *              RdotP -                 perturbed ray dot product
63 < *              CrP, CgP, CbP -         perturbed material color
63 > *              CrP, CgP, CbP -         perturbed material color (or pattern)
64   */
65  
61 extern double   funvalue(), varvalue();
62 extern XF  funcxf;
63
66   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;          /* color of this material */
71 <        double  rspec;          /* specular reflection */
72 <        double  rdiff;          /* diffuse reflection */
73 <        double  trans;          /* transmissivity */
74 <        double  tspec;          /* specular transmission */
75 <        double  tdiff;          /* diffuse transmission */
70 >        COLOR  mcolor;          /* material (or pattern) color */
71 >        COLOR  rdiff;           /* diffuse reflection */
72 >        COLOR  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) */
76          FVECT  pnorm;           /* perturbed surface normal */
77          double  pdot;           /* perturbed dot product */
78   }  BRDFDAT;             /* BRDF material data */
# Line 86 | Line 88 | double  omega;                 /* light source size */
88          double  dtmp;
89          COLOR  ctmp;
90          FVECT  ldx;
91 <        double  pt[MAXDIM];
91 >        double  lddx[3], pt[MAXDIM];
92 >        double  vldx[4];
93          register char   **sa;
94          register int    i;
95  
# Line 96 | Line 99 | double  omega;                 /* light source size */
99  
100          if (ldot <= FTINY && ldot >= -FTINY)
101                  return;         /* too close to grazing */
102 +
103          if (ldot < 0.0 ? np->trans <= FTINY : np->trans >= 1.0-FTINY)
104                  return;         /* wrong side */
105  
106 <        if (ldot > 0.0 && np->rdiff > FTINY) {
106 >        if (ldot > 0.0) {
107                  /*
108                   *  Compute and add diffuse reflected component to returned
109                   *  color.  The diffuse reflected component will always be
110                   *  modified by the color of the material.
111                   */
112 <                copycolor(ctmp, np->mcolor);
113 <                dtmp = ldot * omega * np->rdiff / PI;
112 >                copycolor(ctmp, np->rdiff);
113 >                dtmp = ldot * omega / PI;
114                  scalecolor(ctmp, dtmp);
115                  addcolor(cval, ctmp);
116 <        }
113 <        if (ldot < 0.0 && np->tdiff > FTINY) {
116 >        } else {
117                  /*
118                   *  Diffuse transmitted component.
119                   */
120 <                copycolor(ctmp, np->mcolor);
121 <                dtmp = -ldot * omega * np->tdiff / PI;
120 >                copycolor(ctmp, np->tdiff);
121 >                dtmp = -ldot * omega / PI;
122                  scalecolor(ctmp, dtmp);
123                  addcolor(cval, ctmp);
124          }
# Line 128 | Line 131 | double  omega;                 /* light source size */
131                                          /* transform light vector */
132          multv3(ldx, ldir, funcxf.xfm);
133          for (i = 0; i < 3; i++)
134 <                ldx[i] /= funcxf.sca;
134 >                lddx[i] = ldx[i]/funcxf.sca;
135                                          /* compute BRTDF */
136          if (np->mp->otype == MAT_BRTDF) {
137 <                colval(ctmp,RED) = funvalue(sa[6], 3, ldx);
137 >                if (sa[6][0] == '0')            /* special case */
138 >                        colval(ctmp,RED) = 0.0;
139 >                else
140 >                        colval(ctmp,RED) = funvalue(sa[6], 3, lddx);
141                  if (!strcmp(sa[7],sa[6]))
142                          colval(ctmp,GRN) = colval(ctmp,RED);
143                  else
144 <                        colval(ctmp,GRN) = funvalue(sa[7], 3, ldx);
144 >                        colval(ctmp,GRN) = funvalue(sa[7], 3, lddx);
145                  if (!strcmp(sa[8],sa[6]))
146                          colval(ctmp,BLU) = colval(ctmp,RED);
147                  else if (!strcmp(sa[8],sa[7]))
148                          colval(ctmp,BLU) = colval(ctmp,GRN);
149                  else
150 <                        colval(ctmp,BLU) = funvalue(sa[8], 3, ldx);
150 >                        colval(ctmp,BLU) = funvalue(sa[8], 3, lddx);
151                  dtmp = bright(ctmp);
152          } else if (np->dp == NULL) {
153 <                dtmp = funvalue(sa[0], 3, ldx);
153 >                dtmp = funvalue(sa[0], 3, lddx);
154                  setcolor(ctmp, dtmp, dtmp, dtmp);
155          } else {
156                  for (i = 0; i < np->dp->nd; i++)
157 <                        pt[i] = funvalue(sa[3+i], 3, ldx);
158 <                dtmp = datavalue(np->dp, pt);
159 <                dtmp = funvalue(sa[0], 1, &dtmp);
157 >                        pt[i] = funvalue(sa[3+i], 3, lddx);
158 >                vldx[0] = datavalue(np->dp, pt);
159 >                vldx[1] = lddx[0]; vldx[2] = lddx[1]; vldx[3] = lddx[2];
160 >                dtmp = funvalue(sa[0], 4, vldx);
161                  setcolor(ctmp, dtmp, dtmp, dtmp);
162          }
163 <        if (errno)
164 <                goto computerr;
163 >        if (errno) {
164 >                objerror(np->mp, WARNING, "compute error");
165 >                return;
166 >        }
167          if (dtmp <= FTINY)
168                  return;
169          if (ldot > 0.0) {
170                  /*
171                   *  Compute reflected non-diffuse component.
172                   */
173 <                if (np->mp->otype == MAT_MFUNC || np->mp->otype == MAT_MDATA)
173 >                if (np->mp->otype == MAT_MFUNC | np->mp->otype == MAT_MDATA)
174                          multcolor(ctmp, np->mcolor);
175                  dtmp = ldot * omega * np->rspec;
176                  scalecolor(ctmp, dtmp);
# Line 170 | Line 179 | double  omega;                 /* light source size */
179                  /*
180                   *  Compute transmitted non-diffuse component.
181                   */
182 <                if (np->mp->otype == MAT_TFUNC || np->mp->otype == MAT_TDATA)
182 >                if (np->mp->otype == MAT_TFUNC | np->mp->otype == MAT_TDATA)
183                          multcolor(ctmp, np->mcolor);
184                  dtmp = -ldot * omega * np->tspec;
185                  scalecolor(ctmp, dtmp);
186                  addcolor(cval, ctmp);
187          }
179        return;
180 computerr:
181        objerror(np->mp, WARNING, "compute error");
182        return;
188   }
189  
190  
191 < m_brdf(m, r)                    /* color a ray which hit a BRDF material */
191 > m_brdf(m, r)                    /* color a ray which hit a BRDTF material */
192   register OBJREC  *m;
193   register RAY  *r;
194   {
190        int  minsa, minfa;
195          BRDFDAT  nd;
196 +        RAY  sr;
197          double  transtest, transdist;
198 +        int  hasrefl, hastrans;
199          COLOR  ctmp;
200 <        double  dtmp, tspect, rspecr;
200 >        register MFUNC  *mf;
201          register int  i;
202                                                  /* check arguments */
203 <        switch (m->otype) {
204 <        case MAT_PFUNC: case MAT_MFUNC:
205 <                minsa = 2; minfa = 4; break;
206 <        case MAT_PDATA: case MAT_MDATA:
207 <                minsa = 4; minfa = 4; break;
208 <        case MAT_TFUNC:
209 <                minsa = 2; minfa = 6; break;
210 <        case MAT_TDATA:
211 <                minsa = 4; minfa = 6; break;
212 <        case MAT_BRTDF:
213 <                minsa = 10; minfa = 6; break;
203 >        if (m->oargs.nsargs < 10 | m->oargs.nfargs < 9)
204 >                objerror(m, USER, "bad # arguments");
205 >        nd.mp = m;
206 >        nd.pr = r;
207 >                                                /* dummy values */
208 >        nd.rspec = nd.tspec = 1.0;
209 >        nd.trans = 0.5;
210 >                                                /* diffuse reflectance */
211 >        if (r->rod > 0.0)
212 >                setcolor(nd.rdiff, m->oargs.farg[0],
213 >                                m->oargs.farg[1],
214 >                                m->oargs.farg[2]);
215 >        else
216 >                setcolor(nd.rdiff, m->oargs.farg[3],
217 >                                m->oargs.farg[4],
218 >                                m->oargs.farg[5]);
219 >                                                /* diffuse transmittance */
220 >        setcolor(nd.tdiff, m->oargs.farg[6],
221 >                        m->oargs.farg[7],
222 >                        m->oargs.farg[8]);
223 >                                        /* get modifiers */
224 >        raytexture(r, m->omod);
225 >        nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
226 >        if (r->rod < 0.0) {                     /* orient perturbed values */
227 >                nd.pdot = -nd.pdot;
228 >                for (i = 0; i < 3; i++) {
229 >                        nd.pnorm[i] = -nd.pnorm[i];
230 >                        r->pert[i] = -r->pert[i];
231 >                }
232          }
233 <        if (m->oargs.nsargs < minsa || m->oargs.nfargs < minfa)
233 >        copycolor(nd.mcolor, r->pcol);          /* get pattern color */
234 >        multcolor(nd.rdiff, nd.mcolor);         /* modify diffuse values */
235 >        multcolor(nd.tdiff, nd.mcolor);
236 >        hasrefl = bright(nd.rdiff) > FTINY;
237 >        hastrans = bright(nd.tdiff) > FTINY;
238 >                                                /* load cal file */
239 >        nd.dp = NULL;
240 >        mf = getfunc(m, 9, 0x3f, 0);
241 >                                                /* compute transmitted ray */
242 >        setbrdfunc(&nd);
243 >        transtest = 0;
244 >        transdist = r->rot;
245 >        errno = 0;
246 >        setcolor(ctmp, evalue(mf->ep[3]),
247 >                        evalue(mf->ep[4]),
248 >                        evalue(mf->ep[5]));
249 >        if (errno)
250 >                objerror(m, WARNING, "compute error");
251 >        else if (rayorigin(&sr, r, TRANS, bright(ctmp)) == 0) {
252 >                if (!(r->crtype & SHADOW) &&
253 >                                DOT(r->pert,r->pert) > FTINY*FTINY) {
254 >                        for (i = 0; i < 3; i++) /* perturb direction */
255 >                                sr.rdir[i] = r->rdir[i] - .75*r->pert[i];
256 >                        if (normalize(sr.rdir) == 0.0) {
257 >                                objerror(m, WARNING, "illegal perturbation");
258 >                                VCOPY(sr.rdir, r->rdir);
259 >                        }
260 >                } else {
261 >                        VCOPY(sr.rdir, r->rdir);
262 >                        transtest = 2;
263 >                }
264 >                rayvalue(&sr);
265 >                multcolor(sr.rcol, ctmp);
266 >                addcolor(r->rcol, sr.rcol);
267 >                transtest *= bright(sr.rcol);
268 >                transdist = r->rot + sr.rt;
269 >        }
270 >        if (r->crtype & SHADOW)                 /* the rest is shadow */
271 >                return(1);
272 >                                                /* compute reflected ray */
273 >        setbrdfunc(&nd);
274 >        errno = 0;
275 >        setcolor(ctmp, evalue(mf->ep[0]),
276 >                        evalue(mf->ep[1]),
277 >                        evalue(mf->ep[2]));
278 >        if (errno)
279 >                objerror(m, WARNING, "compute error");
280 >        else if (rayorigin(&sr, r, REFLECTED, bright(ctmp)) == 0) {
281 >                for (i = 0; i < 3; i++)
282 >                        sr.rdir[i] = r->rdir[i] + 2.0*nd.pdot*nd.pnorm[i];
283 >                rayvalue(&sr);
284 >                multcolor(sr.rcol, ctmp);
285 >                addcolor(r->rcol, sr.rcol);
286 >        }
287 >                                                /* compute ambient */
288 >        if (hasrefl) {
289 >                if (nd.pdot < 0.0)
290 >                        flipsurface(r);
291 >                ambient(ctmp, r);
292 >                multcolor(ctmp, nd.rdiff);
293 >                addcolor(r->rcol, ctmp);        /* add to returned color */
294 >                if (nd.pdot < 0.0)
295 >                        flipsurface(r);
296 >        }
297 >        if (hastrans) {                         /* from other side */
298 >                if (nd.pdot > 0.0)
299 >                        flipsurface(r);
300 >                ambient(ctmp, r);
301 >                multcolor(ctmp, nd.tdiff);
302 >                addcolor(r->rcol, ctmp);
303 >                if (nd.pdot > 0.0)
304 >                        flipsurface(r);
305 >        }
306 >        if (hasrefl | hastrans || m->oargs.sarg[6][0] != '0')
307 >                direct(r, dirbrdf, &nd);        /* add direct component */
308 >                                                /* check distance */
309 >        if (transtest > bright(r->rcol))
310 >                r->rt = transdist;
311 >
312 >        return(1);
313 > }
314 >
315 >
316 >
317 > m_brdf2(m, r)                   /* color a ray which hit a BRDF material */
318 > register OBJREC  *m;
319 > register RAY  *r;
320 > {
321 >        BRDFDAT  nd;
322 >        COLOR  ctmp;
323 >        double  dtmp;
324 >                                                /* always a shadow */
325 >        if (r->crtype & SHADOW)
326 >                return(1);
327 >                                                /* check arguments */
328 >        if (m->oargs.nsargs < (hasdata(m->otype)?4:2) | m->oargs.nfargs <
329 >                        (m->otype==MAT_TFUNC|m->otype==MAT_TDATA?6:4))
330                  objerror(m, USER, "bad # arguments");
331          nd.mp = m;
332          nd.pr = r;
333 +                                                /* get material color */
334 +        setcolor(nd.mcolor, m->oargs.farg[0],
335 +                        m->oargs.farg[1],
336 +                        m->oargs.farg[2]);
337                                                  /* get specular component */
338          nd.rspec = m->oargs.farg[3];
339 <                                                /* compute transmission */
340 <        if (m->otype == MAT_TFUNC || m->otype == MAT_TDATA
217 <                        || m->otype == MAT_BRTDF) {
339 >                                                /* compute transmittance */
340 >        if (m->otype == MAT_TFUNC | m->otype == MAT_TDATA) {
341                  nd.trans = m->oargs.farg[4]*(1.0 - nd.rspec);
342                  nd.tspec = nd.trans * m->oargs.farg[5];
343 <                nd.tdiff = nd.trans - nd.tspec;
344 <        } else
345 <                nd.tdiff = nd.tspec = nd.trans = 0.0;
346 <                                                /* early shadow check */
347 <        if (r->crtype & SHADOW && (m->otype != MAT_BRTDF || nd.tspec <= FTINY))
348 <                return;
349 <                                                /* diffuse reflection */
350 <        nd.rdiff = 1.0 - nd.trans - nd.rspec;
351 <                                                /* get material color */
229 <        setcolor(nd.mcolor, m->oargs.farg[0],
230 <                           m->oargs.farg[1],
231 <                           m->oargs.farg[2]);
343 >                dtmp = nd.trans - nd.tspec;
344 >                setcolor(nd.tdiff, dtmp, dtmp, dtmp);
345 >        } else {
346 >                nd.tspec = nd.trans = 0.0;
347 >                setcolor(nd.tdiff, 0.0, 0.0, 0.0);
348 >        }
349 >                                                /* compute reflectance */
350 >        dtmp = 1.0 - nd.trans - nd.rspec;
351 >        setcolor(nd.rdiff, dtmp, dtmp, dtmp);
352                                                  /* fix orientation */
353          if (r->rod < 0.0)
354                  flipsurface(r);
# Line 236 | Line 356 | register RAY  *r;
356          raytexture(r, m->omod);
357          nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
358          multcolor(nd.mcolor, r->pcol);          /* modify material color */
359 <        transtest = 0;
359 >        multcolor(nd.rdiff, nd.mcolor);
360 >        multcolor(nd.tdiff, nd.mcolor);
361                                                  /* load auxiliary files */
362 <        if (m->otype == MAT_PDATA || m->otype == MAT_MDATA
242 <                        || m->otype == MAT_TDATA) {
362 >        if (hasdata(m->otype)) {
363                  nd.dp = getdata(m->oargs.sarg[1]);
364 <                for (i = 3; i < m->oargs.nsargs; i++)
245 <                        if (m->oargs.sarg[i][0] == '-')
246 <                                break;
247 <                if (i-3 != nd.dp->nd)
248 <                        objerror(m, USER, "dimension error");
249 <                if (!fundefined(m->oargs.sarg[3]))
250 <                        loadfunc(m->oargs.sarg[2]);
251 <        } else if (m->otype == MAT_BRTDF) {
252 <                nd.dp = NULL;
253 <                if (!fundefined(m->oargs.sarg[7]))
254 <                        loadfunc(m->oargs.sarg[9]);
364 >                getfunc(m, 2, 0, 0);
365          } else {
366                  nd.dp = NULL;
367 <                if (!fundefined(m->oargs.sarg[0]))
258 <                        loadfunc(m->oargs.sarg[1]);
367 >                getfunc(m, 1, 0, 0);
368          }
260                                                /* set special variables */
261        setbrdfunc(&nd);
262                                                /* compute transmitted ray */
263        tspect = 0.;
264        if (m->otype == MAT_BRTDF && nd.tspec > FTINY) {
265                RAY  sr;
266                errno = 0;
267                setcolor(ctmp, varvalue(m->oargs.sarg[3]),
268                                varvalue(m->oargs.sarg[4]),
269                                varvalue(m->oargs.sarg[5]));
270                scalecolor(ctmp, nd.tspec);
271                if (errno)
272                        objerror(m, WARNING, "compute error");
273                else if ((tspect = bright(ctmp)) > FTINY &&
274                                rayorigin(&sr, r, TRANS, tspect) == 0) {
275                        if (DOT(r->pert,r->pert) > FTINY*FTINY) {
276                                for (i = 0; i < 3; i++) /* perturb direction */
277                                        sr.rdir[i] = r->rdir[i] -
278                                                        .75*r->pert[i];
279                                normalize(sr.rdir);
280                        } else {
281                                VCOPY(sr.rdir, r->rdir);
282                                transtest = 2;
283                        }
284                        rayvalue(&sr);
285                        multcolor(sr.rcol, ctmp);
286                        addcolor(r->rcol, sr.rcol);
287                        transtest *= bright(sr.rcol);
288                        transdist = r->rot + sr.rt;
289                }
290        }
291        if (r->crtype & SHADOW)                 /* the rest is shadow */
292                return;
293                                                /* compute reflected ray */
294        rspecr = 0.;
295        if (m->otype == MAT_BRTDF && nd.rspec > FTINY) {
296                RAY  sr;
297                errno = 0;
298                setcolor(ctmp, varvalue(m->oargs.sarg[0]),
299                                varvalue(m->oargs.sarg[1]),
300                                varvalue(m->oargs.sarg[2]));
301                scalecolor(ctmp, nd.rspec);
302                if (errno)
303                        objerror(m, WARNING, "compute error");
304                else if ((rspecr = bright(ctmp)) > FTINY &&
305                                rayorigin(&sr, r, REFLECTED, rspecr) == 0) {
306                        for (i = 0; i < 3; i++)
307                                sr.rdir[i] = r->rdir[i] +
308                                                2.0*nd.pdot*nd.pnorm[i];
309                        rayvalue(&sr);
310                        multcolor(sr.rcol, ctmp);
311                        addcolor(r->rcol, sr.rcol);
312                }
313        }
369                                                  /* compute ambient */
370 <        if ((dtmp = 1.0-nd.trans-rspecr) > FTINY) {
370 >        if (nd.trans < 1.0-FTINY) {
371                  ambient(ctmp, r);
372 <                scalecolor(ctmp, dtmp);
372 >                scalecolor(ctmp, 1.0-nd.trans);
373                  multcolor(ctmp, nd.mcolor);     /* modified by material color */
374                  addcolor(r->rcol, ctmp);        /* add to returned color */
375          }
376 <        if ((dtmp = nd.trans-tspect) > FTINY) { /* from other side */
376 >        if (nd.trans > FTINY) {         /* from other side */
377                  flipsurface(r);
378                  ambient(ctmp, r);
379 <                scalecolor(ctmp, dtmp);
379 >                scalecolor(ctmp, nd.trans);
380                  multcolor(ctmp, nd.mcolor);
381                  addcolor(r->rcol, ctmp);
382                  flipsurface(r);
383          }
384                                                  /* add direct component */
385          direct(r, dirbrdf, &nd);
386 <                                                /* check distance */
387 <        if (transtest > bright(r->rcol))
333 <                r->rt = transdist;
386 >
387 >        return(1);
388   }
389  
390  

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines