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 2.58 by greg, Tue Oct 12 19:01:14 2010 UTC vs.
Revision 2.87 by greg, Fri Dec 20 16:29:50 2024 UTC

# Line 19 | Line 19 | static const char RCSid[] = "$Id$";
19   #include  "otypes.h"
20   #include  "rtotypes.h"
21   #include  "random.h"
22 + #include  "pmapmat.h"
23  
24   #ifndef  MAXITER
25   #define  MAXITER        10              /* maximum # specular ray attempts */
26   #endif
27                                          /* estimate of Fresnel function */
28 < #define  FRESNE(ci)     (exp(-5.85*(ci)) - 0.00287989916)
28 > #define  FRESNE(ci)     (exp(-5.85*(ci)) - 0.00202943064)
29   #define  FRESTHRESH     0.017999        /* minimum specularity for approx. */
30  
31  
# Line 53 | Line 54 | typedef struct {
54          OBJREC  *mp;            /* material pointer */
55          RAY  *rp;               /* ray pointer */
56          short  specfl;          /* specularity flags, defined above */
57 <        COLOR  mcolor;          /* color of this material */
58 <        COLOR  scolor;          /* color of specular component */
58 <        FVECT  vrefl;           /* vector in direction of reflected ray */
57 >        SCOLOR  mcolor;         /* color of this material */
58 >        SCOLOR  scolor;         /* color of specular component */
59          FVECT  prdir;           /* vector in transmitted direction */
60          double  alpha2;         /* roughness squared */
61          double  rdiff, rspec;   /* reflected specular, diffuse */
# Line 65 | Line 65 | typedef struct {
65          double  pdot;           /* perturbed dot product */
66   }  NORMDAT;             /* normal material data */
67  
68 < static srcdirf_t dirnorm;
69 < static void gaussamp(RAY  *r, NORMDAT  *np);
68 > static void gaussamp(NORMDAT  *np);
69  
70  
71   static void
72   dirnorm(                /* compute source contribution */
73 <        COLOR  cval,                    /* returned coefficient */
74 <        void  *nnp,             /* material data */
73 >        SCOLOR  scval,                  /* returned coefficient */
74 >        void  *nnp,                     /* material data */
75          FVECT  ldir,                    /* light source direction */
76          double  omega                   /* light source size */
77   )
78   {
79 <        register NORMDAT *np = nnp;
79 >        NORMDAT *np = nnp;
80          double  ldot;
81          double  lrdiff, ltdiff;
82          double  dtmp, d2, d3, d4;
83          FVECT  vtmp;
84 <        COLOR  ctmp;
84 >        SCOLOR  sctmp;
85  
86 <        setcolor(cval, 0.0, 0.0, 0.0);
86 >        scolorblack(scval);
87  
88          ldot = DOT(np->pnorm, ldir);
89  
# Line 101 | Line 100 | dirnorm(               /* compute source contribution */
100                  ltdiff *= dtmp;
101          }
102  
103 <        if (ldot > FTINY && lrdiff > FTINY) {
103 >        if ((ldot > FTINY) & (lrdiff > FTINY)) {
104                  /*
105                   *  Compute and add diffuse reflected component to returned
106                   *  color.  The diffuse reflected component will always be
107                   *  modified by the color of the material.
108                   */
109 <                copycolor(ctmp, np->mcolor);
109 >                copyscolor(sctmp, np->mcolor);
110                  dtmp = ldot * omega * lrdiff * (1.0/PI);
111 <                scalecolor(ctmp, dtmp);
112 <                addcolor(cval, ctmp);
111 >                scalescolor(sctmp, dtmp);
112 >                saddscolor(scval, sctmp);
113          }
114 <        if (ldot > FTINY && (np->specfl&(SP_REFL|SP_PURE)) == SP_REFL) {
114 >
115 >        if ((ldot < -FTINY) & (ltdiff > FTINY)) {
116                  /*
117 +                 *  Compute diffuse transmission.
118 +                 */
119 +                copyscolor(sctmp, np->mcolor);
120 +                dtmp = -ldot * omega * ltdiff * (1.0/PI);
121 +                scalescolor(sctmp, dtmp);
122 +                saddscolor(scval, sctmp);
123 +        }
124 +
125 +        if (ambRayInPmap(np->rp))
126 +                return;         /* specular already in photon map */
127 +
128 +        if ((ldot > FTINY) & ((np->specfl&(SP_REFL|SP_PURE)) == SP_REFL)) {
129 +                /*
130                   *  Compute specular reflection coefficient using
131                   *  Gaussian distribution model.
132                   */
# Line 121 | Line 134 | dirnorm(               /* compute source contribution */
134                  dtmp = np->alpha2;
135                                                  /* + source if flat */
136                  if (np->specfl & SP_FLAT)
137 <                        dtmp += omega * (0.25/PI);
137 >                        dtmp += (1. - dstrsrc) * omega * (0.25/PI);
138                                                  /* half vector */
139 <                vtmp[0] = ldir[0] - np->rp->rdir[0];
127 <                vtmp[1] = ldir[1] - np->rp->rdir[1];
128 <                vtmp[2] = ldir[2] - np->rp->rdir[2];
139 >                VSUB(vtmp, ldir, np->rp->rdir);
140                  d2 = DOT(vtmp, np->pnorm);
141                  d2 *= d2;
142                  d3 = DOT(vtmp,vtmp);
# Line 134 | Line 145 | dirnorm(               /* compute source contribution */
145                  dtmp = exp(-d4/dtmp) * d3 / (PI * d2*d2 * dtmp);
146                                                  /* worth using? */
147                  if (dtmp > FTINY) {
148 <                        copycolor(ctmp, np->scolor);
148 >                        copyscolor(sctmp, np->scolor);
149                          dtmp *= ldot * omega;
150 <                        scalecolor(ctmp, dtmp);
151 <                        addcolor(cval, ctmp);
150 >                        scalescolor(sctmp, dtmp);
151 >                        saddscolor(scval, sctmp);
152                  }
153          }
154 <        if (ldot < -FTINY && ltdiff > FTINY) {
154 >        
155 >
156 >        if ((ldot < -FTINY) & ((np->specfl&(SP_TRAN|SP_PURE)) == SP_TRAN)) {
157                  /*
145 –                 *  Compute diffuse transmission.
146 –                 */
147 –                copycolor(ctmp, np->mcolor);
148 –                dtmp = -ldot * omega * ltdiff * (1.0/PI);
149 –                scalecolor(ctmp, dtmp);
150 –                addcolor(cval, ctmp);
151 –        }
152 –        if (ldot < -FTINY && (np->specfl&(SP_TRAN|SP_PURE)) == SP_TRAN) {
153 –                /*
158                   *  Compute specular transmission.  Specular transmission
159                   *  is always modified by material color.
160                   */
# Line 160 | Line 164 | dirnorm(               /* compute source contribution */
164                  dtmp = exp((2.*DOT(np->prdir,ldir)-2.)/dtmp)/(PI*dtmp);
165                                                  /* worth using? */
166                  if (dtmp > FTINY) {
167 <                        copycolor(ctmp, np->mcolor);
167 >                        copyscolor(sctmp, np->mcolor);
168                          dtmp *= np->tspec * omega * sqrt(-ldot/np->pdot);
169 <                        scalecolor(ctmp, dtmp);
170 <                        addcolor(cval, ctmp);
169 >                        scalescolor(sctmp, dtmp);
170 >                        saddscolor(scval, sctmp);
171                  }
172          }
173   }
174  
175  
176 < extern int
176 > int
177   m_normal(                       /* color a ray that hit something normal */
178 <        register OBJREC  *m,
179 <        register RAY  *r
178 >        OBJREC  *m,
179 >        RAY  *r
180   )
181   {
182          NORMDAT  nd;
183          double  fest;
180 –        double  transtest, transdist;
181 –        double  mirtest, mirdist;
184          int     hastexture;
185          double  d;
186 <        COLOR  ctmp;
187 <        register int  i;
186 >        SCOLOR  sctmp;
187 >        int  i;
188 >
189 >        /* PMAP: skip transmitted shadow ray if accounted for in photon map */
190 >        /* No longer needed?
191 >        if (shadowRayInPmap(r) || ambRayInPmap(r))
192 >                return(1); */          
193 >                
194                                                  /* easy shadow test */
195          if (r->crtype & SHADOW && m->otype != MAT_TRANS)
196                  return(1);
# Line 191 | Line 199 | m_normal(                      /* color a ray that hit something normal *
199                  objerror(m, USER, "bad number of arguments");
200                                                  /* check for back side */
201          if (r->rod < 0.0) {
202 <                if (!backvis && m->otype != MAT_TRANS) {
202 >                if (!backvis) {
203                          raytrans(r);
204                          return(1);
205                  }
# Line 202 | Line 210 | m_normal(                      /* color a ray that hit something normal *
210          nd.mp = m;
211          nd.rp = r;
212                                                  /* get material color */
213 <        setcolor(nd.mcolor, m->oargs.farg[0],
213 >        setscolor(nd.mcolor, m->oargs.farg[0],
214                             m->oargs.farg[1],
215                             m->oargs.farg[2]);
216                                                  /* get roughness */
# Line 217 | Line 225 | m_normal(                      /* color a ray that hit something normal *
225                  VCOPY(nd.pnorm, r->ron);
226                  nd.pdot = r->rod;
227          }
228 <        if (r->ro != NULL && isflat(r->ro->otype))
228 >        if (!hastexture && r->ro != NULL && isflat(r->ro->otype))
229                  nd.specfl |= SP_FLAT;
230          if (nd.pdot < .001)
231                  nd.pdot = .001;                 /* non-zero for dirnorm() */
232 <        multcolor(nd.mcolor, r->pcol);          /* modify material color */
225 <        mirtest = transtest = 0;
226 <        mirdist = transdist = r->rot;
232 >        smultscolor(nd.mcolor, r->pcol);        /* modify material color */
233          nd.rspec = m->oargs.farg[3];
234                                                  /* compute Fresnel approx. */
235          if (nd.specfl & SP_PURE && nd.rspec >= FRESTHRESH) {
236 <                fest = FRESNE(r->rod);
236 >                fest = FRESNE(nd.pdot);
237                  nd.rspec += fest*(1. - nd.rspec);
238          } else
239                  fest = 0.;
# Line 242 | Line 248 | m_normal(                      /* color a ray that hit something normal *
248                          if (!(nd.specfl & SP_PURE) &&
249                                          specthresh >= nd.tspec-FTINY)
250                                  nd.specfl |= SP_TBLT;
251 <                        if (!hastexture || r->crtype & SHADOW) {
251 >                        if (!hastexture || r->crtype & (SHADOW|AMBIENT)) {
252                                  VCOPY(nd.prdir, r->rdir);
247 –                                transtest = 2;
253                          } else {
254 <                                for (i = 0; i < 3; i++)         /* perturb */
255 <                                        nd.prdir[i] = r->rdir[i] - r->pert[i];
254 >                                                        /* perturb */
255 >                                VSUB(nd.prdir, r->rdir, r->pert);
256                                  if (DOT(nd.prdir, r->ron) < -FTINY)
257                                          normalize(nd.prdir);    /* OK */
258                                  else
# Line 256 | Line 261 | m_normal(                      /* color a ray that hit something normal *
261                  }
262          } else
263                  nd.tdiff = nd.tspec = nd.trans = 0.0;
264 +                                                /* diffuse reflection */
265 +        nd.rdiff = 1.0 - nd.trans - nd.rspec;
266                                                  /* transmitted ray */
267          if ((nd.specfl&(SP_TRAN|SP_PURE|SP_TBLT)) == (SP_TRAN|SP_PURE)) {
268                  RAY  lr;
269 <                copycolor(lr.rcoef, nd.mcolor); /* modified by color */
270 <                scalecolor(lr.rcoef, nd.tspec);
269 >                copyscolor(lr.rcoef, nd.mcolor);        /* modified by color */
270 >                scalescolor(lr.rcoef, nd.tspec);
271                  if (rayorigin(&lr, TRANS, r, lr.rcoef) == 0) {
272                          VCOPY(lr.rdir, nd.prdir);
273                          rayvalue(&lr);
274 <                        multcolor(lr.rcol, lr.rcoef);
275 <                        addcolor(r->rcol, lr.rcol);
276 <                        transtest *= bright(lr.rcol);
277 <                        transdist = r->rot + lr.rt;
274 >                        smultscolor(lr.rcol, lr.rcoef);
275 >                        saddscolor(r->rcol, lr.rcol);
276 >                        if (nd.tspec >= 1.0-FTINY) {
277 >                                                /* completely transparent */
278 >                                smultscolor(lr.mcol, lr.rcoef);
279 >                                copyscolor(r->mcol, lr.mcol);
280 >                                r->rmt = r->rot + lr.rmt;
281 >                                r->rxt = r->rot + lr.rxt;
282 >                        } else if (nd.tspec > nd.tdiff + nd.rdiff)
283 >                                r->rxt = r->rot + raydistance(&lr);
284                  }
285 <        } else
273 <                transtest = 0;
285 >        }
286  
287 <        if (r->crtype & SHADOW) {               /* the rest is shadow */
276 <                r->rt = transdist;
287 >        if (r->crtype & SHADOW)                 /* the rest is shadow */
288                  return(1);
278 –        }
289                                                  /* get specular reflection */
290          if (nd.rspec > FTINY) {
291                  nd.specfl |= SP_REFL;
292                                                  /* compute specular color */
293                  if (m->otype != MAT_METAL) {
294 <                        setcolor(nd.scolor, nd.rspec, nd.rspec, nd.rspec);
294 >                        setscolor(nd.scolor, nd.rspec, nd.rspec, nd.rspec);
295                  } else if (fest > FTINY) {
296 <                        d = nd.rspec*(1. - fest);
297 <                        for (i = 0; i < 3; i++)
296 >                        d = m->oargs.farg[3]*(1. - fest);
297 >                        for (i = NCSAMP; i--; )
298                                  nd.scolor[i] = fest + nd.mcolor[i]*d;
299                  } else {
300 <                        copycolor(nd.scolor, nd.mcolor);
301 <                        scalecolor(nd.scolor, nd.rspec);
300 >                        copyscolor(nd.scolor, nd.mcolor);
301 >                        scalescolor(nd.scolor, nd.rspec);
302                  }
303                                                  /* check threshold */
304                  if (!(nd.specfl & SP_PURE) && specthresh >= nd.rspec-FTINY)
305                          nd.specfl |= SP_RBLT;
296 –                                                /* compute reflected ray */
297 –                VSUM(nd.vrefl, r->rdir, nd.pnorm, 2.*nd.pdot);
298 –                                                /* penetration? */
299 –                if (hastexture && DOT(nd.vrefl, r->ron) <= FTINY)
300 –                        VSUM(nd.vrefl, r->rdir, r->ron, 2.*r->rod);
301 –                checknorm(nd.vrefl);
306          }
307                                                  /* reflected ray */
308          if ((nd.specfl&(SP_REFL|SP_PURE|SP_RBLT)) == (SP_REFL|SP_PURE)) {
309                  RAY  lr;
310                  if (rayorigin(&lr, REFLECTED, r, nd.scolor) == 0) {
311 <                        VCOPY(lr.rdir, nd.vrefl);
311 >                                                /* compute reflected ray */
312 >                        VSUM(lr.rdir, r->rdir, nd.pnorm, 2.*nd.pdot);
313 >                                                /* penetration? */
314 >                        if (hastexture && DOT(lr.rdir, r->ron) <= FTINY)
315 >                                VSUM(lr.rdir, r->rdir, r->ron, 2.*r->rod);
316 >                        checknorm(lr.rdir);
317                          rayvalue(&lr);
318 <                        multcolor(lr.rcol, lr.rcoef);
319 <                        addcolor(r->rcol, lr.rcol);
320 <                        if (!hastexture && nd.specfl & SP_FLAT) {
321 <                                mirtest = 2.*bright(lr.rcol);
322 <                                mirdist = r->rot + lr.rt;
323 <                        }
318 >                        smultscolor(lr.rcol, lr.rcoef);
319 >                        copyscolor(r->mcol, lr.rcol);
320 >                        saddscolor(r->rcol, lr.rcol);
321 >                        r->rmt = r->rot;
322 >                        if (nd.specfl & SP_FLAT && r->crtype & AMBIENT)
323 >                                r->rmt += raydistance(&lr);
324                  }
325          }
317 –                                                /* diffuse reflection */
318 –        nd.rdiff = 1.0 - nd.trans - nd.rspec;
326  
327          if (nd.specfl & SP_PURE && nd.rdiff <= FTINY && nd.tdiff <= FTINY)
328                  return(1);                      /* 100% pure specular */
329  
330          if (!(nd.specfl & SP_PURE))
331 <                gaussamp(r, &nd);               /* checks *BLT flags */
331 >                gaussamp(&nd);                  /* checks *BLT flags */
332  
333          if (nd.rdiff > FTINY) {         /* ambient from this side */
334 <                copycolor(ctmp, nd.mcolor);     /* modified by material color */
335 <                if (nd.specfl & SP_RBLT)
336 <                        scalecolor(ctmp, 1.0-nd.trans);
337 <                else
338 <                        scalecolor(ctmp, nd.rdiff);
339 <                multambient(ctmp, r, hastexture ? nd.pnorm : r->ron);
333 <                addcolor(r->rcol, ctmp);        /* add to returned color */
334 >                copyscolor(sctmp, nd.mcolor);   /* modified by material color */
335 >                scalescolor(sctmp, nd.rdiff);
336 >                if (nd.specfl & SP_RBLT)        /* add in specular as well? */
337 >                        saddscolor(sctmp, nd.scolor);
338 >                multambient(sctmp, r, nd.pnorm);
339 >                saddscolor(r->rcol, sctmp);     /* add to returned color */
340          }
341          if (nd.tdiff > FTINY) {         /* ambient from other side */
342 <                copycolor(ctmp, nd.mcolor);     /* modified by color */
343 <                if (nd.specfl & SP_TBLT)
344 <                        scalecolor(ctmp, nd.trans);
345 <                else
346 <                        scalecolor(ctmp, nd.tdiff);
347 <                flipsurface(r);
348 <                if (hastexture) {
349 <                        FVECT  bnorm;
350 <                        bnorm[0] = -nd.pnorm[0];
351 <                        bnorm[1] = -nd.pnorm[1];
352 <                        bnorm[2] = -nd.pnorm[2];
353 <                        multambient(ctmp, r, bnorm);
348 <                } else
349 <                        multambient(ctmp, r, r->ron);
350 <                addcolor(r->rcol, ctmp);
351 <                flipsurface(r);
342 >                FVECT  bnorm;
343 >                copyscolor(sctmp, nd.mcolor);   /* modified by color */
344 >                if (nd.specfl & SP_TBLT) {
345 >                        scalescolor(sctmp, nd.trans);
346 >                } else {
347 >                        scalescolor(sctmp, nd.tdiff);
348 >                }
349 >                bnorm[0] = -nd.pnorm[0];
350 >                bnorm[1] = -nd.pnorm[1];
351 >                bnorm[2] = -nd.pnorm[2];
352 >                multambient(sctmp, r, bnorm);
353 >                saddscolor(r->rcol, sctmp);
354          }
355                                          /* add direct component */
356          direct(r, dirnorm, &nd);
355 –                                        /* check distance */
356 –        d = bright(r->rcol);
357 –        if (transtest > d)
358 –                r->rt = transdist;
359 –        else if (mirtest > d)
360 –                r->rt = mirdist;
357  
358          return(1);
359   }
# Line 365 | Line 361 | m_normal(                      /* color a ray that hit something normal *
361  
362   static void
363   gaussamp(                       /* sample Gaussian specular */
364 <        RAY  *r,
369 <        register NORMDAT  *np
364 >        NORMDAT  *np
365   )
366   {
367          RAY  sr;
368          FVECT  u, v, h;
369          double  rv[2];
370          double  d, sinp, cosp;
371 <        COLOR   scol;
371 >        SCOLOR  scol;
372          int  maxiter, ntrials, nstarget, nstaken;
373 <        register int  i;
373 >        int  i;
374                                          /* quick test */
375          if ((np->specfl & (SP_REFL|SP_RBLT)) != SP_REFL &&
376                          (np->specfl & (SP_TRAN|SP_TBLT)) != SP_TRAN)
377                  return;
378                                          /* set up sample coordinates */
379 <        v[0] = v[1] = v[2] = 0.0;
385 <        for (i = 0; i < 3; i++)
386 <                if (np->pnorm[i] < 0.6 && np->pnorm[i] > -0.6)
387 <                        break;
388 <        v[i] = 1.0;
389 <        fcross(u, v, np->pnorm);
390 <        normalize(u);
379 >        getperpendicular(u, np->pnorm, rand_samp);
380          fcross(v, np->pnorm, u);
381                                          /* compute reflection */
382          if ((np->specfl & (SP_REFL|SP_RBLT)) == SP_REFL &&
383 <                        rayorigin(&sr, SPECULAR, r, np->scolor) == 0) {
383 >                        rayorigin(&sr, RSPECULAR, np->rp, np->scolor) == 0) {
384                  nstarget = 1;
385                  if (specjitter > 1.5) { /* multiple samples? */
386 <                        nstarget = specjitter*r->rweight + .5;
386 >                        nstarget = specjitter*np->rp->rweight + .5;
387                          if (sr.rweight <= minweight*nstarget)
388                                  nstarget = sr.rweight/minweight;
389                          if (nstarget > 1) {
390                                  d = 1./nstarget;
391 <                                scalecolor(sr.rcoef, d);
391 >                                scalescolor(sr.rcoef, d);
392                                  sr.rweight *= d;
393                          } else
394                                  nstarget = 1;
395                  }
396 <                setcolor(scol, 0., 0., 0.);
397 <                dimlist[ndims++] = (int)np->mp;
396 >                scolorblack(scol);
397 >                dimlist[ndims++] = (int)(size_t)np->mp;
398                  maxiter = MAXITER*nstarget;
399                  for (nstaken = ntrials = 0; nstaken < nstarget &&
400                                                  ntrials < maxiter; ntrials++) {
# Line 425 | Line 414 | gaussamp(                      /* sample Gaussian specular */
414                                  d = sqrt( np->alpha2 * -log(rv[1]) );
415                          for (i = 0; i < 3; i++)
416                                  h[i] = np->pnorm[i] + d*(cosp*u[i] + sinp*v[i]);
417 <                        d = -2.0 * DOT(h, r->rdir) / (1.0 + d*d);
418 <                        VSUM(sr.rdir, r->rdir, h, d);
417 >                        d = -2.0 * DOT(h, np->rp->rdir) / (1.0 + d*d);
418 >                        VSUM(sr.rdir, np->rp->rdir, h, d);
419                                                  /* sample rejection test */
420 <                        if ((d = DOT(sr.rdir, r->ron)) <= FTINY)
420 >                        if ((d = DOT(sr.rdir, np->rp->ron)) <= FTINY)
421                                  continue;
422                          checknorm(sr.rdir);
423                          if (nstarget > 1) {     /* W-G-M-D adjustment */
424 <                                rayclear(&sr);
424 >                                if (nstaken) rayclear(&sr);
425                                  rayvalue(&sr);
426 <                                d = 2./(1. + r->rod/d);
427 <                                scalecolor(sr.rcol, d);
428 <                                addcolor(scol, sr.rcol);
426 >                                d = 2./(1. + np->rp->rod/d);
427 >                                scalescolor(sr.rcol, d);
428 >                                saddscolor(scol, sr.rcol);
429                          } else {
430                                  rayvalue(&sr);
431 <                                multcolor(sr.rcol, sr.rcoef);
432 <                                addcolor(r->rcol, sr.rcol);
431 >                                smultscolor(sr.rcol, sr.rcoef);
432 >                                saddscolor(np->rp->rcol, sr.rcol);
433                          }
434                          ++nstaken;
435                  }
436                  if (nstarget > 1) {             /* final W-G-M-D weighting */
437 <                        multcolor(scol, sr.rcoef);
437 >                        smultscolor(scol, sr.rcoef);
438                          d = (double)nstarget/ntrials;
439 <                        scalecolor(scol, d);
440 <                        addcolor(r->rcol, scol);
439 >                        scalescolor(scol, d);
440 >                        saddscolor(np->rp->rcol, scol);
441                  }
442                  ndims--;
443          }
444                                          /* compute transmission */
445 <        copycolor(sr.rcoef, np->mcolor);        /* modified by color */
446 <        scalecolor(sr.rcoef, np->tspec);
445 >        copyscolor(sr.rcoef, np->mcolor);       /* modified by color */
446 >        scalescolor(sr.rcoef, np->tspec);
447          if ((np->specfl & (SP_TRAN|SP_TBLT)) == SP_TRAN &&
448 <                        rayorigin(&sr, SPECULAR, r, sr.rcoef) == 0) {
448 >                        rayorigin(&sr, TSPECULAR, np->rp, sr.rcoef) == 0) {
449                  nstarget = 1;
450                  if (specjitter > 1.5) { /* multiple samples? */
451 <                        nstarget = specjitter*r->rweight + .5;
451 >                        nstarget = specjitter*np->rp->rweight + .5;
452                          if (sr.rweight <= minweight*nstarget)
453                                  nstarget = sr.rweight/minweight;
454                          if (nstarget > 1) {
455                                  d = 1./nstarget;
456 <                                scalecolor(sr.rcoef, d);
456 >                                scalescolor(sr.rcoef, d);
457                                  sr.rweight *= d;
458                          } else
459                                  nstarget = 1;
460                  }
461 <                dimlist[ndims++] = (int)np->mp;
461 >                dimlist[ndims++] = (int)(size_t)np->mp;
462                  maxiter = MAXITER*nstarget;
463                  for (nstaken = ntrials = 0; nstaken < nstarget &&
464                                                  ntrials < maxiter; ntrials++) {
# Line 490 | Line 479 | gaussamp(                      /* sample Gaussian specular */
479                          for (i = 0; i < 3; i++)
480                                  sr.rdir[i] = np->prdir[i] + d*(cosp*u[i] + sinp*v[i]);
481                                                  /* sample rejection test */
482 <                        if (DOT(sr.rdir, r->ron) >= -FTINY)
482 >                        if (DOT(sr.rdir, np->rp->ron) >= -FTINY)
483                                  continue;
484                          normalize(sr.rdir);     /* OK, normalize */
485 <                        if (nstarget > 1)       /* multi-sampling */
485 >                        if (nstaken)            /* multi-sampling */
486                                  rayclear(&sr);
487                          rayvalue(&sr);
488 <                        multcolor(sr.rcol, sr.rcoef);
489 <                        addcolor(r->rcol, sr.rcol);
488 >                        smultscolor(sr.rcol, sr.rcoef);
489 >                        saddscolor(np->rp->rcol, sr.rcol);
490                          ++nstaken;
491                  }
492                  ndims--;

Diff Legend

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