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

Comparing ray/src/rt/rv3.c (file contents):
Revision 1.20 by greg, Tue May 21 17:41:19 1991 UTC vs.
Revision 2.11 by greg, Tue Feb 25 02:47:23 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   *  rv3.c - miscellaneous routines for rview.
6   *
7 < *     5/11/87
7 > *  External symbols declared in rpaint.h
8   */
9  
10 + #include "copyright.h"
11 +
12   #include  "ray.h"
13  
15 – #include  "octree.h"
16 –
14   #include  "rpaint.h"
15  
16   #include  "random.h"
17  
18   #ifndef WFLUSH
19 < #define WFLUSH          30              /* flush after this many rays */
19 > #ifdef SPEED
20 > #define WFLUSH          (5*SPEED)
21 > #else
22 > #define WFLUSH          100             /* flush after this many rays */
23   #endif
24 + #endif
25  
26 + #ifdef  SMLFLT
27 + #define  sscanvec(s,v)  (sscanf(s,"%f %f %f",v,v+1,v+2)==3)
28 + #else
29 + #define  sscanvec(s,v)  (sscanf(s,"%lf %lf %lf",v,v+1,v+2)==3)
30 + #endif
31  
32 +
33 + int
34   getrect(s, r)                           /* get a box */
35   char  *s;
36   register RECT  *r;
# Line 69 | Line 77 | register RECT  *r;
77   }
78  
79  
80 + int
81   getinterest(s, direc, vec, mp)          /* get area of interest */
82   char  *s;
83   int  direc;
# Line 87 | Line 96 | double  *mp;
96                  error(COMMAND, "illegal magnification");
97                  return(-1);
98          }
99 <        if (sscanf(s, "%*lf %lf %lf %lf", &vec[0], &vec[1], &vec[2]) != 3) {
99 >        if (!sscanvec(sskip(s), vec)) {
100                  if (dev->getcur == NULL)
101                          return(-1);
102                  (*dev->comout)("Pick view center\n");
103                  if ((*dev->getcur)(&x, &y) == ABORT)
104                          return(-1);
105 <                if (viewray(thisray.rorg, thisray.rdir, &ourview,
106 <                                (x+.5)/hresolu, (y+.5)/vresolu) < 0) {
105 >                if ((thisray.rmax = viewray(thisray.rorg, thisray.rdir,
106 >                        &ourview, (x+.5)/hresolu, (y+.5)/vresolu)) < -FTINY) {
107                          error(COMMAND, "not on image");
108                          return(-1);
109                  }
# Line 133 | Line 142 | register COLOR  col;
142   }
143  
144  
145 + void
146   paint(p, xmin, ymin, xmax, ymax)        /* compute and paint a rectangle */
147   register PNODE  *p;
148   int  xmin, ymin, xmax, ymax;
149   {
150 <        extern long  nrays;
141 <        static long  lastflush = 0;
150 >        static unsigned long  lastflush = 0;
151          static RAY  thisray;
152          double  h, v;
153  
# Line 152 | Line 161 | int  xmin, ymin, xmax, ymax;
161          h = xmin + (xmax-xmin)*frandom();
162          v = ymin + (ymax-ymin)*frandom();
163          
164 <        if (viewray(thisray.rorg, thisray.rdir, &ourview,
165 <                        h/hresolu, v/vresolu) < 0) {
164 >        if ((thisray.rmax = viewray(thisray.rorg, thisray.rdir, &ourview,
165 >                        h/hresolu, v/vresolu)) < -FTINY) {
166                  setcolor(thisray.rcol, 0.0, 0.0, 0.0);
167          } else {
168                  rayorigin(&thisray, NULL, PRIMARY, 1.0);
# Line 175 | Line 184 | int  xmin, ymin, xmax, ymax;
184   }
185  
186  
187 + void
188   newimage()                              /* start a new image */
189   {
190                                                  /* free old image */
# Line 195 | Line 205 | newimage()                             /* start a new image */
205   }
206  
207  
208 + void
209   redraw()                                /* redraw the image */
210   {
211          (*dev->clear)(hresolu, vresolu);
# Line 204 | Line 215 | redraw()                               /* redraw the image */
215   }
216  
217  
218 + void
219   repaint(xmin, ymin, xmax, ymax)                 /* repaint a region */
220   int  xmin, ymin, xmax, ymax;
221   {
# Line 216 | Line 228 | int  xmin, ymin, xmax, ymax;
228   }
229  
230  
231 + void
232   paintrect(p, xmin, ymin, xmax, ymax, r)         /* paint picture rectangle */
233   register PNODE  *p;
234   int  xmin, ymin, xmax, ymax;
# Line 286 | Line 299 | int  pd;
299   }
300  
301  
302 + void
303   scalepict(p, sf)                        /* scale picture values */
304   register PNODE  *p;
305   double  sf;
# Line 302 | Line 316 | double  sf;
316   }
317  
318  
319 + void
320   getpictcolrs(yoff, scan, p, xsiz, ysiz) /* get scanline from picture */
321   int  yoff;
322   register COLR  *scan;
# Line 332 | Line 347 | int  xsiz, ysiz;
347   }
348  
349  
350 < pcopy(p1, p2)                           /* copy paint node p1 into p2 */
336 < register PNODE  *p1, *p2;
337 < {
338 <        copycolor(p2->v, p1->v);
339 <        p2->x = p1->x;
340 <        p2->y = p1->y;
341 < }
342 <
343 <
350 > void
351   freepkids(p)                            /* free pnode's children */
352   register PNODE  *p;
353   {
# Line 350 | Line 357 | register PNODE  *p;
357          freepkids(p->kid+DR);
358          freepkids(p->kid+UL);
359          freepkids(p->kid+UR);
360 <        free((char *)p->kid);
360 >        free((void *)p->kid);
361          p->kid = NULL;
362   }
363  
364  
365 + void
366   newview(vp)                             /* change viewing parameters */
367   register VIEW  *vp;
368   {
# Line 371 | Line 379 | register VIEW  *vp;
379   }
380  
381  
382 + void
383   moveview(angle, elev, mag, vc)                  /* move viewpoint */
384   double  angle, elev, mag;
385   FVECT  vc;
386   {
378 –        extern double  sqrt(), dist2();
387          double  d;
388          FVECT  v1;
389          VIEW  nv;
# Line 395 | Line 403 | FVECT  vc;
403                  d = 0.0;                        /* don't move closer */
404                  for (i = 0; i < 3; i++)
405                          d += (vc[i] - ourview.vp[i])*ourview.vdir[i];
406 +                nv.vfore = ourview.vfore;
407 +                nv.vaft = ourview.vaft;
408          } else {
409                  nv.horiz = ourview.horiz;
410                  nv.vert = ourview.vert;
411                  d = sqrt(dist2(ourview.vp, vc)) / mag;
412 +                if ((nv.vfore = ourview.vfore) > FTINY) {
413 +                        nv.vfore += d - d*mag;
414 +                        if (nv.vfore < 0.0) nv.vfore = 0.0;
415 +                }
416 +                if ((nv.vaft = ourview.vaft) > FTINY) {
417 +                        nv.vaft += d - d*mag;
418 +                        if (nv.vaft <= nv.vfore) nv.vaft = 0.0;
419 +                }
420          }
421          for (i = 0; i < 3; i++)
422                  nv.vp[i] = vc[i] - d*nv.vdir[i];
# Line 406 | Line 424 | FVECT  vc;
424   }
425  
426  
427 < zoomview(vp, zf)                        /* zoom in our out */
427 > void
428 > pcopy(p1, p2)                           /* copy paint node p1 into p2 */
429 > register PNODE  *p1, *p2;
430 > {
431 >        copycolor(p2->v, p1->v);
432 >        p2->x = p1->x;
433 >        p2->y = p1->y;
434 > }
435 >
436 >
437 > void
438 > zoomview(vp, zf)                        /* zoom in or out */
439   register VIEW  *vp;
440   double  zf;
441   {
442          switch (vp->type) {
443          case VT_PAR:                            /* parallel view */
444 +                vp->horiz /= zf;
445 +                vp->vert /= zf;
446 +                return;
447          case VT_ANG:                            /* angular fisheye */
448                  vp->horiz /= zf;
449 +                if (vp->horiz > 360.)
450 +                        vp->horiz = 360.;
451                  vp->vert /= zf;
452 +                if (vp->vert > 360.)
453 +                        vp->vert = 360.;
454 +                return;
455 +        case VT_CYL:                            /* cylindrical panorama */
456 +                vp->horiz /= zf;
457 +                if (vp->horiz > 360.)
458 +                        vp->horiz = 360.;
459 +                vp->vert = atan(tan(vp->vert*(PI/180./2.))/zf) / (PI/180./2.);
460                  return;
461          case VT_PER:                            /* perspective view */
462                  vp->horiz = atan(tan(vp->horiz*(PI/180./2.))/zf) /

Diff Legend

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