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

Comparing ray/src/rt/normal.c (file contents):
Revision 1.1 by greg, Thu Feb 2 10:41:30 1989 UTC vs.
Revision 1.14 by greg, Wed Oct 30 14:53:55 1991 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1986 Regents of the University of California */
1 > /* Copyright (c) 1991 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 15 | Line 15 | static char SCCSid[] = "$SunId$ LBL";
15  
16   #include  "ray.h"
17  
18 – #include  "source.h"
19 –
18   #include  "otypes.h"
19  
20   /*
# Line 36 | Line 34 | static char SCCSid[] = "$SunId$ LBL";
34  
35   #define  BSPEC(m)       (6.0)           /* specularity parameter b */
36  
37 + extern double  exp();
38  
39 < m_normal(m, r)                  /* color a ray which hit something normal */
40 < register OBJREC  *m;
42 < register RAY  *r;
43 < {
44 <        double  exp();
39 > typedef struct {
40 >        OBJREC  *mp;            /* material pointer */
41          COLOR  mcolor;          /* color of this material */
42          COLOR  scolor;          /* color of specular component */
43          FVECT  vrefl;           /* vector in direction of reflected ray */
44 +        FVECT  prdir;           /* vector in transmitted direction */
45          double  alpha2;         /* roughness squared times 2 */
49 –        RAY  lr;                /* ray to illumination source */
46          double  rdiff, rspec;   /* reflected specular, diffuse */
47          double  trans;          /* transmissivity */
48          double  tdiff, tspec;   /* transmitted specular, diffuse */
49          FVECT  pnorm;           /* perturbed surface normal */
50          double  pdot;           /* perturbed dot product */
51 + }  NORMDAT;             /* normal material data */
52 +
53 +
54 + dirnorm(cval, np, ldir, omega)          /* compute source contribution */
55 + COLOR  cval;                    /* returned coefficient */
56 + register NORMDAT  *np;          /* material data */
57 + FVECT  ldir;                    /* light source direction */
58 + double  omega;                  /* light source size */
59 + {
60          double  ldot;
56 –        double  omega;
61          double  dtmp;
62          COLOR  ctmp;
63 +
64 +        setcolor(cval, 0.0, 0.0, 0.0);
65 +
66 +        ldot = DOT(np->pnorm, ldir);
67 +
68 +        if (ldot < 0.0 ? np->trans <= FTINY : np->trans >= 1.0-FTINY)
69 +                return;         /* wrong side */
70 +
71 +        if (ldot > FTINY && np->rdiff > FTINY) {
72 +                /*
73 +                 *  Compute and add diffuse reflected component to returned
74 +                 *  color.  The diffuse reflected component will always be
75 +                 *  modified by the color of the material.
76 +                 */
77 +                copycolor(ctmp, np->mcolor);
78 +                dtmp = ldot * omega * np->rdiff / PI;
79 +                scalecolor(ctmp, dtmp);
80 +                addcolor(cval, ctmp);
81 +        }
82 +        if (ldot > FTINY && np->rspec > FTINY && np->alpha2 > FTINY) {
83 +                /*
84 +                 *  Compute specular reflection coefficient using
85 +                 *  gaussian distribution model.
86 +                 */
87 +                                                /* roughness + source */
88 +                dtmp = np->alpha2 + omega/(2.0*PI);
89 +                                                /* gaussian */
90 +                dtmp = exp((DOT(np->vrefl,ldir)-1.)/dtmp)/(2.*PI)/dtmp;
91 +                                                /* worth using? */
92 +                if (dtmp > FTINY) {
93 +                        copycolor(ctmp, np->scolor);
94 +                        dtmp *= omega / np->pdot;
95 +                        scalecolor(ctmp, dtmp);
96 +                        addcolor(cval, ctmp);
97 +                }
98 +        }
99 +        if (ldot < -FTINY && np->tdiff > FTINY) {
100 +                /*
101 +                 *  Compute diffuse transmission.
102 +                 */
103 +                copycolor(ctmp, np->mcolor);
104 +                dtmp = -ldot * omega * np->tdiff / PI;
105 +                scalecolor(ctmp, dtmp);
106 +                addcolor(cval, ctmp);
107 +        }
108 +        if (ldot < -FTINY && np->tspec > FTINY && np->alpha2 > FTINY) {
109 +                /*
110 +                 *  Compute specular transmission.  Specular transmission
111 +                 *  is always modified by material color.
112 +                 */
113 +                                                /* roughness + source */
114 +                dtmp = np->alpha2 + omega/(2.0*PI);
115 +                                                /* gaussian */
116 +                dtmp = exp((DOT(np->prdir,ldir)-1.)/dtmp)/(2.*PI)/dtmp;
117 +                                                /* worth using? */
118 +                if (dtmp > FTINY) {
119 +                        copycolor(ctmp, np->mcolor);
120 +                        dtmp *= np->tspec * omega / np->pdot;
121 +                        scalecolor(ctmp, dtmp);
122 +                        addcolor(cval, ctmp);
123 +                }
124 +        }
125 + }
126 +
127 +
128 + m_normal(m, r)                  /* color a ray which hit something normal */
129 + register OBJREC  *m;
130 + register RAY  *r;
131 + {
132 +        NORMDAT  nd;
133 +        double  transtest, transdist;
134 +        double  dtmp;
135 +        COLOR  ctmp;
136          register int  i;
137  
138          if (m->oargs.nfargs != (m->otype == MAT_TRANS ? 7 : 5))
# Line 63 | Line 140 | register RAY  *r;
140                                                  /* easy shadow test */
141          if (r->crtype & SHADOW && m->otype != MAT_TRANS)
142                  return;
143 +        nd.mp = m;
144                                                  /* get material color */
145 <        setcolor(mcolor, m->oargs.farg[0],
145 >        setcolor(nd.mcolor, m->oargs.farg[0],
146                             m->oargs.farg[1],
147                             m->oargs.farg[2]);
148                                                  /* get roughness */
149 <        alpha2 = m->oargs.farg[4];
150 <        alpha2 *= 2.0 * alpha2;
149 >        nd.alpha2 = m->oargs.farg[4];
150 >        nd.alpha2 *= 2.0 * nd.alpha2;
151                                                  /* reorient if necessary */
152          if (r->rod < 0.0)
153                  flipsurface(r);
154                                                  /* get modifiers */
155          raytexture(r, m->omod);
156 <        pdot = raynormal(pnorm, r);             /* perturb normal */
157 <        multcolor(mcolor, r->pcol);             /* modify material color */
156 >        nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
157 >        if (nd.pdot < .001)
158 >                nd.pdot = .001;                 /* non-zero for dirnorm() */
159 >        multcolor(nd.mcolor, r->pcol);          /* modify material color */
160 >        transtest = 0;
161                                                  /* get specular component */
162 <        rspec = m->oargs.farg[3];
162 >        nd.rspec = m->oargs.farg[3];
163  
164 <        if (rspec > FTINY) {                    /* has specular component */
164 >        if (nd.rspec > FTINY) {                 /* has specular component */
165                                                  /* compute specular color */
166                  if (m->otype == MAT_METAL)
167 <                        copycolor(scolor, mcolor);
167 >                        copycolor(nd.scolor, nd.mcolor);
168                  else
169 <                        setcolor(scolor, 1.0, 1.0, 1.0);
170 <                scalecolor(scolor, rspec);
169 >                        setcolor(nd.scolor, 1.0, 1.0, 1.0);
170 >                scalecolor(nd.scolor, nd.rspec);
171                                                  /* improved model */
172 <                dtmp = exp(-BSPEC(m)*pdot);
172 >                dtmp = exp(-BSPEC(m)*nd.pdot);
173                  for (i = 0; i < 3; i++)
174 <                        colval(scolor,i) += (1.0-colval(scolor,i))*dtmp;
175 <                rspec += (1.0-rspec)*dtmp;
174 >                        colval(nd.scolor,i) += (1.0-colval(nd.scolor,i))*dtmp;
175 >                nd.rspec += (1.0-nd.rspec)*dtmp;
176                                                  /* compute reflected ray */
177                  for (i = 0; i < 3; i++)
178 <                        vrefl[i] = r->rdir[i] + 2.0*pdot*pnorm[i];
178 >                        nd.vrefl[i] = r->rdir[i] + 2.0*nd.pdot*nd.pnorm[i];
179  
180 <                if (alpha2 <= FTINY && !(r->crtype & SHADOW))
181 <                        if (rayorigin(&lr, r, REFLECTED, rspec) == 0) {
182 <                                VCOPY(lr.rdir, vrefl);
180 >                if (nd.alpha2 <= FTINY && !(r->crtype & SHADOW)) {
181 >                        RAY  lr;
182 >                        if (rayorigin(&lr, r, REFLECTED, nd.rspec) == 0) {
183 >                                VCOPY(lr.rdir, nd.vrefl);
184                                  rayvalue(&lr);
185 <                                multcolor(lr.rcol, scolor);
185 >                                multcolor(lr.rcol, nd.scolor);
186                                  addcolor(r->rcol, lr.rcol);
187                          }
188 +                }
189          }
190 <
190 >                                                /* compute transmission */
191          if (m->otype == MAT_TRANS) {
192 <                trans = m->oargs.farg[5]*(1.0 - rspec);
193 <                tspec = trans * m->oargs.farg[6];
194 <                tdiff = trans - tspec;
192 >                nd.trans = m->oargs.farg[5]*(1.0 - nd.rspec);
193 >                nd.tspec = nd.trans * m->oargs.farg[6];
194 >                nd.tdiff = nd.trans - nd.tspec;
195 >                if (r->crtype & SHADOW || DOT(r->pert,r->pert) <= FTINY*FTINY) {
196 >                        VCOPY(nd.prdir, r->rdir);
197 >                        transtest = 2;
198 >                } else {
199 >                        for (i = 0; i < 3; i++)         /* perturb direction */
200 >                                nd.prdir[i] = r->rdir[i] - .75*r->pert[i];
201 >                        normalize(nd.prdir);
202 >                }
203          } else
204 <                tdiff = tspec = trans = 0.0;
204 >                nd.tdiff = nd.tspec = nd.trans = 0.0;
205                                                  /* transmitted ray */
206 <        if (tspec > FTINY && alpha2 <= FTINY)
207 <                if (rayorigin(&lr, r, TRANS, tspec) == 0) {
208 <                        VCOPY(lr.rdir, r->rdir);
206 >        if (nd.tspec > FTINY && nd.alpha2 <= FTINY) {
207 >                RAY  lr;
208 >                if (rayorigin(&lr, r, TRANS, nd.tspec) == 0) {
209 >                        VCOPY(lr.rdir, nd.prdir);
210                          rayvalue(&lr);
211 <                        scalecolor(lr.rcol, tspec);
211 >                        scalecolor(lr.rcol, nd.tspec);
212 >                        multcolor(lr.rcol, nd.mcolor);  /* modified by color */
213                          addcolor(r->rcol, lr.rcol);
214 +                        transtest *= bright(lr.rcol);
215 +                        transdist = r->rot + lr.rt;
216                  }
217 +        }
218          if (r->crtype & SHADOW)                 /* the rest is shadow */
219                  return;
220                                                  /* diffuse reflection */
221 <        rdiff = 1.0 - trans - rspec;
221 >        nd.rdiff = 1.0 - nd.trans - nd.rspec;
222  
223 <        if (rdiff <= FTINY && tdiff <= FTINY && alpha2 <= FTINY)
223 >        if (nd.rdiff <= FTINY && nd.tdiff <= FTINY && nd.alpha2 <= FTINY)
224                  return;                         /* purely specular */
225  
226 <        ambient(ctmp, r);               /* compute ambient component */
227 <        scalecolor(ctmp, 1.0-trans);    /* from this side */
228 <        multcolor(ctmp, mcolor);        /* modified by material color */
229 <        addcolor(r->rcol, ctmp);        /* add to returned color */
230 <
231 <        if (trans > FTINY) {            /* ambient from other side */
226 >        if (nd.rdiff > FTINY) {         /* ambient from this side */
227 >                ambient(ctmp, r);
228 >                if (nd.alpha2 <= FTINY)
229 >                        scalecolor(ctmp, nd.rdiff);
230 >                else
231 >                        scalecolor(ctmp, 1.0-nd.trans);
232 >                multcolor(ctmp, nd.mcolor);     /* modified by material color */
233 >                addcolor(r->rcol, ctmp);        /* add to returned color */
234 >        }
235 >        if (nd.tdiff > FTINY) {         /* ambient from other side */
236                  flipsurface(r);
237 <                scalecolor(ctmp, trans);
238 <                multcolor(ctmp, mcolor);
237 >                ambient(ctmp, r);
238 >                if (nd.alpha2 <= FTINY)
239 >                        scalecolor(ctmp, nd.tdiff);
240 >                else
241 >                        scalecolor(ctmp, nd.trans);
242 >                multcolor(ctmp, nd.mcolor);     /* modified by color */
243                  addcolor(r->rcol, ctmp);
244                  flipsurface(r);
245          }
246 <        
247 <        for (i = 0; i < nsources; i++) {        /* add specular and diffuse */
248 <
249 <                if ((omega = srcray(&lr, r, i)) == 0.0)
250 <                        continue;               /* bad source */
147 <
148 <                ldot = DOT(pnorm, lr.rdir);
149 <        
150 <                if (ldot < 0.0 ? trans <= FTINY : trans >= 1.0-FTINY)
151 <                        continue;               /* wrong side */
152 <        
153 <                rayvalue(&lr);                  /* compute light ray value */
154 <        
155 <                if (intens(lr.rcol) <= FTINY)
156 <                        continue;               /* didn't hit light source */
157 <
158 <                if (ldot > FTINY && rdiff > FTINY) {
159 <                        /*
160 <                         *  Compute and add diffuse component to returned color.
161 <                         *  The diffuse component will always be modified by the
162 <                         *  color of the material.
163 <                         */
164 <                        copycolor(ctmp, lr.rcol);
165 <                        dtmp = ldot * omega * rdiff / PI;
166 <                        scalecolor(ctmp, dtmp);
167 <                        multcolor(ctmp, mcolor);
168 <                        addcolor(r->rcol, ctmp);
169 <                }
170 <                if (ldot > FTINY && rspec > FTINY && alpha2 > FTINY) {
171 <                        /*
172 <                         *  Compute specular reflection coefficient using
173 <                         *  gaussian distribution model.
174 <                         */
175 <                                                        /* roughness + source */
176 <                        dtmp = alpha2 + omega/(2.0*PI);
177 <                                                        /* gaussian */
178 <                        dtmp = exp((DOT(vrefl,lr.rdir)-1.)/dtmp)/(2.*PI)/dtmp;
179 <                                                        /* worth using? */
180 <                        if (dtmp > FTINY) {
181 <                                copycolor(ctmp, lr.rcol);
182 <                                dtmp *= omega;
183 <                                scalecolor(ctmp, dtmp);
184 <                                multcolor(ctmp, scolor);
185 <                                addcolor(r->rcol, ctmp);
186 <                        }
187 <                }
188 <                if (ldot < -FTINY && tdiff > FTINY) {
189 <                        /*
190 <                         *  Compute diffuse transmission.
191 <                         */
192 <                        copycolor(ctmp, lr.rcol);
193 <                        dtmp = -ldot * omega * tdiff / PI;
194 <                        scalecolor(ctmp, dtmp);
195 <                        multcolor(ctmp, mcolor);
196 <                        addcolor(r->rcol, ctmp);
197 <                }
198 <                if (ldot < -FTINY && tspec > FTINY && alpha2 > FTINY) {
199 <                        /*
200 <                         *  Compute specular transmission.
201 <                         */
202 <                                                        /* roughness + source */
203 <                        dtmp = alpha2 + omega/(2.0*PI);
204 <                                                        /* gaussian */
205 <                        dtmp = exp((DOT(r->rdir,lr.rdir)-1.)/dtmp)/(2.*PI)/dtmp;
206 <                                                        /* worth using? */
207 <                        if (dtmp > FTINY) {
208 <                                copycolor(ctmp, lr.rcol);
209 <                                dtmp *= tspec * omega;
210 <                                scalecolor(ctmp, dtmp);
211 <                                addcolor(r->rcol, ctmp);
212 <                        }
213 <                }
214 <        }
246 >                                        /* add direct component */
247 >        direct(r, dirnorm, &nd);
248 >                                        /* check distance */
249 >        if (transtest > bright(r->rcol))
250 >                r->rt = transdist;
251   }

Diff Legend

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