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.62 by greg, Wed Nov 15 18:02:52 2023 UTC vs.
Revision 2.67 by greg, Thu Dec 19 23:25:28 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 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 288 | Line 285 | m_aniso(                       /* shade ray that hit something anisotropic
285          
286          if (nd.tdiff > FTINY) {         /* ambient from other side */
287                  FVECT  bnorm;
291 –
292 –                flipsurface(r);
288                  bnorm[0] = -nd.pnorm[0];
289                  bnorm[1] = -nd.pnorm[1];
290                  bnorm[2] = -nd.pnorm[2];
# Line 301 | Line 296 | m_aniso(                       /* shade ray that hit something anisotropic
296                  }
297                  multambient(sctmp, r, bnorm);
298                  saddscolor(r->rcol, sctmp);
304 –                flipsurface(r);
299          }
300                                          /* add direct component */
301          direct(r, diraniso, &nd);
# Line 324 | 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 348 | Line 342 | agaussamp(             /* sample anisotropic Gaussian specular */
342          FVECT  h;
343          double  rv[2];
344          double  d, sinp, cosp;
351 –        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, SPECULAR, np->rp, np->scolor) == 0) {
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 361 | Line 355 | agaussamp(             /* sample anisotropic Gaussian specular */
355                                  nstarget = sr.rweight/minweight;
356                          if (nstarget > 1) {
357                                  d = 1./nstarget;
358 <                                scalecolor(sr.rcoef, d);
358 >                                scalescolor(sr.rcoef, d);
359                                  sr.rweight *= d;
360                          } else
361                                  nstarget = 1;
# Line 369 | 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 384 | 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)
388 <                                d = 1.0;
389 <                        else
390 <                                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 424 | Line 415 | agaussamp(             /* sample anisotropic Gaussian specular */
415          copyscolor(sr.rcoef, np->mcolor);               /* modify by material color */
416          scalescolor(sr.rcoef, np->tspec);
417          if ((np->specfl & (SP_TRAN|SP_TBLT)) == SP_TRAN &&
418 <                        rayorigin(&sr, SPECULAR, np->rp, sr.rcoef) == 0) {
418 >                        rayorigin(&sr, TSPECULAR, np->rp, sr.rcoef) == 0) {
419                  nstarget = 1;
420                  if (specjitter > 1.5) { /* multiple samples? */
421                          nstarget = specjitter*np->rp->rweight + .5;
# Line 432 | Line 423 | agaussamp(             /* sample anisotropic Gaussian specular */
423                                  nstarget = sr.rweight/minweight;
424                          if (nstarget > 1) {
425                                  d = 1./nstarget;
426 <                                scalecolor(sr.rcoef, d);
426 >                                scalescolor(sr.rcoef, d);
427                                  sr.rweight *= d;
428                          } else
429                                  nstarget = 1;
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 463 | 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