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

Comparing ray/src/rt/rview.c (file contents):
Revision 2.3 by greg, Thu Dec 19 14:54:46 1991 UTC vs.
Revision 2.18 by greg, Sat Feb 22 02:07:29 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1987 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   *  rview.c - routines and variables for interactive view generation.
6   *
7 < *     3/24/87
7 > *  External symbols declared in rpaint.h
8   */
9  
10 + /* ====================================================================
11 + * The Radiance Software License, Version 1.0
12 + *
13 + * Copyright (c) 1990 - 2002 The Regents of the University of California,
14 + * through Lawrence Berkeley National Laboratory.   All rights reserved.
15 + *
16 + * Redistribution and use in source and binary forms, with or without
17 + * modification, are permitted provided that the following conditions
18 + * are met:
19 + *
20 + * 1. Redistributions of source code must retain the above copyright
21 + *         notice, this list of conditions and the following disclaimer.
22 + *
23 + * 2. Redistributions in binary form must reproduce the above copyright
24 + *       notice, this list of conditions and the following disclaimer in
25 + *       the documentation and/or other materials provided with the
26 + *       distribution.
27 + *
28 + * 3. The end-user documentation included with the redistribution,
29 + *           if any, must include the following acknowledgment:
30 + *             "This product includes Radiance software
31 + *                 (http://radsite.lbl.gov/)
32 + *                 developed by the Lawrence Berkeley National Laboratory
33 + *               (http://www.lbl.gov/)."
34 + *       Alternately, this acknowledgment may appear in the software itself,
35 + *       if and wherever such third-party acknowledgments normally appear.
36 + *
37 + * 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
38 + *       and "The Regents of the University of California" must
39 + *       not be used to endorse or promote products derived from this
40 + *       software without prior written permission. For written
41 + *       permission, please contact [email protected].
42 + *
43 + * 5. Products derived from this software may not be called "Radiance",
44 + *       nor may "Radiance" appear in their name, without prior written
45 + *       permission of Lawrence Berkeley National Laboratory.
46 + *
47 + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
48 + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
49 + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
50 + * DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
51 + * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
52 + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
53 + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
54 + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
55 + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
56 + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
57 + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58 + * SUCH DAMAGE.
59 + * ====================================================================
60 + *
61 + * This software consists of voluntary contributions made by many
62 + * individuals on behalf of Lawrence Berkeley National Laboratory.   For more
63 + * information on Lawrence Berkeley National Laboratory, please see
64 + * <http://www.lbl.gov/>.
65 + */
66 +
67   #include  "ray.h"
68  
69   #include  "rpaint.h"
# Line 18 | Line 72 | static char SCCSid[] = "$SunId$ LBL";
72  
73   #include  <ctype.h>
74  
75 < VIEW  ourview = STDVIEW;                /* viewing parameters */
76 < int  hresolu, vresolu;                  /* image resolution */
75 > CUBE  thescene;                         /* our scene */
76 > OBJECT  nsceneobjs;                     /* number of objects in our scene */
77  
78   int  dimlist[MAXDIM];                   /* sampling dimensions */
79   int  ndims = 0;                         /* number of sampling dimensions */
80   int  samplendx = 0;                     /* index for this sample */
81  
82 + extern void  ambnotify();
83 + void  (*addobjnotify[])() = {ambnotify, NULL};
84 +
85 + VIEW  ourview = STDVIEW;                /* viewing parameters */
86 + int  hresolu, vresolu;                  /* image resolution */
87 +
88 + void  (*trace)() = NULL;                /* trace call */
89 +
90 + int  do_irrad = 0;                      /* compute irradiance? */
91 +
92   int  psample = 8;                       /* pixel sample size */
93 < double  maxdiff = .15;                  /* max. sample difference */
93 > double  maxdiff = .15;                  /* max. sample difference */
94  
95 < double  exposure = 1.0;                 /* exposure for scene */
95 > double  exposure = 1.0;                 /* exposure for scene */
96  
97 < double  dstrsrc = 0.0;                  /* square source distribution */
98 < double  shadthresh = .1;                /* shadow threshold */
99 < double  shadcert = .25;                 /* shadow certainty */
97 > double  dstrsrc = 0.0;                  /* square source distribution */
98 > double  shadthresh = .1;                /* shadow threshold */
99 > double  shadcert = .25;                 /* shadow certainty */
100   int  directrelay = 0;                   /* number of source relays */
101   int  vspretest = 128;                   /* virtual source pretest density */
102 < int  directinvis = 0;                   /* sources invisible? */
103 < double  srcsizerat = 0.;                /* maximum ratio source size/dist. */
102 > int  directvis = 1;                     /* sources visible? */
103 > double  srcsizerat = 0.;                /* maximum ratio source size/dist. */
104  
105 + COLOR  cextinction = BLKCOLOR;          /* global extinction coefficient */
106 + COLOR  salbedo = BLKCOLOR;              /* global scattering albedo */
107 + double  seccg = 0.;                     /* global scattering eccentricity */
108 + double  ssampdist = 0.;                 /* scatter sampling distance */
109 +
110 + double  specthresh = .3;                /* specular sampling threshold */
111 + double  specjitter = 1.;                /* specular sampling jitter */
112 +
113 + int  backvis = 1;                       /* back face visibility */
114 +
115   int  maxdepth = 4;                      /* maximum recursion depth */
116 < double  minweight = 1e-2;               /* minimum ray weight */
116 > double  minweight = 1e-2;               /* minimum ray weight */
117  
118 + char  *ambfile = NULL;                  /* ambient file name */
119   COLOR  ambval = BLKCOLOR;               /* ambient value */
120 < double  ambacc = 0.2;                   /* ambient accuracy */
120 > int  ambvwt = 0;                        /* initial weight for ambient value */
121 > double  ambacc = 0.2;                   /* ambient accuracy */
122   int  ambres = 8;                        /* ambient resolution */
123   int  ambdiv = 32;                       /* ambient divisions */
124   int  ambssamp = 0;                      /* ambient super-samples */
# Line 51 | Line 127 | char  *amblist[128];                   /* ambient include/exclude list
127   int  ambincl = -1;                      /* include == 1, exclude == 0 */
128  
129   int  greyscale = 0;                     /* map colors to brightness? */
130 < char  *devname = dev_default;           /* output device name */
130 > char  *dvcname = dev_default;           /* output device name */
131  
132   struct driver  *dev = NULL;             /* driver functions */
133  
134 + char  rifname[128];                     /* rad input file name */
135 +
136   VIEW  oldview;                          /* previous view parameters */
137  
138   PNODE  ptrunk;                          /* the base of our image */
# Line 65 | Line 143 | static char  *reserve_mem = NULL;      /* pre-allocated res
143  
144   #define RESERVE_AMT     32768           /* amount of memory to reserve */
145  
146 < #define  CTRL(c)        ('c'-'@')
146 > #define  CTRL(c)        ((c)-'@')
147  
148  
149 + void
150   quit(code)                      /* quit program */
151   int  code;
152   {
153 + #ifdef MSTATS
154 +        if (code == 2 && errno == ENOMEM)
155 +                printmemstats(stderr);
156 + #endif
157          devclose();
158          exit(code);
159   }
160  
161  
162 + void
163   devopen(dname)                          /* open device driver */
164   char  *dname;
165   {
# Line 92 | Line 176 | char  *dname;
176                                  error(USER, errmsg);
177                          } else
178                                  return;
179 + #ifndef NIX                                                
180                                                  /* not there, try exec */
181          if ((dev = comm_init(dname, id)) == NULL) {
182                  sprintf(errmsg, "cannot start device \"%s\"", dname);
183                  error(USER, errmsg);
184          }
185 + #endif
186   }
187  
188  
189 + void
190   devclose()                              /* close our device */
191   {
192          if (dev != NULL)
# Line 108 | Line 195 | devclose()                             /* close our device */
195   }
196  
197  
198 + void
199   printdevices()                          /* print list of output devices */
200   {
201          register int  i;
# Line 117 | Line 205 | printdevices()                         /* print list of output devices */
205   }
206  
207  
208 + void
209   rview()                         /* do a view */
210   {
211          char  buf[32];
212  
213 <        devopen(devname);               /* open device */
213 >        devopen(dvcname);               /* open device */
214          newimage();                     /* start image (calls fillreserves) */
215  
216          for ( ; ; ) {                   /* quit in command() */
# Line 149 | Line 238 | rview()                                /* do a view */
238   }
239  
240  
241 + void
242   fillreserves()                  /* fill memory reserves */
243   {
244          if (reserve_mem != NULL)
245                  return;
246 <        reserve_mem = malloc(RESERVE_AMT);
246 >        reserve_mem = (char *)malloc(RESERVE_AMT);
247   }
248  
249  
250 + void
251   freereserves()                  /* free memory reserves */
252   {
253          if (reserve_mem == NULL)
# Line 166 | Line 257 | freereserves()                 /* free memory reserves */
257   }
258  
259  
260 + void
261   command(prompt)                 /* get/execute command */
262   char  *prompt;
263   {
264 < #define  badcom(s)      strncmp(s, inpbuf, args-inpbuf-1)
264 > #define  badcom(s)      strncmp(s, inpbuf, args-inpbuf-1)
265          char  inpbuf[256];
266          char  *args;
267   again:
# Line 180 | Line 272 | again:
272          else *++args = '\0';
273          
274          switch (inpbuf[0]) {
275 <        case 'f':                               /* new frame */
276 <                if (badcom("frame"))
277 <                        goto commerr;
275 >        case 'f':                               /* new frame (or free mem.) */
276 >                if (badcom("frame")) {
277 >                        if (badcom("free"))
278 >                                goto commerr;
279 >                        free_objmem();
280 >                        break;
281 >                }
282                  getframe(args);
283                  break;
284          case 'v':                               /* view */
# Line 195 | Line 291 | again:
291                          goto commerr;
292                  lastview(args);
293                  break;
294 +        case 'V':                               /* save view */
295 +                if (badcom("V"))
296 +                        goto commerr;
297 +                saveview(args);
298 +                break;
299 +        case 'L':                               /* load view */
300 +                if (badcom("L"))
301 +                        goto commerr;
302 +                loadview(args);
303 +                break;
304          case 'e':                               /* exposure */
305                  if (badcom("exposure"))
306                          goto commerr;
307                  getexposure(args);
308                  break;
309          case 's':                               /* set a parameter */
310 <                if (badcom("set"))
310 >                if (badcom("set")) {
311 > #ifdef  SIGTSTP
312 >                        if (!badcom("stop"))
313 >                                goto dostop;
314 > #endif
315                          goto commerr;
316 +                }
317                  setparam(args);
318                  break;
319          case 'n':                               /* new picture */
# Line 220 | Line 331 | again:
331                          goto commerr;
332                  getaim(args);
333                  break;
334 <        case 'm':                               /* move camera */
334 >        case 'm':                               /* move camera (or memstats) */
335                  if (badcom("move"))
336 < #ifdef  MSTATS
336 > #ifdef  MSTATS
337                  {
338                          if (badcom("memory"))
339                                  goto commerr;
# Line 236 | Line 347 | again:
347                  break;
348          case 'r':                               /* rotate/repaint */
349                  if (badcom("rotate")) {
350 <                        if (badcom("repaint"))
351 <                                goto commerr;
350 >                        if (badcom("repaint")) {
351 >                                if (badcom("redraw"))
352 >                                        goto commerr;
353 >                                redraw();
354 >                                break;
355 >                        }
356                          getrepaint(args);
357                          break;
358                  }
359                  getrotate(args);
360                  break;
361          case 'p':                               /* pivot view */
362 <                if (badcom("pivot"))
363 <                        goto commerr;
362 >                if (badcom("pivot")) {
363 >                        if (badcom("pause"))
364 >                                goto commerr;
365 >                        goto again;
366 >                }
367                  getpivot(args);
368                  break;
369 <        case CTRL(R):                           /* redraw */
369 >        case CTRL('R'):                         /* redraw */
370                  redraw();
371                  break;
372          case 'w':                               /* write */
# Line 260 | Line 378 | again:
378                  if (badcom("quit"))
379                          goto commerr;
380                  quit(0);
381 <        case CTRL(C):                           /* interrupt */
381 >        case CTRL('C'):                         /* interrupt */
382                  goto again;
383 < #ifdef  SIGTSTP
384 <        case CTRL(Z):                           /* stop */
383 > #ifdef  SIGTSTP
384 >        case CTRL('Z'):;                        /* stop */
385 > dostop:
386                  devclose();
387                  kill(0, SIGTSTP);
388                  /* pc stops here */
389 <                devopen(devname);
389 >                devopen(dvcname);
390                  redraw();
391                  break;
392   #endif
# Line 283 | Line 402 | commerr:
402                  error(COMMAND, errmsg);
403                  break;
404          }
405 < #undef  badcom
405 > #undef  badcom
406   }
407  
408  
409 + void
410   rsample()                       /* sample the image */
411   {
412          int  xsiz, ysiz, y;
413          RECT  r;
414          PNODE  *p;
415          register RECT  *rl;
416 <        register PNODE  **pl;
416 >        register PNODE  **pl;
417          register int  x;
418          /*
419           *     We initialize the bottom row in the image at our current
420 <         * resolution.  During sampling, we check super-pixels to the
420 >         * resolution.  During sampling, we check super-pixels to the
421           * right and above by calling bigdiff().  If there is a significant
422           * difference, we subsample the super-pixels.  The testing process
423           * includes initialization of the next row.
424           */
425 <        xsiz = (((pframe.r-pframe.l)<<pdepth)+hresolu-1) / hresolu;
426 <        ysiz = (((pframe.u-pframe.d)<<pdepth)+vresolu-1) / vresolu;
425 >        xsiz = (((long)(pframe.r-pframe.l)<<pdepth)+hresolu-1) / hresolu;
426 >        ysiz = (((long)(pframe.u-pframe.d)<<pdepth)+vresolu-1) / vresolu;
427          rl = (RECT *)malloc(xsiz*sizeof(RECT));
428          if (rl == NULL)
429                  return;
430          pl = (PNODE **)malloc(xsiz*sizeof(PNODE *));
431 <        if (pl == NULL)
431 >        if (pl == NULL) {
432 >                free((void *)rl);
433                  return;
434 +        }
435          /*
436           * Initialize the bottom row.
437           */
# Line 368 | Line 490 | rsample()                      /* sample the image */
490                  }
491          }
492   escape:
493 <        free((char *)rl);
494 <        free((char *)pl);
493 >        free((void *)rl);
494 >        free((void *)pl);
495   }
496  
497  
498   int
499   refine(p, xmin, ymin, xmax, ymax, pd)           /* refine a node */
500 < register PNODE  *p;
500 > register PNODE  *p;
501   int  xmin, ymin, xmax, ymax;
502   int  pd;
503   {
# Line 399 | Line 521 | int  pd;
521                          return(0);
522                  /*
523                   *  The following paint order can leave a black pixel
524 <                 *  when redraw() is called in (*dev->paintr)().
524 >                 *  if redraw() is called in (*dev->paintr)().
525                   */
526                  if (p->x >= mx && p->y >= my)
527                          pcopy(p, p->kid+UR);

Diff Legend

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