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

Comparing ray/src/rt/aniso.c (file contents):
Revision 2.64 by greg, Fri Apr 5 01:10:26 2024 UTC vs.
Revision 2.68 by greg, Fri Dec 20 16:29:50 2024 UTC

# Line 49 | Line 49 | typedef struct {
49          short  specfl;          /* specularity flags, defined above */
50          SCOLOR  mcolor;         /* color of this material */
51          SCOLOR  scolor;         /* color of specular component */
52 –        FVECT  vrefl;           /* vector in reflected direction */
52          FVECT  prdir;           /* vector in transmitted direction */
53          FVECT  u, v;            /* u and v vectors orienting anisotropy */
54          double  u_alpha;        /* u roughness */
# Line 119 | Line 118 | diraniso(              /* compute source contribution */
118                   */
119                                                  /* add source width if flat */
120                  if (np->specfl & SP_FLAT)
121 <                        au2 = av2 = omega * (0.25/PI);
121 >                        au2 = av2 = (1. - dstrsrc) * omega * (0.25/PI);
122                  else
123                          au2 = av2 = 0.0;
124                  au2 += np->u_alpha*np->u_alpha;
# Line 161 | Line 160 | diraniso(              /* compute source contribution */
160                  if (dtmp > FTINY*FTINY) {
161                          dtmp1 = DOT(h,np->pnorm);
162                          dtmp = 1.0 - dtmp1*dtmp1/dtmp;
163 <                        if (dtmp > FTINY*FTINY) {
164 <                                dtmp1 = DOT(h,np->u);
165 <                                dtmp1 *= dtmp1 / au2;
166 <                                dtmp2 = DOT(h,np->v);
167 <                                dtmp2 *= dtmp2 / av2;
168 <                                dtmp = (dtmp1 + dtmp2) / dtmp;
169 <                        }
163 >                }
164 >                if (dtmp > FTINY*FTINY) {
165 >                        dtmp1 = DOT(h,np->u);
166 >                        dtmp1 *= dtmp1 / au2;
167 >                        dtmp2 = DOT(h,np->v);
168 >                        dtmp2 *= dtmp2 / av2;
169 >                        dtmp = (dtmp1 + dtmp2) / dtmp;
170 >                        dtmp = exp(-dtmp);
171                  } else
172 <                        dtmp = 0.0;
172 >                        dtmp = 1.0;
173                                                  /* Gaussian */
174 <                dtmp = exp(-dtmp) * (1.0/PI) * sqrt(-ldot/(np->pdot*au2*av2));
174 >                dtmp *= (1.0/PI) * sqrt(-ldot/(np->pdot*au2*av2));
175                                                  /* worth using? */
176                  if (dtmp > FTINY) {
177                          copyscolor(sctmp, np->mcolor);
# Line 237 | Line 237 | m_aniso(                       /* shade ray that hit something anisotropic
237                                                  /* check threshold */
238                  if (specthresh >= nd.rspec-FTINY)
239                          nd.specfl |= SP_RBLT;
240 –                                                /* compute refl. direction */
241 –                VSUM(nd.vrefl, r->rdir, nd.pnorm, 2.0*nd.pdot);
242 –                if (DOT(nd.vrefl, r->ron) <= FTINY)     /* penetration? */
243 –                        VSUM(nd.vrefl, r->rdir, r->ron, 2.0*r->rod);
240          }
241                                                  /* compute transmission */
242          if (m->otype == MAT_TRANS2) {
# Line 269 | Line 265 | m_aniso(                       /* shade ray that hit something anisotropic
265                                                  /* diffuse reflection */
266          nd.rdiff = 1.0 - nd.trans - nd.rspec;
267  
268 <        if (r->ro != NULL && isflat(r->ro->otype))
268 >        if (r->ro != NULL && isflat(r->ro->otype) &&
269 >                        DOT(r->pert,r->pert) <= FTINY*FTINY)
270                  nd.specfl |= SP_FLAT;
271  
272          getacoords(&nd);                        /* set up coordinates */
# Line 321 | Line 318 | getacoords(            /* set up coordinate system */
318                  np->u[i] = evalue(mf->ep[i]);
319          if ((errno == EDOM) | (errno == ERANGE))
320                  np->u[0] = np->u[1] = np->u[2] = 0.0;
321 <        if (mf->fxp != &unitxf)
321 >        else if (mf->fxp != &unitxf)
322                  multv3(np->u, np->u, mf->fxp->xfm);
323          fcross(np->v, np->pnorm, np->u);
324          if (normalize(np->v) == 0.0) {
# Line 345 | Line 342 | agaussamp(             /* sample anisotropic Gaussian specular */
342          FVECT  h;
343          double  rv[2];
344          double  d, sinp, cosp;
348 –        SCOLOR  scol;
345          int  maxiter, ntrials, nstarget, nstaken;
346          int  i;
347                                          /* compute reflection */
348          if ((np->specfl & (SP_REFL|SP_RBLT)) == SP_REFL &&
349                          rayorigin(&sr, RSPECULAR, np->rp, np->scolor) == 0) {
350 +                SCOLOR  scol;
351                  nstarget = 1;
352                  if (specjitter > 1.5) { /* multiple samples? */
353                          nstarget = specjitter*np->rp->rweight + .5;
# Line 366 | Line 363 | agaussamp(             /* sample anisotropic Gaussian specular */
363                  scolorblack(scol);
364                  dimlist[ndims++] = (int)(size_t)np->mp;
365                  maxiter = MAXITER*nstarget;
366 <                for (nstaken = ntrials = 0; nstaken < nstarget &&
367 <                                                ntrials < maxiter; ntrials++) {
366 >                for (nstaken = ntrials = 0; (nstaken < nstarget) &
367 >                                                (ntrials < maxiter); ntrials++) {
368                          if (ntrials)
369                                  d = frandom();
370                          else
# Line 381 | Line 378 | agaussamp(             /* sample anisotropic Gaussian specular */
378                          sinp *= d;
379                          if ((0. <= specjitter) & (specjitter < 1.))
380                                  rv[1] = 1.0 - specjitter*rv[1];
381 <                        if (rv[1] <= FTINY)
385 <                                d = 1.0;
386 <                        else
387 <                                d = sqrt(-log(rv[1]) /
381 >                        d = (rv[1] <= FTINY) ? 1.0 : sqrt( -log(rv[1]) /
382                                          (cosp*cosp/(np->u_alpha*np->u_alpha) +
383 <                                         sinp*sinp/(np->v_alpha*np->v_alpha)));
383 >                                         sinp*sinp/(np->v_alpha*np->v_alpha)) );
384                          for (i = 0; i < 3; i++)
385                                  h[i] = np->pnorm[i] +
386                                          d*(cosp*np->u[i] + sinp*np->v[i]);
# Line 436 | Line 430 | agaussamp(             /* sample anisotropic Gaussian specular */
430                  }
431                  dimlist[ndims++] = (int)(size_t)np->mp;
432                  maxiter = MAXITER*nstarget;
433 <                for (nstaken = ntrials = 0; nstaken < nstarget &&
434 <                                                ntrials < maxiter; ntrials++) {
433 >                for (nstaken = ntrials = 0; (nstaken < nstarget) &
434 >                                                (ntrials < maxiter); ntrials++) {
435                          if (ntrials)
436                                  d = frandom();
437                          else
# Line 460 | Line 454 | agaussamp(             /* sample anisotropic Gaussian specular */
454                          for (i = 0; i < 3; i++)
455                                  sr.rdir[i] = np->prdir[i] +
456                                                  d*(cosp*np->u[i] + sinp*np->v[i]);
457 <                        if (DOT(sr.rdir, np->rp->ron) >= -FTINY)
458 <                                continue;
457 >                        if (DOT(sr.rdir,np->rp->ron) >= -FTINY)
458 >                                continue;       /* reject sample */
459                          normalize(sr.rdir);     /* OK, normalize */
460                          if (nstaken)            /* multi-sampling */
461                                  rayclear(&sr);

Diff Legend

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