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

Comparing ray/src/rt/ambient.c (file contents):
Revision 2.114 by greg, Mon Apr 11 00:45:30 2022 UTC vs.
Revision 2.131 by greg, Thu Jan 23 22:03:08 2025 UTC

# Line 33 | Line 33 | double minarad;                /* minimum ambient radius */
33   static AMBTREE  atrunk;         /* our ambient trunk node */
34  
35   static FILE  *ambfp = NULL;     /* ambient file pointer */
36 < static int  nunflshed = 0;      /* number of unflushed ambient values */
36 > static int  nunflshed;          /* number of unflushed ambient values */
37  
38   static double  avsum = 0.;              /* computed ambient value sum (log) */
39   static unsigned int  navsum = 0;        /* number of values in avsum */
40   static unsigned int  nambvals = 0;      /* total number of indirect values */
41 – static unsigned int  nambshare = 0;     /* number of values from file */
41   static FILE  *ambinp = NULL;            /* auxiliary file for input */
42 < static long  lastpos = -1;              /* last flush position */
42 > static off_t  lastpos = -1;             /* last flush position */
43  
44   #define  AMBFLUSH       (BUFSIZ/AMBVALSIZ)
45  
46 < #define  newambval()    (AMBVAL *)malloc(sizeof(AMBVAL))
46 > #define  AVSIZE         (sizeof(AMBVAL)-sizeof(SCOLOR)+sizeof(COLORV)*NCSAMP)
47 > #define  newambval()    (AMBVAL *)malloc(AVSIZE)
48  
49 < #define  tfunc(lwr, x, upr)     (((x)-(lwr))/((upr)-(lwr)))
49 > #define  tfunc(x0, x, x1)       (((x)-(x0))/((x1)-(x0)))
50  
51 < static void initambfile(int creat);
51 > static void initambfile(int cre8);
52   static void avsave(AMBVAL *av);
53   static AMBVAL *avstore(AMBVAL  *aval);
54   static AMBTREE *newambtree(void);
# Line 62 | Line 62 | static void unloadatree(AMBTREE  *at, unloadtf_t *f);
62   static void sortambvals(void);
63  
64   static int      plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang);
65 < static double   sumambient(COLOR acol, RAY *r, FVECT rn, int al,
65 > static double   sumambient(SCOLOR acol, RAY *r, FVECT rn, int al,
66                                  AMBTREE *at, FVECT c0, double s);
67 < static int      makeambient(COLOR acol, RAY *r, FVECT rn, int al);
68 < static int      extambient(COLOR cr, AMBVAL *ap, FVECT pv, FVECT nv,
67 > static int      makeambient(SCOLOR acol, RAY *r, FVECT rn, int al);
68 > static int      extambient(SCOLOR cr, AMBVAL *ap, FVECT pv, FVECT nv,
69                                  FVECT uvw[3]);
70  
71   #ifdef  F_SETLKW
# Line 116 | Line 116 | void
116   setambient(void)                                /* initialize calculation */
117   {
118          int     readonly = 0;
119 <        long    flen;
119 >        off_t   flen;
120          AMBVAL  amb;
121                                                  /* make sure we're fresh */
122          ambdone();
# Line 136 | Line 136 | setambient(void)                               /* initialize calculation */
136                  readonly = (ambfp = fopen(ambfile, "r")) != NULL;
137          if (ambfp != NULL) {
138                  initambfile(0);                 /* file exists */
139 <                lastpos = ftell(ambfp);
139 >                lastpos = ftello(ambfp);
140                  while (readambval(&amb, ambfp))
141                          avstore(&amb);
142 –                nambshare = nambvals;           /* share loaded values */
142                  if (readonly) {
143                          sprintf(errmsg,
144                                  "loaded %u values from read-only ambient file",
# Line 150 | Line 149 | setambient(void)                               /* initialize calculation */
149                          return;                 /* avoid ambsync() */
150                  }
151                                                  /* align file pointer */
152 <                lastpos += (long)nambvals*AMBVALSIZ;
153 <                flen = lseek(fileno(ambfp), (off_t)0, SEEK_END);
152 >                lastpos += (off_t)nambvals*AMBVALSIZ;
153 >                flen = lseek(fileno(ambfp), 0, SEEK_END);
154                  if (flen != lastpos) {
155                          sprintf(errmsg,
156                          "ignoring last %ld values in ambient file (corrupted)",
157                                          (flen - lastpos)/AMBVALSIZ);
158                          error(WARNING, errmsg);
159 <                        fseek(ambfp, lastpos, SEEK_SET);
160 <                        ftruncate(fileno(ambfp), (off_t)lastpos);
159 >                        fseeko(ambfp, lastpos, SEEK_SET);
160 >                        ftruncate(fileno(ambfp), lastpos);
161                  }
162          } else if ((ambfp = fopen(ambfile, "w+")) != NULL) {
163                  initambfile(1);                 /* else create new file */
164                  fflush(ambfp);
165 <                lastpos = ftell(ambfp);
165 >                lastpos = ftello(ambfp);
166          } else {
167                  sprintf(errmsg, "cannot open ambient file \"%s\"", ambfile);
168                  error(SYSTEM, errmsg);
# Line 193 | Line 192 | ambdone(void)                  /* close ambient file and free memory
192          avsum = 0.;
193          navsum = 0;
194          nambvals = 0;
196 –        nambshare = 0;
195   }
196  
197  
# Line 229 | Line 227 | ambnotify(                     /* record new modifier */
227  
228   void
229   multambient(            /* compute ambient component & multiply by coef. */
230 <        COLOR  aval,
230 >        SCOLOR  aval,
231          RAY  *r,
232          FVECT  nrm
233   )
234   {
235          static double  logAvgAbsorp = 1;
236          static int  rdepth = 0;                 /* ambient recursion */
237 <        COLOR   acol, caustic;
237 >        SCOLOR  acol, caustic;
238          int     i, ok;
239          double  d, l;
240  
# Line 252 | Line 250 | multambient(           /* compute ambient component & multiply
250          /* PMAP: Factor in specular-diffuse ambient (caustics) from photon
251           * map, if enabled and ray is primary, else caustic is zero.  Continue
252           * with RADIANCE ambient calculation */
253 <        copycolor(caustic, aval);
254 <        ambPmapCaustic(caustic, r, rdepth);
255 <        
253 > {/* XXX TEMPORARY */
254 >        COLOR   pmc;
255 >        scolor_color(pmc, aval);
256 >        ambPmapCaustic(pmc, r, rdepth);
257 >        setscolor(caustic, colval(pmc,RED), colval(pmc,GRN), colval(pmc,BLU));
258 > }
259          if (ambdiv <= 0)                        /* no ambient calculation */
260                  goto dumbamb;
261                                                  /* check number of bounces */
# Line 265 | Line 266 | multambient(           /* compute ambient component & multiply
266                          ambincl != inset(ambset, r->ro->omod))
267                  goto dumbamb;
268  
269 <        if (ambacc <= FTINY) {                  /* no ambient storage */
270 <                FVECT   uvd[2];
269 >        if (ambacc <= FTINY) {                  /* no ambient storage? */
270 >                double  rdot = DOT(nrm,r->ron);
271 >                int     sgn = 1 - 2*(rdot < 0);
272                  float   dgrad[2], *dgp = NULL;
273 +                FVECT   uvd[2];
274  
275 <                if (nrm != r->ron && DOT(nrm,r->ron) < 0.9999)
275 >                if (sgn*rdot < 0.9999)
276                          dgp = dgrad;            /* compute rotational grad. */
277 <                copycolor(acol, aval);
277 >                copyscolor(acol, aval);
278                  rdepth++;
279 <                ok = doambient(acol, r, r->rweight,
279 >                ok = doambient(acol, r, r->rweight*sgn,
280                                  uvd, NULL, NULL, dgp, NULL);
281                  rdepth--;
282                  if (!ok)
# Line 283 | Line 286 | multambient(           /* compute ambient component & multiply
286                          VCROSS(v1, r->ron, nrm);
287                          d = 1.0;
288                          for (i = 3; i--; )
289 <                                d += v1[i] * (dgp[0]*uvd[0][i] + dgp[1]*uvd[1][i]);
289 >                                d += sgn*v1[i] * (dgp[0]*uvd[0][i] + dgp[1]*uvd[1][i]);
290                          if (d >= 0.05)
291 <                                scalecolor(acol, d);
291 >                                scalescolor(acol, d);
292                  }
293 <                copycolor(aval, acol);
293 >                copyscolor(aval, acol);
294  
295                  /* PMAP: add in caustic */
296 <                addcolor(aval, caustic);
296 >                saddscolor(aval, caustic);
297                  return;
298          }
299                                                  /* interpolate ambient value */
300 <        setcolor(acol, 0.0, 0.0, 0.0);
300 >        scolorblack(acol);
301          d = sumambient(acol, r, nrm, rdepth,
302                          &atrunk, thescene.cuorg, thescene.cusize);
303                          
304          if (d > FTINY) {
305 <                d = 1.0/d;
306 <                scalecolor(acol, d);
304 <                multcolor(aval, acol);
305 >                scalescolor(acol, 1.0/d);
306 >                smultscolor(aval, acol);
307  
308                  /* PMAP: add in caustic */
309 <                addcolor(aval, caustic);
309 >                saddscolor(aval, caustic);
310                  return;
311          }
312          
# Line 313 | Line 315 | multambient(           /* compute ambient component & multiply
315          rdepth--;
316          
317          if (ok) {
318 <                multcolor(aval, acol);          /* computed new value */
318 >                smultscolor(aval, acol);        /* computed new value */
319  
320                  /* PMAP: add in caustic */
321 <                addcolor(aval, caustic);
321 >                saddscolor(aval, caustic);
322                  return;
323          }
324          
325   dumbamb:                                        /* return global value */
326          if ((ambvwt <= 0) | (navsum == 0)) {
327 <                multcolor(aval, ambval);
327 >                smultcolor(aval, ambval);
328                  
329                  /* PMAP: add in caustic */
330 <                addcolor(aval, caustic);
330 >                saddscolor(aval, caustic);
331                  return;
332          }
333          
# Line 334 | Line 336 | dumbamb:                                       /* return global value */
336                  d = (log(l)*(double)ambvwt + avsum + logAvgAbsorp*navsum) /
337                                  (double)(ambvwt + navsum);
338                  d = exp(d) / l;
339 <                scalecolor(aval, d);
340 <                multcolor(aval, ambval);        /* apply color of ambval */
339 >                scalescolor(aval, d);
340 >                smultcolor(aval, ambval);       /* apply color of ambval */
341          } else {
342                  d = exp( avsum/(double)navsum + logAvgAbsorp );
343 <                scalecolor(aval, d);            /* neutral color */
343 >                scalescolor(aval, d);           /* neutral color */
344          }
345   }
346  
# Line 377 | Line 379 | plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang)
379          rtst.rmax = normalize(rtst.rdir);       /* short ray test */
380          while (localhit(&rtst, &thescene)) {    /* check for occluder */
381                  OBJREC  *m = findmaterial(rtst.ro);
382 <                if (m != NULL && !istransp(m->otype) && !isBSDFproxy(m) &&
382 >                if (m != NULL && !istransp(m) && !isBSDFproxy(m) &&
383                                  (rtst.clipset == NULL ||
384                                          !inset(rtst.clipset, rtst.ro->omod)))
385                          return(1);              /* plug light leak */
# Line 391 | Line 393 | plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang)
393  
394   static double
395   sumambient(             /* get interpolated ambient value */
396 <        COLOR  acol,
396 >        SCOLOR  acol,
397          RAY  *r,
398          FVECT  rn,
399          int  al,
# Line 401 | Line 403 | sumambient(            /* get interpolated ambient value */
403   )
404   {                       /* initial limit is 10 degrees plus ambacc radians */
405          const double    minangle = 10.0 * PI/180.;
406 +        const int       sgn = 1 - 2*(DOT(r->ron,rn) < 0);
407          double          maxangle = minangle + ambacc;
408          double          wsum = 0.0;
409          FVECT           ck0;
# Line 424 | Line 427 | sumambient(            /* get interpolated ambient value */
427                                                          at->kid+i, ck0, s);
428                  }
429                                          /* good enough? */
430 <                if (wsum >= 0.05 && s > minarad*10.0)
430 >                if ((wsum >= 0.05) & (s*ambacc > minarad))
431                          return(wsum);
432          }
433                                          /* adjust maximum angle */
# Line 433 | Line 436 | sumambient(            /* get interpolated ambient value */
436                                          /* sum this node */
437          for (av = at->alist; av != NULL; av = av->next) {
438                  double  u, v, d, delta_r2, delta_t2;
439 <                COLOR   ct;
439 >                SCOLOR  sct;
440                  FVECT   uvw[3];
441                  /*
442                   *  Ambient level test
# Line 445 | Line 448 | sumambient(            /* get interpolated ambient value */
448                   *  Direction test using unperturbed normal
449                   */
450                  decodedir(uvw[2], av->ndir);
451 <                d = DOT(uvw[2], r->ron);
451 >                d = sgn * DOT(uvw[2], r->ron);
452                  if (d <= 0.0)           /* >= 90 degrees */
453                          continue;
454                  delta_r2 = 2.0 - 2.0*d; /* approx. radians^2 */
# Line 456 | Line 459 | sumambient(            /* get interpolated ambient value */
459                   */
460                  VSUB(ck0, r->rop, av->pos);
461                  d = DOT(ck0, uvw[2]);
462 <                if (d < -minarad*ambacc-.001)
462 >                if (d < -minarad*ambacc)
463                          continue;
464                  d /= av->rad[0];
465                  delta_t2 = d*d;
# Line 481 | Line 484 | sumambient(            /* get interpolated ambient value */
484                  /*
485                   *  Extrapolate value and compute final weight (hat function)
486                   */
487 <                if (!extambient(ct, av, r->rop, rn, uvw))
487 >                if (!extambient(sct, av, r->rop, rn, uvw))
488                          continue;
489                  d = tfunc(maxangle, sqrt(delta_r2), 0.0) *
490                          tfunc(ambacc, sqrt(delta_t2), 0.0);
491 <                scalecolor(ct, d);
492 <                addcolor(acol, ct);
491 >                scalescolor(sct, d);
492 >                saddscolor(acol, sct);
493                  wsum += d;
494          }
495          return(wsum);
# Line 495 | Line 498 | sumambient(            /* get interpolated ambient value */
498  
499   static int
500   makeambient(            /* make a new ambient value for storage */
501 <        COLOR  acol,
501 >        SCOLOR  acol,
502          RAY  *r,
503          FVECT  rn,
504          int  al
505   )
506   {
507 +        int     sgn = 1 - 2*(DOT(r->ron,rn) < 0);
508          AMBVAL  amb;
509          FVECT   uvw[3];
510          int     i;
# Line 510 | Line 514 | makeambient(           /* make a new ambient value for storage
514                  amb.weight *= AVGREFL;
515          if (r->rweight < 0.1*amb.weight)        /* heuristic override */
516                  amb.weight = 1.25*r->rweight;
517 <        setcolor(acol, AVGREFL, AVGREFL, AVGREFL);
517 >        setscolor(acol, AVGREFL, AVGREFL, AVGREFL);
518                                                  /* compute ambient */
519 <        i = doambient(acol, r, amb.weight,
519 >        i = doambient(acol, r, amb.weight*sgn,
520                          uvw, amb.rad, amb.gpos, amb.gdir, &amb.corral);
521 <        scalecolor(acol, 1./AVGREFL);           /* undo assumed reflectance */
521 >        scalescolor(acol, 1./AVGREFL);          /* undo assumed reflectance */
522          if (i <= 0 || amb.rad[0] <= FTINY)      /* no Hessian or zero radius */
523                  return(i);
524 +        uvw[2][0] = sgn*r->ron[0];              /* orient unperturbed normal */
525 +        uvw[2][1] = sgn*r->ron[1];
526 +        uvw[2][2] = sgn*r->ron[2];
527                                                  /* store value */
528          VCOPY(amb.pos, r->rop);
529 <        amb.ndir = encodedir(r->ron);
529 >        amb.ndir = encodedir(uvw[2]);
530          amb.udir = encodedir(uvw[0]);
531          amb.lvl = al;
532 <        copycolor(amb.val, acol);
533 <                                                /* insert into tree */
534 <        avsave(&amb);                           /* and save to file */
528 <        if (rn != r->ron) {                     /* texture */
529 <                VCOPY(uvw[2], r->ron);
532 >        copyscolor(amb.val, acol);
533 >        avsave(&amb);                           /* insert and save to file */
534 >        if (DOT(uvw[2],rn) < 0.9999)            /* texture? */
535                  extambient(acol, &amb, r->rop, rn, uvw);
531 –        }
536          return(1);
537   }
538  
539  
540   static int
541   extambient(             /* extrapolate value at pv, nv */
542 <        COLOR  cr,
542 >        SCOLOR  scr,
543          AMBVAL   *ap,
544          FVECT  pv,
545          FVECT  nv,
# Line 567 | Line 571 | extambient(            /* extrapolate value at pv, nv */
571                  d = min_d;
572          else if (d > max_d)
573                  d = max_d;
574 <        copycolor(cr, ap->val);
575 <        scalecolor(cr, d);
574 >        copyscolor(scr, ap->val);
575 >        scalescolor(scr, d);
576          return(d > min_d);
577   }
578  
# Line 623 | Line 627 | initambfile(           /* initialize ambient file */
627   {
628          extern char  *progname, *octname;
629          static char  *mybuf = NULL;
630 +        int  ntries = 3;
631  
632 +        if (!AMBFLUSH)
633 +                error(INTERNAL, "BUFSIZ too small in initambfile");
634   #ifdef  F_SETLKW
635          aflock(cre8 ? F_WRLCK : F_RDLCK);
636   #endif
# Line 631 | Line 638 | initambfile(           /* initialize ambient file */
638          if (mybuf == NULL)
639                  mybuf = (char *)bmalloc(BUFSIZ+8);
640          setbuf(ambfp, mybuf);
641 +        nunflshed = 0;
642 + retry:
643          if (cre8) {                     /* new file */
644                  newheader("RADIANCE", ambfp);
645                  fprintf(ambfp, "%s -av %g %g %g -aw %d -ab %d -aa %g ",
# Line 639 | Line 648 | initambfile(           /* initialize ambient file */
648                                  ambvwt, ambounce, ambacc);
649                  fprintf(ambfp, "-ad %d -as %d -ar %d ",
650                                  ambdiv, ambssamp, ambres);
651 <                fprintf(ambfp, "-dt %g -dc %g -ss %g -lr %d -lw %g ",
652 <                                shadthresh, shadcert, specjitter,
653 <                                maxdepth, minweight);
651 >                fprintf(ambfp, "-dr %d -ds %g -dt %g -dc %g ", directrelay,
652 >                                srcsizerat, shadthresh, shadcert);
653 >                fprintf(ambfp, "-ss %g -st %g -lr %d -lw %g ", specjitter,
654 >                                specthresh, maxdepth, minweight);
655 >                fprintf(ambfp, "-cw %g %g -cs %d ", WLPART[3], WLPART[0], NCSAMP);
656                  if (octname != NULL)
657                          fputs(octname, ambfp);
658 <                fputc('\n', ambfp);
658 >                fputc('\n', ambfp);     /* end of command line, not header! */
659                  fprintf(ambfp, "SOFTWARE= %s\n", VersionID);
660                  fputnow(ambfp);
661 +                AMB_CNDX = CNDX;        /* use current spectral sampling */
662 +                AMB_WLPART = WLPART;
663 +                fputwlsplit(WLPART, ambfp);
664 +                fputncomp(NCSAMP, ambfp);
665                  fputformat(AMBFMT, ambfp);
666                  fputc('\n', ambfp);
667                  putambmagic(ambfp);
668 <        } else if (checkheader(ambfp, AMBFMT, NULL) < 0 || !hasambmagic(ambfp))
669 <                error(USER, "bad ambient file");
668 >        } else if (getheader(ambfp, amb_headline, NULL) < 0 || !hasambmagic(ambfp)) {
669 >                if (--ntries > 0 && ftell(ambfp) == 0) {
670 > #ifdef  F_SETLKW
671 >                        aflock(F_UNLCK);
672 >                        clearerr(ambfp);
673 >                        sleep(2);
674 >                        aflock(F_RDLCK);
675 > #else
676 >                        clearerr(ambfp);
677 >                        sleep(2);
678 > #endif
679 >                        goto retry;
680 >                }
681 >                error(USER, "bad/incompatible ambient file");
682 >        }
683 >        if ((AMB_CNDX != CNDX) | (AMB_WLPART != WLPART)) {
684 >                if (setspectrsamp(AMB_CNDX, AMB_WLPART) < 0)
685 >                        error(USER, "bad wavelength sampling in ambient file");
686 >                if (AMB_CNDX[3] == CNDX[3] && FABSEQ(AMB_WLPART[0],WLPART[0]) &&
687 >                                        FABSEQ(AMB_WLPART[3],WLPART[3])) {
688 >                        AMB_CNDX = CNDX;
689 >                        AMB_WLPART = WLPART;            /* just the same */
690 >                } else
691 >                        error(WARNING, "different ambient file wavelength sampling");
692 >        }
693   }
694  
695  
# Line 684 | Line 722 | avstore(                               /* allocate memory and save aval */
722  
723          if ((av = newambval()) == NULL)
724                  error(SYSTEM, "out of memory in avstore");
725 <        *av = *aval;
725 >        memcpy(av, aval, AVSIZE);       /* AVSIZE <= sizeof(AMBVAL) */
726          av->next = NULL;
727          nambvals++;
728 <        d = bright(av->val);
728 >        d = pbright(av->val);
729          if (d > FTINY) {                /* add to log sum for averaging */
730                  avsum += log(d);
731                  navsum++;
# Line 800 | Line 838 | aflock(                        /* lock/unlock ambient file */
838   int
839   ambsync(void)                   /* synchronize ambient file */
840   {
841 <        long  flen;
841 >        off_t  flen;
842          AMBVAL  avs;
843          int  n;
844  
# Line 809 | Line 847 | ambsync(void)                  /* synchronize ambient file */
847                                  /* gain appropriate access */
848          aflock(nunflshed ? F_WRLCK : F_RDLCK);
849                                  /* see if file has grown */
850 <        if ((flen = lseek(fileno(ambfp), (off_t)0, SEEK_END)) < 0)
850 >        if ((flen = lseek(fileno(ambfp), 0, SEEK_END)) < 0)
851                  goto seekerr;
852          if ((n = flen - lastpos) > 0) {         /* file has grown */
853                  if (ambinp == NULL) {           /* get new file pointer */
# Line 817 | Line 855 | ambsync(void)                  /* synchronize ambient file */
855                          if (ambinp == NULL)
856                                  error(SYSTEM, "fopen failed in ambsync");
857                  }
858 <                if (fseek(ambinp, lastpos, SEEK_SET) < 0)
858 >                if (fseeko(ambinp, lastpos, SEEK_SET) < 0)
859                          goto seekerr;
860                  while (n >= AMBVALSIZ) {        /* load contributed values */
861                          if (!readambval(&avs, ambinp)) {
# Line 831 | Line 869 | ambsync(void)                  /* synchronize ambient file */
869                          n -= AMBVALSIZ;
870                  }
871                  lastpos = flen - n;             /* check alignment */
872 <                if (n && lseek(fileno(ambfp), (off_t)lastpos, SEEK_SET) < 0)
872 >                if (n && lseek(fileno(ambfp), lastpos, SEEK_SET) < 0)
873                          goto seekerr;
874          }
875          n = fflush(ambfp);                      /* calls write() at last */
876 <        lastpos += (long)nunflshed*AMBVALSIZ;
876 >        lastpos += (off_t)nunflshed*AMBVALSIZ;
877          aflock(F_UNLCK);                        /* release file */
878          nunflshed = 0;
879          return(n);

Diff Legend

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