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 1.15 by greg, Thu Jun 13 09:41:15 1991 UTC vs.
Revision 2.10 by greg, Thu Jul 16 16:47:28 1992 UTC

# Line 42 | Line 42 | static AMBTREE  atrunk;                /* our ambient trunk node */
42  
43   static FILE  *ambfp = NULL;     /* ambient file pointer */
44  
45 + #define  AMBFLUSH       (BUFSIZ/AMBVALSIZ)
46 +
47   #define  newambval()    (AMBVAL *)bmalloc(sizeof(AMBVAL))
48  
49   #define  newambtree()   (AMBTREE *)calloc(8, sizeof(AMBTREE))
50  
51 + extern long  ftell(), lseek();
52 + static int  initambfile(), avsave(), avinsert(), ambsync();
53  
54 +
55 + setambres(ar)                           /* set ambient resolution */
56 + int  ar;
57 + {
58 +                                                /* set min & max radii */
59 +        if (ar <= 0) {
60 +                minarad = 0.0;
61 +                maxarad = thescene.cusize / 2.0;
62 +        } else {
63 +                minarad = thescene.cusize / ar;
64 +                maxarad = 16.0 * minarad;               /* heuristic */
65 +                if (maxarad > thescene.cusize / 2.0)
66 +                        maxarad = thescene.cusize / 2.0;
67 +        }
68 +        if (maxarad <= FTINY)
69 +                maxarad = .001;
70 + }
71 +
72 +
73   setambient(afile)                       /* initialize calculation */
74   char  *afile;
75   {
76 <        long  ftell();
76 >        long  headlen;
77          AMBVAL  amb;
78 <
79 <        maxarad = thescene.cusize / 2.0;                /* maximum radius */
80 <                                                        /* minimum radius */
58 <        minarad = ambres > 0 ? thescene.cusize/ambres : 0.0;
59 <
60 <                                        /* open ambient file */
78 >                                                /* init ambient limits */
79 >        setambres(ambres);
80 >                                                /* open ambient file */
81          if (afile != NULL)
82                  if ((ambfp = fopen(afile, "r+")) != NULL) {
83 <                        while (fread((char *)&amb,sizeof(AMBVAL),1,ambfp) == 1)
83 >                        initambfile(0);
84 >                        headlen = ftell(ambfp);
85 >                        while (readambval(&amb, ambfp))
86                                  avinsert(&amb, &atrunk, thescene.cuorg,
87                                                  thescene.cusize);
88                                                          /* align */
89 <                        fseek(ambfp, -(ftell(ambfp)%sizeof(AMBVAL)), 1);
90 <                } else if ((ambfp = fopen(afile, "w")) == NULL) {
89 >                        fseek(ambfp, -((ftell(ambfp)-headlen)%AMBVALSIZ), 1);
90 >                } else if ((ambfp = fopen(afile, "w+")) != NULL)
91 >                        initambfile(1);
92 >                else {
93                          sprintf(errmsg, "cannot open ambient file \"%s\"",
94                                          afile);
95                          error(SYSTEM, errmsg);
# Line 100 | Line 124 | COLOR  acol;
124   register RAY  *r;
125   {
126          static int  rdepth = 0;                 /* ambient recursion */
127 <        double  wsum;
127 >        double  d;
128  
105 –        rdepth++;                               /* increment level */
106 –
129          if (ambdiv <= 0)                        /* no ambient calculation */
130                  goto dumbamb;
131                                                  /* check number of bounces */
132 <        if (rdepth > ambounce)
132 >        if (rdepth >= ambounce)
133                  goto dumbamb;
134                                                  /* check ambient list */
135          if (ambincl != -1 && r->ro != NULL &&
# Line 115 | Line 137 | register RAY  *r;
137                  goto dumbamb;
138  
139          if (ambacc <= FTINY) {                  /* no ambient storage */
140 <                if (doambient(acol, r, NULL, NULL) == 0.0)
140 >                rdepth++;
141 >                d = doambient(acol, r, r->rweight, NULL, NULL);
142 >                rdepth--;
143 >                if (d == 0.0)
144                          goto dumbamb;
145 <                goto done;
145 >                return;
146          }
147                                                  /* get ambient value */
148          setcolor(acol, 0.0, 0.0, 0.0);
149 <        wsum = sumambient(acol, r, &atrunk, thescene.cuorg, thescene.cusize);
150 <        if (wsum > FTINY)
151 <                scalecolor(acol, 1.0/wsum);
152 <        else if (makeambient(acol, r) == 0.0)
153 <                goto dumbamb;
154 <        goto done;
155 <
149 >        d = sumambient(acol, r, rdepth,
150 >                        &atrunk, thescene.cuorg, thescene.cusize);
151 >        if (d > FTINY)
152 >                scalecolor(acol, 1.0/d);
153 >        else {
154 >                d = makeambient(acol, r, rdepth++);
155 >                rdepth--;
156 >        }
157 >        if (d > FTINY)
158 >                return;
159   dumbamb:                                        /* return global value */
160          copycolor(acol, ambval);
133 – done:                                           /* must finish here! */
134 –        rdepth--;
161   }
162  
163  
164   double
165 < sumambient(acol, r, at, c0, s)          /* get interpolated ambient value */
165 > sumambient(acol, r, al, at, c0, s)      /* get interpolated ambient value */
166   COLOR  acol;
167   register RAY  *r;
168 + int  al;
169   AMBTREE  *at;
170   FVECT  c0;
171   double  s;
# Line 154 | Line 181 | double  s;
181          wsum = 0.0;
182          for (av = at->alist; av != NULL; av = av->next) {
183                  /*
184 <                 *  Ray strength test.
184 >                 *  Ambient level test.
185                   */
186 <                if (av->lvl > r->rlvl || av->weight < r->rweight-FTINY)
186 >                if (av->lvl > al || av->weight < r->rweight-FTINY)
187                          continue;
188                  /*
189                   *  Ambient radius test.
# Line 183 | Line 210 | double  s;
210                  for (j = 0; j < 3; j++)
211                          d += (r->rop[j] - av->pos[j]) *
212                                          (av->dir[j] + r->ron[j]);
213 <                if (d*0.5 < -minarad*ambacc)
213 >                if (d*0.5 < -minarad*ambacc-.001)
214                          continue;
215                  /*
216                   *  Jittering final test reduces image artifacts.
217                   */
218                  wt = sqrt(e1) + sqrt(e2);
219 <                wt *= .9 + .2*frandom();
219 >                wt *= .9 + .2*urand(9015+samplendx);
220                  if (wt > ambacc)
221                          continue;
222                  if (wt <= 1e-3)
# Line 216 | Line 243 | double  s;
243                                  break;
244                  }
245                  if (j == 3)
246 <                        wsum += sumambient(acol, r, at->kid+i, ck0, s);
246 >                        wsum += sumambient(acol, r, al, at->kid+i, ck0, s);
247          }
248          return(wsum);
249   }
250  
251  
252   double
253 < makeambient(acol, r)            /* make a new ambient value */
253 > makeambient(acol, r, al)        /* make a new ambient value */
254   COLOR  acol;
255   register RAY  *r;
256 + int  al;
257   {
258          AMBVAL  amb;
259          FVECT   gp, gd;
260 <
261 <        amb.rad = doambient(acol, r, gp, gd);   /* compute ambient */
260 >                                                /* compute weight */
261 >        amb.weight = pow(AVGREFL, (double)al);
262 >        if (r->rweight < 0.2*amb.weight)        /* heuristic */
263 >                amb.weight = r->rweight;
264 >                                                /* compute ambient */
265 >        amb.rad = doambient(acol, r, amb.weight, gp, gd);
266          if (amb.rad == 0.0)
267                  return(0.0);
268                                                  /* store it */
269          VCOPY(amb.pos, r->rop);
270          VCOPY(amb.dir, r->ron);
271 <        amb.lvl = r->rlvl;
240 <        amb.weight = r->rweight;
271 >        amb.lvl = al;
272          copycolor(amb.val, acol);
273          VCOPY(amb.gpos, gp);
274          VCOPY(amb.gdir, gd);
275                                                  /* insert into tree */
276 <        avinsert(&amb, &atrunk, thescene.cuorg, thescene.cusize);
246 <        avsave(&amb);                           /* write to file */
276 >        avsave(&amb);                           /* and save to file */
277          return(amb.rad);
278   }
279  
# Line 275 | Line 305 | FVECT  pv, nv;
305  
306  
307   static
308 < avsave(av)                              /* save an ambient value */
308 > initambfile(creat)              /* initialize ambient file */
309 > int  creat;
310 > {
311 >        extern char  *progname, *octname, VersionID[];
312 >
313 >        setbuf(ambfp, bmalloc(BUFSIZ));
314 >        if (creat) {                    /* new file */
315 >                fprintf(ambfp, "%s -av %g %g %g -ab %d -aa %g ",
316 >                                progname, colval(ambval,RED),
317 >                                colval(ambval,GRN), colval(ambval,BLU),
318 >                                ambounce, ambacc);
319 >                fprintf(ambfp, "-ad %d -as %d -ar %d %s\n",
320 >                                ambdiv, ambssamp, ambres,
321 >                                octname==NULL ? "" : octname);
322 >                fprintf(ambfp, "SOFTWARE= %s\n", VersionID);
323 >                fputformat(AMBFMT, ambfp);
324 >                putc('\n', ambfp);
325 >                putambmagic(ambfp);
326 >                fflush(ambfp);
327 >        } else if (checkheader(ambfp, AMBFMT, NULL) < 0 || !hasambmagic(ambfp))
328 >                error(USER, "bad ambient file");
329 > }
330 >
331 >
332 > static
333 > avsave(av)                              /* insert and save an ambient value */
334   AMBVAL  *av;
335   {
281 – #ifdef  AMBFLUSH
336          static int  nunflshed = 0;
337 < #endif
337 >
338 >        avinsert(av, &atrunk, thescene.cuorg, thescene.cusize);
339          if (ambfp == NULL)
340                  return;
341 <        if (fwrite((char *)av, sizeof(AMBVAL), 1, ambfp) != 1)
341 >        if (writambval(av, ambfp) < 0)
342                  goto writerr;
288 – #ifdef  AMBFLUSH
343          if (++nunflshed >= AMBFLUSH) {
344 <                if (fflush(ambfp) == EOF)
344 >                if (ambsync() == EOF)
345                          goto writerr;
346                  nunflshed = 0;
347          }
294 – #endif
348          return;
349   writerr:
350          error(SYSTEM, "error writing ambient file");
# Line 333 | Line 386 | double  s;
386   memerr:
387          error(SYSTEM, "out of memory in avinsert");
388   }
389 +
390 +
391 + #ifdef  NIX
392 +
393 + static
394 + ambsync()                       /* flush ambient file */
395 + {
396 +        return(fflush(ambfp));
397 + }
398 +
399 + #else
400 +
401 + #include  <fcntl.h>
402 + #include  <sys/types.h>
403 + #include  <sys/stat.h>
404 +
405 + static
406 + ambsync()                       /* synchronize ambient file */
407 + {
408 +        static FILE  *ambinp = NULL;
409 +        struct flock  fls;
410 +        struct stat  sts;
411 +        AMBVAL  avs;
412 +        long  lastpos, flen;
413 +        register int  n;
414 +                                /* gain exclusive access */
415 +        fls.l_type = F_WRLCK;
416 +        fls.l_whence = 0;
417 +        fls.l_start = 0L;
418 +        fls.l_len = 0L;
419 +        if (fcntl(fileno(ambfp), F_SETLKW, &fls) < 0)
420 +                error(SYSTEM, "cannot lock ambient file");
421 +                                /* see if file has grown */
422 +        lastpos = lseek(fileno(ambfp), 0L, 1);  /* get previous position */
423 +        if (fstat(fileno(ambfp), &sts) < 0)     /* get current length */
424 +                error(SYSTEM, "cannot stat ambient file");
425 +        flen = sts.st_size;
426 +        if (n = (flen - lastpos)/AMBVALSIZ) {   /* file has grown */
427 +                if (ambinp == NULL)             /* use duplicate file */
428 +                        ambinp = fdopen(dup(fileno(ambfp)), "r");
429 +                while (n--) {                   /* load contributed values */
430 +                        readambval(&avs, ambinp);
431 +                        avinsert(&avs,&atrunk,thescene.cuorg,thescene.cusize);
432 +                }                               /* moves shared file pointer */
433 +                if (n = (flen - lastpos)%AMBVALSIZ)     /* alignment */
434 +                        lseek(fileno(ambfp), flen-n, 0);
435 +        }
436 +        n = fflush(ambfp);                      /* calls write() at last */
437 +        fls.l_type = F_UNLCK;                   /* release file */
438 +        fcntl(fileno(ambfp), F_SETLKW, &fls);
439 +        return(n);
440 + }
441 +
442 + #endif

Diff Legend

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