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.10 by greg, Fri May 10 08:51:04 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;
41 < register RAY  *r;
43 < {
44 <        double  exp();
39 > typedef struct {
40 >        OBJREC  *mp;            /* material pointer */
41 >        RAY  *pr;               /* intersected ray */
42          COLOR  mcolor;          /* color of this material */
43          COLOR  scolor;          /* color of specular component */
44          FVECT  vrefl;           /* vector in direction of reflected ray */
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;
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 unaffected by material color.
112 +                 */
113 +                                                /* roughness + source */
114 +                dtmp = np->alpha2 + omega/(2.0*PI);
115 +                                                /* gaussian */
116 +                dtmp = exp((DOT(np->pr->rdir,ldir)-1.)/dtmp)/(2.*PI)/dtmp;
117 +                                                /* worth using? */
118 +                if (dtmp > FTINY) {
119 +                        dtmp *= np->tspec * omega;
120 +                        setcolor(ctmp, dtmp, dtmp, dtmp);
121 +                        addcolor(cval, ctmp);
122 +                }
123 +        }
124 + }
125 +
126 +
127 + m_normal(m, r)                  /* color a ray which hit something normal */
128 + register OBJREC  *m;
129 + register RAY  *r;
130 + {
131 +        NORMDAT  nd;
132 +        double  transtest, transdist;
133 +        double  dtmp;
134 +        COLOR  ctmp;
135          register int  i;
136  
137          if (m->oargs.nfargs != (m->otype == MAT_TRANS ? 7 : 5))
# Line 63 | Line 139 | register RAY  *r;
139                                                  /* easy shadow test */
140          if (r->crtype & SHADOW && m->otype != MAT_TRANS)
141                  return;
142 +        nd.mp = m;
143 +        nd.pr = r;
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 >        multcolor(nd.mcolor, r->pcol);          /* modify material color */
158 >        r->rt = r->rot;                         /* default ray length */
159 >        transtest = 0;
160                                                  /* get specular component */
161 <        rspec = m->oargs.farg[3];
161 >        nd.rspec = m->oargs.farg[3];
162  
163 <        if (rspec > FTINY) {                    /* has specular component */
163 >        if (nd.rspec > FTINY) {                 /* has specular component */
164                                                  /* compute specular color */
165                  if (m->otype == MAT_METAL)
166 <                        copycolor(scolor, mcolor);
166 >                        copycolor(nd.scolor, nd.mcolor);
167                  else
168 <                        setcolor(scolor, 1.0, 1.0, 1.0);
169 <                scalecolor(scolor, rspec);
168 >                        setcolor(nd.scolor, 1.0, 1.0, 1.0);
169 >                scalecolor(nd.scolor, nd.rspec);
170                                                  /* improved model */
171 <                dtmp = exp(-BSPEC(m)*pdot);
171 >                dtmp = exp(-BSPEC(m)*nd.pdot);
172                  for (i = 0; i < 3; i++)
173 <                        colval(scolor,i) += (1.0-colval(scolor,i))*dtmp;
174 <                rspec += (1.0-rspec)*dtmp;
173 >                        colval(nd.scolor,i) += (1.0-colval(nd.scolor,i))*dtmp;
174 >                nd.rspec += (1.0-nd.rspec)*dtmp;
175                                                  /* compute reflected ray */
176                  for (i = 0; i < 3; i++)
177 <                        vrefl[i] = r->rdir[i] + 2.0*pdot*pnorm[i];
177 >                        nd.vrefl[i] = r->rdir[i] + 2.0*nd.pdot*nd.pnorm[i];
178  
179 <                if (alpha2 <= FTINY && !(r->crtype & SHADOW))
180 <                        if (rayorigin(&lr, r, REFLECTED, rspec) == 0) {
181 <                                VCOPY(lr.rdir, vrefl);
179 >                if (nd.alpha2 <= FTINY && !(r->crtype & SHADOW)) {
180 >                        RAY  lr;
181 >                        if (rayorigin(&lr, r, REFLECTED, nd.rspec) == 0) {
182 >                                VCOPY(lr.rdir, nd.vrefl);
183                                  rayvalue(&lr);
184 <                                multcolor(lr.rcol, scolor);
184 >                                multcolor(lr.rcol, nd.scolor);
185                                  addcolor(r->rcol, lr.rcol);
186                          }
187 +                }
188          }
189 <
189 >                                                /* compute transmission */
190          if (m->otype == MAT_TRANS) {
191 <                trans = m->oargs.farg[5]*(1.0 - rspec);
192 <                tspec = trans * m->oargs.farg[6];
193 <                tdiff = trans - tspec;
191 >                nd.trans = m->oargs.farg[5]*(1.0 - nd.rspec);
192 >                nd.tspec = nd.trans * m->oargs.farg[6];
193 >                nd.tdiff = nd.trans - nd.tspec;
194          } else
195 <                tdiff = tspec = trans = 0.0;
195 >                nd.tdiff = nd.tspec = nd.trans = 0.0;
196                                                  /* transmitted ray */
197 <        if (tspec > FTINY && alpha2 <= FTINY)
198 <                if (rayorigin(&lr, r, TRANS, tspec) == 0) {
199 <                        VCOPY(lr.rdir, r->rdir);
197 >        if (nd.tspec > FTINY && nd.alpha2 <= FTINY) {
198 >                RAY  lr;
199 >                if (rayorigin(&lr, r, TRANS, nd.tspec) == 0) {
200 >                        if (DOT(r->pert,r->pert) > FTINY*FTINY) {
201 >                                for (i = 0; i < 3; i++) /* perturb direction */
202 >                                        lr.rdir[i] = r->rdir[i] -
203 >                                                        .75*r->pert[i];
204 >                                normalize(lr.rdir);
205 >                        } else {
206 >                                VCOPY(lr.rdir, r->rdir);
207 >                                transtest = 2;
208 >                        }
209                          rayvalue(&lr);
210 <                        scalecolor(lr.rcol, tspec);
210 >                        scalecolor(lr.rcol, nd.tspec);
211 >                        multcolor(lr.rcol, nd.mcolor);  /* modified by color */
212                          addcolor(r->rcol, lr.rcol);
213 +                        transtest *= bright(lr.rcol);
214 +                        transdist = r->rot + lr.rt;
215                  }
216 +        }
217          if (r->crtype & SHADOW)                 /* the rest is shadow */
218                  return;
219                                                  /* diffuse reflection */
220 <        rdiff = 1.0 - trans - rspec;
220 >        nd.rdiff = 1.0 - nd.trans - nd.rspec;
221  
222 <        if (rdiff <= FTINY && tdiff <= FTINY && alpha2 <= FTINY)
222 >        if (nd.rdiff <= FTINY && nd.tdiff <= FTINY && nd.alpha2 <= FTINY)
223                  return;                         /* purely specular */
224  
225 <        ambient(ctmp, r);               /* compute ambient component */
226 <        scalecolor(ctmp, 1.0-trans);    /* from this side */
227 <        multcolor(ctmp, mcolor);        /* modified by material color */
228 <        addcolor(r->rcol, ctmp);        /* add to returned color */
229 <
230 <        if (trans > FTINY) {            /* ambient from other side */
225 >        if (nd.rdiff > FTINY) {         /* ambient from this side */
226 >                ambient(ctmp, r);
227 >                if (nd.alpha2 <= FTINY)
228 >                        scalecolor(ctmp, nd.rdiff);
229 >                else
230 >                        scalecolor(ctmp, 1.0-nd.trans);
231 >                multcolor(ctmp, nd.mcolor);     /* modified by material color */
232 >                addcolor(r->rcol, ctmp);        /* add to returned color */
233 >        }
234 >        if (nd.tdiff > FTINY) {         /* ambient from other side */
235                  flipsurface(r);
236 <                scalecolor(ctmp, trans);
237 <                multcolor(ctmp, mcolor);
236 >                ambient(ctmp, r);
237 >                if (nd.alpha2 <= FTINY)
238 >                        scalecolor(ctmp, nd.tdiff);
239 >                else
240 >                        scalecolor(ctmp, nd.trans);
241 >                multcolor(ctmp, nd.mcolor);
242                  addcolor(r->rcol, ctmp);
243                  flipsurface(r);
244          }
245 <        
246 <        for (i = 0; i < nsources; i++) {        /* add specular and diffuse */
247 <
248 <                if ((omega = srcray(&lr, r, i)) == 0.0)
249 <                        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 <        }
245 >                                        /* add direct component */
246 >        direct(r, dirnorm, &nd);
247 >                                        /* check distance */
248 >        if (transtest > bright(r->rcol))
249 >                r->rt = transdist;
250   }

Diff Legend

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