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.2 by greg, Sat Apr 15 12:23:22 1989 UTC vs.
Revision 1.3 by greg, Wed Jun 7 08:35:14 1989 UTC

# 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;
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 component to returned color.
74 +                 *  The diffuse component will always be modified by the
75 +                 *  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.
111 +                 */
112 +                                                /* roughness + source */
113 +                dtmp = np->alpha2 + omega/(2.0*PI);
114 +                                                /* gaussian */
115 +                dtmp = exp((DOT(np->pr->rdir,ldir)-1.)/dtmp)/(2.*PI)/dtmp;
116 +                                                /* worth using? */
117 +                if (dtmp > FTINY) {
118 +                        copycolor(ctmp, np->mcolor);
119 +                        dtmp *= np->tspec * omega;
120 +                        scalecolor(ctmp, 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  ldot;
133          double  omega;
134          double  dtmp;
135          COLOR  ctmp;
# 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 +        nd.pr = r;
145                                                  /* get material color */
146 <        setcolor(mcolor, m->oargs.farg[0],
146 >        setcolor(nd.mcolor, m->oargs.farg[0],
147                             m->oargs.farg[1],
148                             m->oargs.farg[2]);
149                                                  /* get roughness */
150 <        alpha2 = m->oargs.farg[4];
151 <        alpha2 *= 2.0 * alpha2;
150 >        nd.alpha2 = m->oargs.farg[4];
151 >        nd.alpha2 *= 2.0 * nd.alpha2;
152                                                  /* reorient if necessary */
153          if (r->rod < 0.0)
154                  flipsurface(r);
155                                                  /* get modifiers */
156          raytexture(r, m->omod);
157 <        pdot = raynormal(pnorm, r);             /* perturb normal */
158 <        multcolor(mcolor, r->pcol);             /* modify material color */
157 >        nd.pdot = raynormal(nd.pnorm, r);       /* perturb normal */
158 >        multcolor(nd.mcolor, r->pcol);          /* modify material color */
159                                                  /* get specular component */
160 <        rspec = m->oargs.farg[3];
160 >        nd.rspec = m->oargs.farg[3];
161  
162 <        if (rspec > FTINY) {                    /* has specular component */
162 >        if (nd.rspec > FTINY) {                 /* has specular component */
163                                                  /* compute specular color */
164                  if (m->otype == MAT_METAL)
165 <                        copycolor(scolor, mcolor);
165 >                        copycolor(nd.scolor, nd.mcolor);
166                  else
167 <                        setcolor(scolor, 1.0, 1.0, 1.0);
168 <                scalecolor(scolor, rspec);
167 >                        setcolor(nd.scolor, 1.0, 1.0, 1.0);
168 >                scalecolor(nd.scolor, nd.rspec);
169                                                  /* improved model */
170 <                dtmp = exp(-BSPEC(m)*pdot);
170 >                dtmp = exp(-BSPEC(m)*nd.pdot);
171                  for (i = 0; i < 3; i++)
172 <                        colval(scolor,i) += (1.0-colval(scolor,i))*dtmp;
173 <                rspec += (1.0-rspec)*dtmp;
172 >                        colval(nd.scolor,i) += (1.0-colval(nd.scolor,i))*dtmp;
173 >                nd.rspec += (1.0-nd.rspec)*dtmp;
174                                                  /* compute reflected ray */
175                  for (i = 0; i < 3; i++)
176 <                        vrefl[i] = r->rdir[i] + 2.0*pdot*pnorm[i];
176 >                        nd.vrefl[i] = r->rdir[i] + 2.0*nd.pdot*nd.pnorm[i];
177  
178 <                if (alpha2 <= FTINY && !(r->crtype & SHADOW))
179 <                        if (rayorigin(&lr, r, REFLECTED, rspec) == 0) {
180 <                                VCOPY(lr.rdir, vrefl);
178 >                if (nd.alpha2 <= FTINY && !(r->crtype & SHADOW)) {
179 >                        RAY  lr;
180 >                        if (rayorigin(&lr, r, REFLECTED, nd.rspec) == 0) {
181 >                                VCOPY(lr.rdir, nd.vrefl);
182                                  rayvalue(&lr);
183 <                                multcolor(lr.rcol, scolor);
183 >                                multcolor(lr.rcol, nd.scolor);
184                                  addcolor(r->rcol, lr.rcol);
185                          }
186 +                }
187          }
188 <
188 >                                                /* compute transmission */
189          if (m->otype == MAT_TRANS) {
190 <                trans = m->oargs.farg[5]*(1.0 - rspec);
191 <                tspec = trans * m->oargs.farg[6];
192 <                tdiff = trans - tspec;
190 >                nd.trans = m->oargs.farg[5]*(1.0 - nd.rspec);
191 >                nd.tspec = nd.trans * m->oargs.farg[6];
192 >                nd.tdiff = nd.trans - nd.tspec;
193          } else
194 <                tdiff = tspec = trans = 0.0;
194 >                nd.tdiff = nd.tspec = nd.trans = 0.0;
195                                                  /* transmitted ray */
196 <        if (tspec > FTINY && alpha2 <= FTINY)
197 <                if (rayorigin(&lr, r, TRANS, tspec) == 0) {
196 >        if (nd.tspec > FTINY && nd.alpha2 <= FTINY) {
197 >                RAY  lr;
198 >                if (rayorigin(&lr, r, TRANS, nd.tspec) == 0) {
199                          VCOPY(lr.rdir, r->rdir);
200                          rayvalue(&lr);
201 <                        scalecolor(lr.rcol, tspec);
201 >                        scalecolor(lr.rcol, nd.tspec);
202                          addcolor(r->rcol, lr.rcol);
203                  }
204 +        }
205          if (r->crtype & SHADOW)                 /* the rest is shadow */
206                  return;
207                                                  /* diffuse reflection */
208 <        rdiff = 1.0 - trans - rspec;
208 >        nd.rdiff = 1.0 - nd.trans - nd.rspec;
209  
210 <        if (rdiff <= FTINY && tdiff <= FTINY && alpha2 <= FTINY)
210 >        if (nd.rdiff <= FTINY && nd.tdiff <= FTINY && nd.alpha2 <= FTINY)
211                  return;                         /* purely specular */
212  
213 <        if (rdiff > FTINY) {            /* ambient from this side */
213 >        if (nd.rdiff > FTINY) {         /* ambient from this side */
214                  ambient(ctmp, r);
215 <                if (alpha2 <= FTINY)
216 <                        scalecolor(ctmp, rdiff);
215 >                if (nd.alpha2 <= FTINY)
216 >                        scalecolor(ctmp, nd.rdiff);
217                  else
218 <                        scalecolor(ctmp, 1.0-trans);
219 <                multcolor(ctmp, mcolor);        /* modified by material color */
218 >                        scalecolor(ctmp, 1.0-nd.trans);
219 >                multcolor(ctmp, nd.mcolor);     /* modified by material color */
220                  addcolor(r->rcol, ctmp);        /* add to returned color */
221          }
222 <        if (tdiff > FTINY) {            /* ambient from other side */
222 >        if (nd.tdiff > FTINY) {         /* ambient from other side */
223                  flipsurface(r);
224                  ambient(ctmp, r);
225 <                if (alpha2 <= FTINY)
226 <                        scalecolor(ctmp, tdiff);
225 >                if (nd.alpha2 <= FTINY)
226 >                        scalecolor(ctmp, nd.tdiff);
227                  else
228 <                        scalecolor(ctmp, trans);
229 <                multcolor(ctmp, mcolor);
228 >                        scalecolor(ctmp, nd.trans);
229 >                multcolor(ctmp, nd.mcolor);
230                  addcolor(r->rcol, ctmp);
231                  flipsurface(r);
232          }
233 <        
234 <        for (i = 0; i < nsources; i++) {        /* add specular and diffuse */
152 <
153 <                if ((omega = srcray(&lr, r, i)) == 0.0)
154 <                        continue;               /* bad source */
155 <
156 <                ldot = DOT(pnorm, lr.rdir);
157 <        
158 <                if (ldot < 0.0 ? trans <= FTINY : trans >= 1.0-FTINY)
159 <                        continue;               /* wrong side */
160 <        
161 <                rayvalue(&lr);                  /* compute light ray value */
162 <        
163 <                if (intens(lr.rcol) <= FTINY)
164 <                        continue;               /* didn't hit light source */
165 <
166 <                if (ldot > FTINY && rdiff > FTINY) {
167 <                        /*
168 <                         *  Compute and add diffuse component to returned color.
169 <                         *  The diffuse component will always be modified by the
170 <                         *  color of the material.
171 <                         */
172 <                        copycolor(ctmp, lr.rcol);
173 <                        dtmp = ldot * omega * rdiff / PI;
174 <                        scalecolor(ctmp, dtmp);
175 <                        multcolor(ctmp, mcolor);
176 <                        addcolor(r->rcol, ctmp);
177 <                }
178 <                if (ldot > FTINY && rspec > FTINY && alpha2 > FTINY) {
179 <                        /*
180 <                         *  Compute specular reflection coefficient using
181 <                         *  gaussian distribution model.
182 <                         */
183 <                                                        /* roughness + source */
184 <                        dtmp = alpha2 + omega/(2.0*PI);
185 <                                                        /* gaussian */
186 <                        dtmp = exp((DOT(vrefl,lr.rdir)-1.)/dtmp)/(2.*PI)/dtmp;
187 <                                                        /* worth using? */
188 <                        if (dtmp > FTINY) {
189 <                                copycolor(ctmp, lr.rcol);
190 <                                dtmp *= omega;
191 <                                scalecolor(ctmp, dtmp);
192 <                                multcolor(ctmp, scolor);
193 <                                addcolor(r->rcol, ctmp);
194 <                        }
195 <                }
196 <                if (ldot < -FTINY && tdiff > FTINY) {
197 <                        /*
198 <                         *  Compute diffuse transmission.
199 <                         */
200 <                        copycolor(ctmp, lr.rcol);
201 <                        dtmp = -ldot * omega * tdiff / PI;
202 <                        scalecolor(ctmp, dtmp);
203 <                        multcolor(ctmp, mcolor);
204 <                        addcolor(r->rcol, ctmp);
205 <                }
206 <                if (ldot < -FTINY && tspec > FTINY && alpha2 > FTINY) {
207 <                        /*
208 <                         *  Compute specular transmission.
209 <                         */
210 <                                                        /* roughness + source */
211 <                        dtmp = alpha2 + omega/(2.0*PI);
212 <                                                        /* gaussian */
213 <                        dtmp = exp((DOT(r->rdir,lr.rdir)-1.)/dtmp)/(2.*PI)/dtmp;
214 <                                                        /* worth using? */
215 <                        if (dtmp > FTINY) {
216 <                                copycolor(ctmp, lr.rcol);
217 <                                dtmp *= tspec * omega;
218 <                                scalecolor(ctmp, dtmp);
219 <                                addcolor(r->rcol, ctmp);
220 <                        }
221 <                }
222 <        }
233 >                                        /* add direct component */
234 >        direct(r, dirnorm, &nd);
235   }

Diff Legend

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