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.117 by greg, Sat Jan 28 19:08:56 2023 UTC vs.
Revision 2.118 by greg, Wed Nov 15 18:02:52 2023 UTC

# Line 44 | Line 44 | static long  lastpos = -1;             /* last flush position */
44  
45   #define  AMBFLUSH       (BUFSIZ/AMBVALSIZ)
46  
47 < #define  newambval()    (AMBVAL *)malloc(sizeof(AMBVAL))
47 > #define  AVSIZE         (sizeof(AMBVAL)-sizeof(SCOLOR)+sizeof(COLORV)*NCSAMP)
48 > #define  newambval()    (AMBVAL *)malloc(AVSIZE)
49  
50   #define  tfunc(x0, x, x1)       (((x)-(x0))/((x1)-(x0)))
51  
52 < static void initambfile(int creat);
52 > static void initambfile(int cre8);
53   static void avsave(AMBVAL *av);
54   static AMBVAL *avstore(AMBVAL  *aval);
55   static AMBTREE *newambtree(void);
# Line 62 | Line 63 | static void unloadatree(AMBTREE  *at, unloadtf_t *f);
63   static void sortambvals(void);
64  
65   static int      plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang);
66 < static double   sumambient(COLOR acol, RAY *r, FVECT rn, int al,
66 > static double   sumambient(SCOLOR acol, RAY *r, FVECT rn, int al,
67                                  AMBTREE *at, FVECT c0, double s);
68 < static int      makeambient(COLOR acol, RAY *r, FVECT rn, int al);
69 < static int      extambient(COLOR cr, AMBVAL *ap, FVECT pv, FVECT nv,
68 > static int      makeambient(SCOLOR acol, RAY *r, FVECT rn, int al);
69 > static int      extambient(SCOLOR cr, AMBVAL *ap, FVECT pv, FVECT nv,
70                                  FVECT uvw[3]);
71  
72   #ifdef  F_SETLKW
# Line 229 | Line 230 | ambnotify(                     /* record new modifier */
230  
231   void
232   multambient(            /* compute ambient component & multiply by coef. */
233 <        COLOR  aval,
233 >        SCOLOR  aval,
234          RAY  *r,
235          FVECT  nrm
236   )
237   {
238          static double  logAvgAbsorp = 1;
239          static int  rdepth = 0;                 /* ambient recursion */
240 <        COLOR   acol, caustic;
240 >        SCOLOR  acol, caustic;
241          int     i, ok;
242          double  d, l;
243  
# Line 252 | Line 253 | multambient(           /* compute ambient component & multiply
253          /* PMAP: Factor in specular-diffuse ambient (caustics) from photon
254           * map, if enabled and ray is primary, else caustic is zero.  Continue
255           * with RADIANCE ambient calculation */
256 <        copycolor(caustic, aval);
257 <        ambPmapCaustic(caustic, r, rdepth);
258 <        
256 > {/* XXX TEMPORARY */
257 >        COLOR   pmc;
258 >        scolor_color(pmc, aval);
259 >        ambPmapCaustic(pmc, r, rdepth);
260 >        setscolor(caustic, colval(pmc,RED), colval(pmc,GRN), colval(pmc,BLU));
261 > }
262          if (ambdiv <= 0)                        /* no ambient calculation */
263                  goto dumbamb;
264                                                  /* check number of bounces */
# Line 271 | Line 275 | multambient(           /* compute ambient component & multiply
275  
276                  if (nrm != r->ron && DOT(nrm,r->ron) < 0.9999)
277                          dgp = dgrad;            /* compute rotational grad. */
278 <                copycolor(acol, aval);
278 >                copyscolor(acol, aval);
279                  rdepth++;
280                  ok = doambient(acol, r, r->rweight,
281                                  uvd, NULL, NULL, dgp, NULL);
# Line 285 | Line 289 | multambient(           /* compute ambient component & multiply
289                          for (i = 3; i--; )
290                                  d += v1[i] * (dgp[0]*uvd[0][i] + dgp[1]*uvd[1][i]);
291                          if (d >= 0.05)
292 <                                scalecolor(acol, d);
292 >                                scalescolor(acol, d);
293                  }
294 <                copycolor(aval, acol);
294 >                copyscolor(aval, acol);
295  
296                  /* PMAP: add in caustic */
297 <                addcolor(aval, caustic);
297 >                saddscolor(aval, caustic);
298                  return;
299          }
300                                                  /* interpolate ambient value */
301 <        setcolor(acol, 0.0, 0.0, 0.0);
301 >        scolorblack(acol);
302          d = sumambient(acol, r, nrm, rdepth,
303                          &atrunk, thescene.cuorg, thescene.cusize);
304                          
305          if (d > FTINY) {
306 <                d = 1.0/d;
307 <                scalecolor(acol, d);
304 <                multcolor(aval, acol);
306 >                scalescolor(acol, 1.0/d);
307 >                smultscolor(aval, acol);
308  
309                  /* PMAP: add in caustic */
310 <                addcolor(aval, caustic);
310 >                saddscolor(aval, caustic);
311                  return;
312          }
313          
# Line 313 | Line 316 | multambient(           /* compute ambient component & multiply
316          rdepth--;
317          
318          if (ok) {
319 <                multcolor(aval, acol);          /* computed new value */
319 >                smultscolor(aval, acol);        /* computed new value */
320  
321                  /* PMAP: add in caustic */
322 <                addcolor(aval, caustic);
322 >                saddscolor(aval, caustic);
323                  return;
324          }
325          
326   dumbamb:                                        /* return global value */
327          if ((ambvwt <= 0) | (navsum == 0)) {
328 <                multcolor(aval, ambval);
328 >                smultcolor(aval, ambval);
329                  
330                  /* PMAP: add in caustic */
331 <                addcolor(aval, caustic);
331 >                saddscolor(aval, caustic);
332                  return;
333          }
334          
# Line 334 | Line 337 | dumbamb:                                       /* return global value */
337                  d = (log(l)*(double)ambvwt + avsum + logAvgAbsorp*navsum) /
338                                  (double)(ambvwt + navsum);
339                  d = exp(d) / l;
340 <                scalecolor(aval, d);
341 <                multcolor(aval, ambval);        /* apply color of ambval */
340 >                scalescolor(aval, d);
341 >                smultcolor(aval, ambval);       /* apply color of ambval */
342          } else {
343                  d = exp( avsum/(double)navsum + logAvgAbsorp );
344 <                scalecolor(aval, d);            /* neutral color */
344 >                scalescolor(aval, d);           /* neutral color */
345          }
346   }
347  
# Line 391 | Line 394 | plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang)
394  
395   static double
396   sumambient(             /* get interpolated ambient value */
397 <        COLOR  acol,
397 >        SCOLOR  acol,
398          RAY  *r,
399          FVECT  rn,
400          int  al,
# 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 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
# Line 510 | Line 513 | makeambient(           /* make a new ambient value for storage
513                  amb.weight *= AVGREFL;
514          if (r->rweight < 0.1*amb.weight)        /* heuristic override */
515                  amb.weight = 1.25*r->rweight;
516 <        setcolor(acol, AVGREFL, AVGREFL, AVGREFL);
516 >        setscolor(acol, AVGREFL, AVGREFL, AVGREFL);
517                                                  /* compute ambient */
518          i = doambient(acol, r, amb.weight,
519                          uvw, amb.rad, amb.gpos, amb.gdir, &amb.corral);
520 <        scalecolor(acol, 1./AVGREFL);           /* undo assumed reflectance */
520 >        scalescolor(acol, 1./AVGREFL);          /* undo assumed reflectance */
521          if (i <= 0 || amb.rad[0] <= FTINY)      /* no Hessian or zero radius */
522                  return(i);
523                                                  /* store value */
# Line 522 | Line 525 | makeambient(           /* make a new ambient value for storage
525          amb.ndir = encodedir(r->ron);
526          amb.udir = encodedir(uvw[0]);
527          amb.lvl = al;
528 <        copycolor(amb.val, acol);
528 >        copyscolor(amb.val, acol);
529                                                  /* insert into tree */
530          avsave(&amb);                           /* and save to file */
531          if (rn != r->ron) {                     /* texture */
# Line 535 | Line 538 | makeambient(           /* make a new ambient value for storage
538  
539   static int
540   extambient(             /* extrapolate value at pv, nv */
541 <        COLOR  cr,
541 >        SCOLOR  scr,
542          AMBVAL   *ap,
543          FVECT  pv,
544          FVECT  nv,
# Line 567 | Line 570 | extambient(            /* extrapolate value at pv, nv */
570                  d = min_d;
571          else if (d > max_d)
572                  d = max_d;
573 <        copycolor(cr, ap->val);
574 <        scalecolor(cr, d);
573 >        copyscolor(scr, ap->val);
574 >        scalescolor(scr, d);
575          return(d > min_d);
576   }
577  
# Line 643 | Line 646 | initambfile(           /* initialize ambient file */
646                                  srcsizerat, shadthresh, shadcert);
647                  fprintf(ambfp, "-ss %g -st %g -lr %d -lw %g ", specjitter,
648                                  specthresh, maxdepth, minweight);
649 +                fprintf(ambfp, "-cw %f %f -cs %d ", WLPART[3], WLPART[0], NCSAMP);
650                  if (octname != NULL)
651                          fputs(octname, ambfp);
652                  fputc('\n', ambfp);
653                  fprintf(ambfp, "SOFTWARE= %s\n", VersionID);
654                  fputnow(ambfp);
655 +                fputwlsplit(WLPART, ambfp);
656 +                fputncomp(NCSAMP, ambfp);
657                  fputformat(AMBFMT, ambfp);
658                  fputc('\n', ambfp);
659                  putambmagic(ambfp);
660 <        } else if (checkheader(ambfp, AMBFMT, NULL) < 0 || !hasambmagic(ambfp))
661 <                error(USER, "bad ambient file");
660 >        } else if (getheader(ambfp, amb_headline, NULL) < 0 || !hasambmagic(ambfp))
661 >                error(USER, "bad/incompatible ambient file");
662 >
663 >        if ((AMB_CNDX != CNDX) | (AMB_WLPART != WLPART)) {
664 >                if (setspectrsamp(AMB_CNDX, AMB_WLPART) < 0)
665 >                        error(USER, "bad wavelength sampling in ambient file");
666 >                if (AMB_CNDX[3] == CNDX[3] && FABSEQ(AMB_WLPART[0],WLPART[0]) &&
667 >                                        FABSEQ(AMB_WLPART[3],WLPART[3])) {
668 >                        AMB_CNDX = CNDX;
669 >                        AMB_WLPART = WLPART;            /* just the same */
670 >                } else
671 >                        error(WARNING, "different ambient file wavelength sampling");
672 >        }
673   }
674  
675  
# Line 685 | Line 702 | avstore(                               /* allocate memory and save aval */
702  
703          if ((av = newambval()) == NULL)
704                  error(SYSTEM, "out of memory in avstore");
705 <        *av = *aval;
705 >        memcpy(av, aval, AVSIZE);       /* AVSIZE <= sizeof(AMBVAL) */
706          av->next = NULL;
707          nambvals++;
708 <        d = bright(av->val);
708 >        d = pbright(av->val);
709          if (d > FTINY) {                /* add to log sum for averaging */
710                  avsum += log(d);
711                  navsum++;

Diff Legend

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