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.70 by greg, Thu Sep 22 02:15:56 2011 UTC vs.
Revision 2.99 by greg, Thu Mar 3 22:44:10 2016 UTC

# Line 1 | Line 1
1 – #ifndef lint
1   static const char       RCSid[] = "$Id$";
3 – #endif
2   /*
3   *  ambient.c - routines dealing with ambient (inter-reflected) component.
4   *
# Line 17 | Line 15 | static const char      RCSid[] = "$Id$";
15   #include  "resolu.h"
16   #include  "ambient.h"
17   #include  "random.h"
18 + #include  "pmapamb.h"
19  
20   #ifndef  OCTSCALE
21   #define  OCTSCALE       1.0     /* ceil((valid rad.)/(cube size)) */
# Line 39 | Line 38 | static int  nunflshed = 0;     /* number of unflushed ambi
38  
39   #ifndef SORT_THRESH
40   #ifdef SMLMEM
41 < #define SORT_THRESH     ((3L<<20)/sizeof(AMBVAL))
41 > #define SORT_THRESH     ((16L<<20)/sizeof(AMBVAL))
42   #else
43 < #define SORT_THRESH     ((9L<<20)/sizeof(AMBVAL))
43 > #define SORT_THRESH     ((64L<<20)/sizeof(AMBVAL))
44   #endif
45   #endif
46   #ifndef SORT_INTVL
# Line 51 | Line 50 | static int  nunflshed = 0;     /* number of unflushed ambi
50   #define MAX_SORT_INTVL  (SORT_INTVL<<6)
51   #endif
52  
53 +
54   static double  avsum = 0.;              /* computed ambient value sum (log) */
55   static unsigned int  navsum = 0;        /* number of values in avsum */
56   static unsigned int  nambvals = 0;      /* total number of indirect values */
# Line 84 | Line 84 | static AMBVAL *avstore(AMBVAL  *aval);
84   static AMBTREE *newambtree(void);
85   static void freeambtree(AMBTREE  *atp);
86  
87 < typedef void unloadtf_t(void *);
87 > typedef void unloadtf_t(AMBVAL *);
88   static unloadtf_t avinsert;
89   static unloadtf_t av2list;
90 + static unloadtf_t avfree;
91   static void unloadatree(AMBTREE  *at, unloadtf_t *f);
92  
93   static int aposcmp(const void *avp1, const void *avp2);
# Line 98 | Line 99 | static void aflock(int  typ);
99   #endif
100  
101  
102 < extern void
102 > void
103   setambres(                              /* set ambient resolution */
104          int  ar
105   )
# Line 107 | Line 108 | setambres(                             /* set ambient resolution */
108                                                  /* set min & max radii */
109          if (ar <= 0) {
110                  minarad = 0;
111 <                maxarad = thescene.cusize / 2.0;
111 >                maxarad = thescene.cusize*0.2;
112          } else {
113                  minarad = thescene.cusize / ar;
114 <                maxarad = 64 * minarad;                 /* heuristic */
115 <                if (maxarad > thescene.cusize / 2.0)
116 <                        maxarad = thescene.cusize / 2.0;
114 >                maxarad = 64.0 * minarad;               /* heuristic */
115 >                if (maxarad > thescene.cusize*0.2)
116 >                        maxarad = thescene.cusize*0.2;
117          }
118          if (minarad <= FTINY)
119 <                minarad = 10*FTINY;
119 >                minarad = 10.0*FTINY;
120          if (maxarad <= minarad)
121 <                maxarad = 64 * minarad;
121 >                maxarad = 64.0 * minarad;
122   }
123  
124  
125 < extern void
125 > void
126   setambacc(                              /* set ambient accuracy */
127          double  newa
128   )
129   {
130 <        double  ambdiff;
131 <
132 <        if (newa < 0.0)
133 <                newa = 0.0;
134 <        ambdiff = fabs(newa - ambacc);
135 <        if (ambdiff >= .01 && (ambacc = newa) > FTINY && nambvals > 0)
136 <                sortambvals(1);                 /* rebuild tree */
130 >        static double   olda;           /* remember previous setting here */
131 >        
132 >        newa *= (newa > 0);
133 >        if (fabs(newa - olda) >= .05*(newa + olda)) {
134 >                ambacc = newa;
135 >                if (nambvals > 0)
136 >                        sortambvals(1);         /* rebuild tree */
137 >        }
138   }
139  
140  
141 < extern void
141 > void
142   setambient(void)                                /* initialize calculation */
143   {
144          int     readonly = 0;
# Line 162 | Line 164 | setambient(void)                               /* initialize calculation */
164                  initambfile(0);                 /* file exists */
165                  lastpos = ftell(ambfp);
166                  while (readambval(&amb, ambfp))
167 <                        avinsert(avstore(&amb));
167 >                        avstore(&amb);
168                  nambshare = nambvals;           /* share loaded values */
169                  if (readonly) {
170                          sprintf(errmsg,
# Line 200 | Line 202 | setambient(void)                               /* initialize calculation */
202   }
203  
204  
205 < extern void
205 > void
206   ambdone(void)                   /* close ambient file and free memory */
207   {
208          if (ambfp != NULL) {            /* close ambient file */
# Line 214 | Line 216 | ambdone(void)                  /* close ambient file and free memory
216                  lastpos = -1;
217          }
218                                          /* free ambient tree */
219 <        unloadatree(&atrunk, free);
219 >        unloadatree(&atrunk, avfree);
220 >        freeambtree(NULL);
221                                          /* reset state variables */
222          avsum = 0.;
223          navsum = 0;
# Line 226 | Line 229 | ambdone(void)                  /* close ambient file and free memory
229   }
230  
231  
232 < extern void
232 > void
233   ambnotify(                      /* record new modifier */
234          OBJECT  obj
235   )
# Line 255 | Line 258 | ambnotify(                     /* record new modifier */
258                  }
259   }
260  
261 + /************ THE FOLLOWING ROUTINES DIFFER BETWEEN NEW & OLD ***************/
262  
263 < extern void
263 > #ifndef OLDAMB
264 >
265 > #define tfunc(lwr, x, upr)      (((x)-(lwr))/((upr)-(lwr)))
266 >
267 > static int      plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang);
268 > static double   sumambient(COLOR acol, RAY *r, FVECT rn, int al,
269 >                                AMBTREE *at, FVECT c0, double s);
270 > static int      makeambient(COLOR acol, RAY *r, FVECT rn, int al);
271 > static int      extambient(COLOR cr, AMBVAL *ap, FVECT pv, FVECT nv,
272 >                                FVECT uvw[3]);
273 >
274 > void
275   multambient(            /* compute ambient component & multiply by coef. */
276          COLOR  aval,
277          RAY  *r,
# Line 264 | Line 279 | multambient(           /* compute ambient component & multiply
279   )
280   {
281          static int  rdepth = 0;                 /* ambient recursion */
282 <        COLOR   acol;
282 >        COLOR   acol, caustic;
283 >        int     ok;
284          double  d, l;
285  
286 +        /* PMAP: Factor in ambient from photon map, if enabled and ray is
287 +         * ambient. Return as all ambient components accounted for, else
288 +         * continue. */
289 +        if (ambPmap(aval, r, rdepth))
290 +                return;
291 +
292 +        /* PMAP: Factor in specular-diffuse ambient (caustics) from photon
293 +         * map, if enabled and ray is primary, else caustic is zero.  Continue
294 +         * with RADIANCE ambient calculation */
295 +        copycolor(caustic, aval);
296 +        ambPmapCaustic(caustic, r, rdepth);
297 +        
298          if (ambdiv <= 0)                        /* no ambient calculation */
299                  goto dumbamb;
300                                                  /* check number of bounces */
# Line 280 | Line 308 | multambient(           /* compute ambient component & multiply
308          if (ambacc <= FTINY) {                  /* no ambient storage */
309                  copycolor(acol, aval);
310                  rdepth++;
311 +                ok = doambient(acol, r, r->rweight,
312 +                                NULL, NULL, NULL, NULL, NULL);
313 +                rdepth--;
314 +                if (!ok)
315 +                        goto dumbamb;
316 +                copycolor(aval, acol);
317 +
318 +                /* PMAP: add in caustic */
319 +                addcolor(aval, caustic);
320 +                return;
321 +        }
322 +
323 +        if (tracktime)                          /* sort to minimize thrashing */
324 +                sortambvals(0);
325 +                                                /* interpolate ambient value */
326 +        setcolor(acol, 0.0, 0.0, 0.0);
327 +        d = sumambient(acol, r, nrm, rdepth,
328 +                        &atrunk, thescene.cuorg, thescene.cusize);
329 +                        
330 +        if (d > FTINY) {
331 +                d = 1.0/d;
332 +                scalecolor(acol, d);
333 +                multcolor(aval, acol);
334 +
335 +                /* PMAP: add in caustic */
336 +                addcolor(aval, caustic);
337 +                return;
338 +        }
339 +        
340 +        rdepth++;                               /* need to cache new value */
341 +        ok = makeambient(acol, r, nrm, rdepth-1);
342 +        rdepth--;
343 +        
344 +        if (ok) {
345 +                multcolor(aval, acol);          /* computed new value */
346 +
347 +                /* PMAP: add in caustic */
348 +                addcolor(aval, caustic);
349 +                return;
350 +        }
351 +        
352 + dumbamb:                                        /* return global value */
353 +        if ((ambvwt <= 0) | (navsum == 0)) {
354 +                multcolor(aval, ambval);
355 +                
356 +                /* PMAP: add in caustic */
357 +                addcolor(aval, caustic);
358 +                return;
359 +        }
360 +        
361 +        l = bright(ambval);                     /* average in computations */  
362 +        if (l > FTINY) {
363 +                d = (log(l)*(double)ambvwt + avsum) /
364 +                                (double)(ambvwt + navsum);
365 +                d = exp(d) / l;
366 +                scalecolor(aval, d);
367 +                multcolor(aval, ambval);        /* apply color of ambval */
368 +        } else {
369 +                d = exp( avsum / (double)navsum );
370 +                scalecolor(aval, d);            /* neutral color */
371 +        }
372 + }
373 +
374 +
375 + /* Plug a potential leak where ambient cache value is occluded */
376 + static int
377 + plugaleak(RAY *r, AMBVAL *ap, FVECT anorm, double ang)
378 + {
379 +        const double    cost70sq = 0.1169778;   /* cos(70deg)^2 */
380 +        RAY             rtst;
381 +        FVECT           vdif;
382 +        double          normdot, ndotd, nadotd;
383 +        double          a, b, c, t[2];
384 +
385 +        ang += 2.*PI*(ang < 0);                 /* check direction flags */
386 +        if ( !(ap->corral>>(int)(ang*(16./PI)) & 1) )
387 +                return(0);
388 +        /*
389 +         * Generate test ray, targeting 20 degrees above sample point plane
390 +         * along surface normal from cache position.  This should be high
391 +         * enough to miss local geometry we don't really care about.
392 +         */
393 +        VSUB(vdif, ap->pos, r->rop);
394 +        normdot = DOT(anorm, r->ron);
395 +        ndotd = DOT(vdif, r->ron);
396 +        nadotd = DOT(vdif, anorm);
397 +        a = normdot*normdot - cost70sq;
398 +        b = 2.0*(normdot*ndotd - nadotd*cost70sq);
399 +        c = ndotd*ndotd - DOT(vdif,vdif)*cost70sq;
400 +        if (quadratic(t, a, b, c) != 2)
401 +                return(1);                      /* should rarely happen */
402 +        if (t[1] <= FTINY)
403 +                return(0);                      /* should fail behind test */
404 +        rayorigin(&rtst, SHADOW, r, NULL);
405 +        VSUM(rtst.rdir, vdif, anorm, t[1]);     /* further dist. > plane */
406 +        rtst.rmax = normalize(rtst.rdir);       /* short ray test */
407 +        while (localhit(&rtst, &thescene)) {    /* check for occluder */
408 +                if (rtst.ro->omod != OVOID &&
409 +                                (rtst.clipset == NULL ||
410 +                                        !inset(rtst.clipset, rtst.ro->omod)))
411 +                        return(1);              /* plug light leak */
412 +                VCOPY(rtst.rorg, rtst.rop);     /* skip invisible surface */
413 +                rtst.rmax -= rtst.rot;
414 +                rayclear(&rtst);
415 +        }
416 +        return(0);                              /* seems we're OK */
417 + }
418 +
419 +
420 + static double
421 + sumambient(             /* get interpolated ambient value */
422 +        COLOR  acol,
423 +        RAY  *r,
424 +        FVECT  rn,
425 +        int  al,
426 +        AMBTREE  *at,
427 +        FVECT  c0,
428 +        double  s
429 + )
430 + {                       /* initial limit is 10 degrees plus ambacc radians */
431 +        const double    minangle = 10.0 * PI/180.;
432 +        double          maxangle = minangle + ambacc;
433 +        double          wsum = 0.0;
434 +        FVECT           ck0;
435 +        int             i, j;
436 +        AMBVAL          *av;
437 +
438 +        if (at->kid != NULL) {          /* sum children first */                                
439 +                s *= 0.5;
440 +                for (i = 0; i < 8; i++) {
441 +                        for (j = 0; j < 3; j++) {
442 +                                ck0[j] = c0[j];
443 +                                if (1<<j & i)
444 +                                        ck0[j] += s;
445 +                                if (r->rop[j] < ck0[j] - OCTSCALE*s)
446 +                                        break;
447 +                                if (r->rop[j] > ck0[j] + (1.0+OCTSCALE)*s)
448 +                                        break;
449 +                        }
450 +                        if (j == 3)
451 +                                wsum += sumambient(acol, r, rn, al,
452 +                                                        at->kid+i, ck0, s);
453 +                }
454 +                                        /* good enough? */
455 +                if (wsum >= 0.05 && s > minarad*10.0)
456 +                        return(wsum);
457 +        }
458 +                                        /* adjust maximum angle */
459 +        if (at->alist != NULL && (at->alist->lvl <= al) & (r->rweight < 0.6))
460 +                maxangle = (maxangle - PI/2.)*pow(r->rweight,0.13) + PI/2.;
461 +                                        /* sum this node */
462 +        for (av = at->alist; av != NULL; av = av->next) {
463 +                double  u, v, d, delta_r2, delta_t2;
464 +                COLOR   ct;
465 +                FVECT   uvw[3];
466 +                                        /* record access */
467 +                if (tracktime)
468 +                        av->latick = ambclock;
469 +                /*
470 +                 *  Ambient level test
471 +                 */
472 +                if (av->lvl > al ||     /* list sorted, so this works */
473 +                                (av->lvl == al) & (av->weight < 0.9*r->rweight))
474 +                        break;
475 +                /*
476 +                 *  Direction test using unperturbed normal
477 +                 */
478 +                decodedir(uvw[2], av->ndir);
479 +                d = DOT(uvw[2], r->ron);
480 +                if (d <= 0.0)           /* >= 90 degrees */
481 +                        continue;
482 +                delta_r2 = 2.0 - 2.0*d; /* approx. radians^2 */
483 +                if (delta_r2 >= maxangle*maxangle)
484 +                        continue;
485 +                /*
486 +                 *  Modified ray behind test
487 +                 */
488 +                VSUB(ck0, r->rop, av->pos);
489 +                d = DOT(ck0, uvw[2]);
490 +                if (d < -minarad*ambacc-.001)
491 +                        continue;
492 +                d /= av->rad[0];
493 +                delta_t2 = d*d;
494 +                if (delta_t2 >= ambacc*ambacc)
495 +                        continue;
496 +                /*
497 +                 *  Elliptical radii test based on Hessian
498 +                 */
499 +                decodedir(uvw[0], av->udir);
500 +                VCROSS(uvw[1], uvw[2], uvw[0]);
501 +                d = (u = DOT(ck0, uvw[0])) / av->rad[0];
502 +                delta_t2 += d*d;
503 +                d = (v = DOT(ck0, uvw[1])) / av->rad[1];
504 +                delta_t2 += d*d;
505 +                if (delta_t2 >= ambacc*ambacc)
506 +                        continue;
507 +                /*
508 +                 *  Test for potential light leak
509 +                 */
510 +                if (av->corral && plugaleak(r, av, uvw[2], atan2a(v,u)))
511 +                        continue;
512 +                /*
513 +                 *  Extrapolate value and compute final weight (hat function)
514 +                 */
515 +                if (!extambient(ct, av, r->rop, rn, uvw))
516 +                        continue;
517 +                d = tfunc(maxangle, sqrt(delta_r2), 0.0) *
518 +                        tfunc(ambacc, sqrt(delta_t2), 0.0);
519 +                scalecolor(ct, d);
520 +                addcolor(acol, ct);
521 +                wsum += d;
522 +        }
523 +        return(wsum);
524 + }
525 +
526 +
527 + static int
528 + makeambient(            /* make a new ambient value for storage */
529 +        COLOR  acol,
530 +        RAY  *r,
531 +        FVECT  rn,
532 +        int  al
533 + )
534 + {
535 +        AMBVAL  amb;
536 +        FVECT   uvw[3];
537 +        int     i;
538 +
539 +        amb.weight = 1.0;                       /* compute weight */
540 +        for (i = al; i-- > 0; )
541 +                amb.weight *= AVGREFL;
542 +        if (r->rweight < 0.1*amb.weight)        /* heuristic override */
543 +                amb.weight = 1.25*r->rweight;
544 +        setcolor(acol, AVGREFL, AVGREFL, AVGREFL);
545 +                                                /* compute ambient */
546 +        i = doambient(acol, r, amb.weight,
547 +                        uvw, amb.rad, amb.gpos, amb.gdir, &amb.corral);
548 +        scalecolor(acol, 1./AVGREFL);           /* undo assumed reflectance */
549 +        if (i <= 0 || amb.rad[0] <= FTINY)      /* no Hessian or zero radius */
550 +                return(i);
551 +                                                /* store value */
552 +        VCOPY(amb.pos, r->rop);
553 +        amb.ndir = encodedir(r->ron);
554 +        amb.udir = encodedir(uvw[0]);
555 +        amb.lvl = al;
556 +        copycolor(amb.val, acol);
557 +                                                /* insert into tree */
558 +        avsave(&amb);                           /* and save to file */
559 +        if (rn != r->ron) {                     /* texture */
560 +                VCOPY(uvw[2], r->ron);
561 +                extambient(acol, &amb, r->rop, rn, uvw);
562 +        }
563 +        return(1);
564 + }
565 +
566 +
567 + static int
568 + extambient(             /* extrapolate value at pv, nv */
569 +        COLOR  cr,
570 +        AMBVAL   *ap,
571 +        FVECT  pv,
572 +        FVECT  nv,
573 +        FVECT  uvw[3]
574 + )
575 + {
576 +        const double    min_d = 0.05;
577 +        static FVECT    my_uvw[3];
578 +        FVECT           v1;
579 +        int             i;
580 +        double          d = 1.0;        /* zeroeth order */
581 +
582 +        if (uvw == NULL) {              /* need local coordinates? */
583 +                decodedir(my_uvw[2], ap->ndir);
584 +                decodedir(my_uvw[0], ap->udir);
585 +                VCROSS(my_uvw[1], my_uvw[2], my_uvw[0]);
586 +                uvw = my_uvw;
587 +        }
588 +        for (i = 3; i--; )              /* gradient due to translation */
589 +                d += (pv[i] - ap->pos[i]) *
590 +                        (ap->gpos[0]*uvw[0][i] + ap->gpos[1]*uvw[1][i]);
591 +
592 +        VCROSS(v1, uvw[2], nv);         /* gradient due to rotation */
593 +        for (i = 3; i--; )
594 +                d += v1[i] * (ap->gdir[0]*uvw[0][i] + ap->gdir[1]*uvw[1][i]);
595 +        
596 +        if (d < min_d)                  /* should not use if we can avoid it */
597 +                d = min_d;
598 +        copycolor(cr, ap->val);
599 +        scalecolor(cr, d);
600 +        return(d > min_d);
601 + }
602 +
603 +
604 + static void
605 + avinsert(                               /* insert ambient value in our tree */
606 +        AMBVAL *av
607 + )
608 + {
609 +        AMBTREE  *at;
610 +        AMBVAL  *ap;
611 +        AMBVAL  avh;
612 +        FVECT  ck0;
613 +        double  s;
614 +        int  branch;
615 +        int  i;
616 +
617 +        if (av->rad[0] <= FTINY)
618 +                error(CONSISTENCY, "zero ambient radius in avinsert");
619 +        at = &atrunk;
620 +        VCOPY(ck0, thescene.cuorg);
621 +        s = thescene.cusize;
622 +        while (s*(OCTSCALE/2) > av->rad[1]*ambacc) {
623 +                if (at->kid == NULL)
624 +                        if ((at->kid = newambtree()) == NULL)
625 +                                error(SYSTEM, "out of memory in avinsert");
626 +                s *= 0.5;
627 +                branch = 0;
628 +                for (i = 0; i < 3; i++)
629 +                        if (av->pos[i] > ck0[i] + s) {
630 +                                ck0[i] += s;
631 +                                branch |= 1 << i;
632 +                        }
633 +                at = at->kid + branch;
634 +        }
635 +        avh.next = at->alist;           /* order by increasing level */
636 +        for (ap = &avh; ap->next != NULL; ap = ap->next)
637 +                if ( ap->next->lvl > av->lvl ||
638 +                                (ap->next->lvl == av->lvl) &
639 +                                (ap->next->weight <= av->weight) )
640 +                        break;
641 +        av->next = ap->next;
642 +        ap->next = (AMBVAL*)av;
643 +        at->alist = avh.next;
644 + }
645 +
646 +
647 + #else /* ! NEWAMB */
648 +
649 + static double   sumambient(COLOR acol, RAY *r, FVECT rn, int al,
650 +                                AMBTREE *at, FVECT c0, double s);
651 + static double   makeambient(COLOR acol, RAY *r, FVECT rn, int al);
652 + static void     extambient(COLOR cr, AMBVAL *ap, FVECT pv, FVECT nv);
653 +
654 +
655 + void
656 + multambient(            /* compute ambient component & multiply by coef. */
657 +        COLOR  aval,
658 +        RAY  *r,
659 +        FVECT  nrm
660 + )
661 + {
662 +        static int  rdepth = 0;                 /* ambient recursion */
663 +        COLOR   acol, caustic;
664 +        double  d, l;
665 +
666 +        /* PMAP: Factor in ambient from global photon map (if enabled) and return
667 +         * as all ambient components accounted for */
668 +        if (ambPmap(aval, r, rdepth))
669 +                return;
670 +
671 +        /* PMAP: Otherwise factor in ambient from caustic photon map
672 +         * (ambPmapCaustic() returns zero if caustic photons disabled) and
673 +         * continue with RADIANCE ambient calculation */
674 +        copycolor(caustic, aval);
675 +        ambPmapCaustic(caustic, r, rdepth);
676 +        
677 +        if (ambdiv <= 0)                        /* no ambient calculation */
678 +                goto dumbamb;
679 +                                                /* check number of bounces */
680 +        if (rdepth >= ambounce)
681 +                goto dumbamb;
682 +                                                /* check ambient list */
683 +        if (ambincl != -1 && r->ro != NULL &&
684 +                        ambincl != inset(ambset, r->ro->omod))
685 +                goto dumbamb;
686 +
687 +        if (ambacc <= FTINY) {                  /* no ambient storage */
688 +                copycolor(acol, aval);
689 +                rdepth++;
690                  d = doambient(acol, r, r->rweight, NULL, NULL);
691                  rdepth--;
692                  if (d <= FTINY)
693                          goto dumbamb;
694 <                copycolor(aval, acol);
694 >                copycolor(aval, acol);          
695 >        
696 >           /* PMAP: add in caustic */
697 >                addcolor(aval, caustic);        
698                  return;
699          }
700  
# Line 294 | Line 704 | multambient(           /* compute ambient component & multiply
704          setcolor(acol, 0.0, 0.0, 0.0);
705          d = sumambient(acol, r, nrm, rdepth,
706                          &atrunk, thescene.cuorg, thescene.cusize);
707 +                        
708          if (d > FTINY) {
709                  d = 1.0/d;
710                  scalecolor(acol, d);
711                  multcolor(aval, acol);
712 +                
713 +                /* PMAP: add in caustic */
714 +                addcolor(aval, caustic);        
715                  return;
716          }
717 +        
718          rdepth++;                               /* need to cache new value */
719          d = makeambient(acol, r, nrm, rdepth-1);
720          rdepth--;
721 +        
722          if (d > FTINY) {
723                  multcolor(aval, acol);          /* got new value */
724 +
725 +                /* PMAP: add in caustic */
726 +                addcolor(aval, caustic);                        
727                  return;
728          }
729 +        
730   dumbamb:                                        /* return global value */
731          if ((ambvwt <= 0) | (navsum == 0)) {
732                  multcolor(aval, ambval);
733 +
734 +                /* PMAP: add in caustic */
735 +                addcolor(aval, caustic);        
736                  return;
737          }
738 +        
739          l = bright(ambval);                     /* average in computations */
740          if (l > FTINY) {
741                  d = (log(l)*(double)ambvwt + avsum) /
# Line 326 | Line 750 | dumbamb:                                       /* return global value */
750   }
751  
752  
753 < extern double
753 > static double
754   sumambient(     /* get interpolated ambient value */
755          COLOR  acol,
756          RAY  *r,
# Line 353 | Line 777 | sumambient(    /* get interpolated ambient value */
777                  /*
778                   *  Ambient level test.
779                   */
780 <                if (av->lvl > al)       /* list sorted, so this works */
780 >                if (av->lvl > al ||     /* list sorted, so this works */
781 >                                (av->lvl == al) & (av->weight < 0.9*r->rweight))
782                          break;
358 –                if (av->weight < 0.9*r->rweight)
359 –                        continue;
783                  /*
784                   *  Ambient radius test.
785                   */
# Line 437 | Line 860 | sumambient(    /* get interpolated ambient value */
860   }
861  
862  
863 < extern double
863 > static double
864   makeambient(            /* make a new ambient value for storage */
865          COLOR  acol,
866          RAY  *r,
# Line 477 | Line 900 | makeambient(           /* make a new ambient value for storage
900   }
901  
902  
903 < extern void
903 > static void
904   extambient(             /* extrapolate value at pv, nv */
905          COLOR  cr,
906          AMBVAL   *ap,
# Line 506 | Line 929 | extambient(            /* extrapolate value at pv, nv */
929  
930  
931   static void
932 + avinsert(                               /* insert ambient value in our tree */
933 +        AMBVAL *av
934 + )
935 + {
936 +        AMBTREE  *at;
937 +        AMBVAL  *ap;
938 +        AMBVAL  avh;
939 +        FVECT  ck0;
940 +        double  s;
941 +        int  branch;
942 +        int  i;
943 +
944 +        if (av->rad <= FTINY)
945 +                error(CONSISTENCY, "zero ambient radius in avinsert");
946 +        at = &atrunk;
947 +        VCOPY(ck0, thescene.cuorg);
948 +        s = thescene.cusize;
949 +        while (s*(OCTSCALE/2) > av->rad*ambacc) {
950 +                if (at->kid == NULL)
951 +                        if ((at->kid = newambtree()) == NULL)
952 +                                error(SYSTEM, "out of memory in avinsert");
953 +                s *= 0.5;
954 +                branch = 0;
955 +                for (i = 0; i < 3; i++)
956 +                        if (av->pos[i] > ck0[i] + s) {
957 +                                ck0[i] += s;
958 +                                branch |= 1 << i;
959 +                        }
960 +                at = at->kid + branch;
961 +        }
962 +        avh.next = at->alist;           /* order by increasing level */
963 +        for (ap = &avh; ap->next != NULL; ap = ap->next)
964 +                if ( ap->next->lvl > av->lvl ||
965 +                                (ap->next->lvl == av->lvl) &
966 +                                (ap->next->weight <= av->weight) )
967 +                        break;
968 +        av->next = ap->next;
969 +        ap->next = (AMBVAL*)av;
970 +        at->alist = avh.next;
971 + }
972 +
973 + #endif  /* ! NEWAMB */
974 +
975 + /************* FOLLOWING ROUTINES SAME FOR NEW & OLD METHODS ***************/
976 +
977 + static void
978   initambfile(            /* initialize ambient file */
979          int  cre8
980   )
# Line 546 | Line 1015 | avsave(                                /* insert and save an ambient value */
1015          AMBVAL  *av
1016   )
1017   {
1018 <        avinsert(avstore(av));
1018 >        avstore(av);
1019          if (ambfp == NULL)
1020                  return;
1021          if (writambval(av, ambfp) < 0)
# Line 561 | Line 1030 | writerr:
1030  
1031  
1032   static AMBVAL *
1033 < avstore(                                /* allocate memory and store aval */
1033 > avstore(                                /* allocate memory and save aval */
1034          AMBVAL  *aval
1035   )
1036   {
# Line 579 | Line 1048 | avstore(                               /* allocate memory and store aval */
1048                  avsum += log(d);
1049                  navsum++;
1050          }
1051 +        avinsert(av);                   /* insert in our cache tree */
1052          return(av);
1053   }
1054  
# Line 615 | Line 1085 | freeambtree(                   /* free 8 ambient tree structs */
1085          AMBTREE  *atp
1086   )
1087   {
1088 <        atp->kid = atfreelist;
1088 >        if (atp == NULL) {      /* freeing free list? */
1089 >                while ((atp = atfreelist) != NULL) {
1090 >                        atfreelist = atp->kid;
1091 >                        free(atp);
1092 >                }
1093 >                return;
1094 >        }
1095 >        atp->kid = atfreelist;  /* else push node onto free list */
1096          atfreelist = atp;
1097   }
1098  
1099  
1100   static void
624 – avinsert(                               /* insert ambient value in our tree */
625 –        void *av
626 – )
627 – {
628 –        AMBTREE  *at;
629 –        AMBVAL  *ap;
630 –        AMBVAL  avh;
631 –        FVECT  ck0;
632 –        double  s;
633 –        int  branch;
634 –        int  i;
635 –
636 –        if (((AMBVAL*)av)->rad <= FTINY)
637 –                error(CONSISTENCY, "zero ambient radius in avinsert");
638 –        at = &atrunk;
639 –        VCOPY(ck0, thescene.cuorg);
640 –        s = thescene.cusize;
641 –        while (s*(OCTSCALE/2) > ((AMBVAL*)av)->rad*ambacc) {
642 –                if (at->kid == NULL)
643 –                        if ((at->kid = newambtree()) == NULL)
644 –                                error(SYSTEM, "out of memory in avinsert");
645 –                s *= 0.5;
646 –                branch = 0;
647 –                for (i = 0; i < 3; i++)
648 –                        if (((AMBVAL*)av)->pos[i] > ck0[i] + s) {
649 –                                ck0[i] += s;
650 –                                branch |= 1 << i;
651 –                        }
652 –                at = at->kid + branch;
653 –        }
654 –        avh.next = at->alist;           /* order by increasing level */
655 –        for (ap = &avh; ap->next != NULL; ap = ap->next)
656 –                if (ap->next->lvl >= ((AMBVAL*)av)->lvl)
657 –                        break;
658 –        ((AMBVAL*)av)->next = ap->next;
659 –        ap->next = (AMBVAL*)av;
660 –        at->alist = avh.next;
661 – }
662 –
663 –
664 – static void
1101   unloadatree(                    /* unload an ambient value tree */
1102          AMBTREE  *at,
1103          unloadtf_t *f
# Line 693 | Line 1129 | static int     i_avlist;               /* index for lists */
1129   static int alatcmp(const void *av1, const void *av2);
1130  
1131   static void
1132 + avfree(AMBVAL *av)
1133 + {
1134 +        free(av);
1135 + }
1136 +
1137 + static void
1138   av2list(
1139 <        void *av
1139 >        AMBVAL *av
1140   )
1141   {
1142   #ifdef DEBUG
# Line 702 | Line 1144 | av2list(
1144                  error(CONSISTENCY, "too many ambient values in av2list1");
1145   #endif
1146          avlist1[i_avlist].p = avlist2[i_avlist] = (AMBVAL*)av;
1147 <        avlist1[i_avlist++].t = ((AMBVAL*)av)->latick;
1147 >        avlist1[i_avlist++].t = av->latick;
1148   }
1149  
1150  
# Line 735 | Line 1177 | aposcmp(                       /* compare ambient value positions */
1177          return(diff > 0);
1178   }
1179  
1180 < #if 1
1180 >
1181   static int
1182   avlmemi(                                /* find list position from address */
1183          AMBVAL  *avaddr
# Line 744 | Line 1186 | avlmemi(                               /* find list position from address */
1186          AMBVAL  **avlpp;
1187  
1188          avlpp = (AMBVAL **)bsearch((char *)&avaddr, (char *)avlist2,
1189 <                        nambvals, sizeof(AMBVAL *), aposcmp);
1189 >                        nambvals, sizeof(AMBVAL *), &aposcmp);
1190          if (avlpp == NULL)
1191                  error(CONSISTENCY, "address not found in avlmemi");
1192          return(avlpp - avlist2);
1193   }
752 – #else
753 – #define avlmemi(avaddr) ((AMBVAL **)bsearch((char *)&avaddr,(char *)avlist2, \
754 –                                nambvals,sizeof(AMBVAL *),aposcmp) - avlist2)
755 – #endif
1194  
1195  
1196   static void
# Line 870 | Line 1308 | aflock(                        /* lock/unlock ambient file */
1308   }
1309  
1310  
1311 < extern int
1311 > int
1312   ambsync(void)                   /* synchronize ambient file */
1313   {
1314          long  flen;
# Line 900 | Line 1338 | ambsync(void)                  /* synchronize ambient file */
1338                                  error(WARNING, errmsg);
1339                                  break;
1340                          }
1341 <                        avinsert(avstore(&avs));
1341 >                        avstore(&avs);
1342                          n -= AMBVALSIZ;
1343                  }
1344                  lastpos = flen - n;
# Line 923 | Line 1361 | seekerr:
1361          return -1; /* pro forma return */
1362   }
1363  
1364 < #else
1364 > #else   /* ! F_SETLKW */
1365  
1366 < extern int
1366 > int
1367   ambsync(void)                   /* flush ambient file */
1368   {
1369          if (ambfp == NULL)
# Line 934 | Line 1372 | ambsync(void)                  /* flush ambient file */
1372          return(fflush(ambfp));
1373   }
1374  
1375 < #endif
1375 > #endif  /* ! F_SETLKW */

Diff Legend

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