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.13 by greg, Thu Feb 22 11:46:15 1990 UTC vs.
Revision 2.41 by greg, Wed Nov 7 18:34:58 2018 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  "ray.h"
10 > #include "copyright.h"
11  
12 < #include  "octree.h"
12 > #include <string.h>
13  
14 + #include  "ray.h"
15   #include  "rpaint.h"
16 <
16 > #include  "otypes.h"
17 > #include  "otspecial.h"
18 > #include  "source.h"
19   #include  "random.h"
20  
21   #ifndef WFLUSH
22 < #define WFLUSH          30              /* flush after this many rays */
22 > #define WFLUSH          64              /* flush after this many primary rays */
23   #endif
24 + #ifndef WFLUSH1
25 + #define WFLUSH1         512             /* or this many total rays */
26 + #endif
27  
28  
29 < getrect(s, r)                           /* get a box */
30 < char  *s;
31 < register RECT  *r;
29 > #ifdef  SMLFLT
30 > #define  sscanvec(s,v)  (sscanf(s,"%f %f %f",v,v+1,v+2)==3)
31 > #else
32 > #define  sscanvec(s,v)  (sscanf(s,"%lf %lf %lf",v,v+1,v+2)==3)
33 > #endif
34 >
35 > extern int      ray_pnprocs;
36 >
37 > static RNUMBER  niflush;                /* flushes since newimage() */
38 >
39 > int
40 > getrect(                                /* get a box */
41 >        char  *s,
42 >        RECT  *r
43 > )
44   {
45          int  x0, y0, x1, y1;
46  
# Line 69 | Line 84 | register RECT  *r;
84   }
85  
86  
87 < getinterest(s, direc, vec, mp)          /* get area of interest */
88 < char  *s;
89 < int  direc;
90 < FVECT  vec;
91 < double  *mp;
87 > int
88 > getinterest(            /* get area of interest */
89 >        char  *s,
90 >        int  direc,
91 >        FVECT  vec,
92 >        double  *mp
93 > )
94   {
95          int  x, y;
96          RAY  thisray;
97 <        register int  i;
97 >        int  i;
98  
99          if (sscanf(s, "%lf", mp) != 1)
100                  *mp = 1.0;
# Line 87 | Line 104 | double  *mp;
104                  error(COMMAND, "illegal magnification");
105                  return(-1);
106          }
107 <        if (sscanf(s, "%*lf %lf %lf %lf", &vec[0], &vec[1], &vec[2]) != 3) {
107 >        if (!sscanvec(sskip(s), vec)) {
108                  if (dev->getcur == NULL)
109                          return(-1);
110                  (*dev->comout)("Pick view center\n");
111                  if ((*dev->getcur)(&x, &y) == ABORT)
112                          return(-1);
113 <                viewray(thisray.rorg, thisray.rdir, &ourview,
114 <                                (x+.5)/hresolu, (y+.5)/vresolu);
113 >                if ((thisray.rmax = viewray(thisray.rorg, thisray.rdir,
114 >                        &ourview, (x+.5)/hresolu, (y+.5)/vresolu)) < -FTINY) {
115 >                        error(COMMAND, "not on image");
116 >                        return(-1);
117 >                }
118                  if (!direc || ourview.type == VT_PAR) {
119 <                        rayorigin(&thisray, NULL, PRIMARY, 1.0);
120 <                        if (!localhit(&thisray, &thescene)) {
119 >                        rayorigin(&thisray, PRIMARY, NULL, NULL);
120 >                        while (localhit(&thisray, &thescene)) {
121 >                                OBJREC  *m = findmaterial(thisray.ro);
122 >                                if (m != NULL && !istransp(m->otype) &&
123 >                                                !isBSDFproxy(m) &&
124 >                                                (thisray.clipset == NULL ||
125 >                                                        !inset(thisray.clipset,
126 >                                                            thisray.ro->omod)))
127 >                                        break;          /* found something */
128 >                                VCOPY(thisray.rorg, thisray.rop);
129 >                                rayclear(&thisray);     /* skip invisible */
130 >                        }
131 >                        if (thisray.ro == NULL) {
132                                  error(COMMAND, "not a local object");
133                                  return(-1);
134                          }
# Line 110 | Line 141 | double  *mp;
141                                  VCOPY(vec, thisray.rdir);
142                  else
143                          VCOPY(vec, thisray.rop);
144 <        } else if (direc)
145 <                        for (i = 0; i < 3; i++)
146 <                                vec[i] -= ourview.vp[i];
144 >        } else if (direc) {
145 >                for (i = 0; i < 3; i++)
146 >                        vec[i] -= ourview.vp[i];
147 >                if (normalize(vec) == 0.0) {
148 >                        error(COMMAND, "point at view origin");
149 >                        return(-1);
150 >                }
151 >        }
152          return(0);
153   }
154  
155  
156 < float *         /* keep consistent with COLOR typedef */
157 < greyof(col)                             /* convert color to greyscale */
158 < register COLOR  col;
156 > COLORV *
157 > greyof(                         /* convert color to greyscale */
158 >        COLOR  col
159 > )
160   {
161          static COLOR  gcol;
162          double  b;
# Line 129 | Line 166 | register COLOR  col;
166          return(gcol);
167   }
168  
169 + static void
170 + recolor(                                        /* recolor the given node */
171 +        PNODE *p
172 + )
173 + {
174 +        while (p->kid != NULL) {                /* need to propogate down */
175 +                int  mx = (p->xmin + p->xmax) >> 1;
176 +                int  my = (p->ymin + p->ymax) >> 1;
177 +                int  ki;
178 +                if (p->x >= mx)
179 +                        ki = (p->y >= my) ? UR : DR;
180 +                else
181 +                        ki = (p->y >= my) ? UL : DL;
182 +                pcopy(p, p->kid+ki);
183 +                p = p->kid + ki;
184 +        }
185  
186 < paint(p, xmin, ymin, xmax, ymax)        /* compute and paint a rectangle */
187 < register PNODE  *p;
188 < int  xmin, ymin, xmax, ymax;
186 >        (*dev->paintr)(greyscale?greyof(p->v):p->v,
187 >                        p->xmin, p->ymin, p->xmax, p->ymax);
188 > }
189 >
190 > int
191 > paint(                  /* compute and paint a rectangle */
192 >        PNODE  *p
193 > )
194   {
137 –        extern long  nrays;
138 –        static long  lastflush = 0;
195          static RAY  thisray;
196          double  h, v;
141 –        register int  i;
197  
198 <        if (xmax - xmin <= 0 || ymax - ymin <= 0) {     /* empty */
199 <                p->x = xmin;
200 <                p->y = ymin;
198 >        if ((p->xmax <= p->xmin) | (p->ymax <= p->ymin)) {      /* empty */
199 >                p->x = p->xmin;
200 >                p->y = p->ymin;
201                  setcolor(p->v, 0.0, 0.0, 0.0);
202 <                return;
202 >                return(0);
203          }
204                                                  /* jitter ray direction */
205 <        p->x = h = xmin + (xmax-xmin)*frandom();
206 <        h /= hresolu;
152 <        p->y = v = ymin + (ymax-ymin)*frandom();
153 <        v /= vresolu;
205 >        p->x = h = p->xmin + (p->xmax-p->xmin)*frandom();
206 >        p->y = v = p->ymin + (p->ymax-p->ymin)*frandom();
207          
208 <        viewray(thisray.rorg, thisray.rdir, &ourview, h, v);
208 >        if ((thisray.rmax = viewray(thisray.rorg, thisray.rdir, &ourview,
209 >                        h/hresolu, v/vresolu)) < -FTINY) {
210 >                setcolor(thisray.rcol, 0.0, 0.0, 0.0);
211 >        } else if (!ray_pnprocs) {              /* immediate mode */
212 >                ray_trace(&thisray);
213 >        } else {                                /* queuing mode */
214 >                int     rval;
215 >                rayorigin(&thisray, PRIMARY, NULL, NULL);
216 >                thisray.rno = (RNUMBER)p;
217 >                rval = ray_pqueue(&thisray);
218 >                if (!rval)
219 >                        return(0);
220 >                if (rval < 0)
221 >                        return(-1);
222 >                                                /* get node for returned ray */
223 >                p = (PNODE *)thisray.rno;
224 >        }
225  
157 –        rayorigin(&thisray, NULL, PRIMARY, 1.0);
158 –        
159 –        rayvalue(&thisray);
160 –
226          copycolor(p->v, thisray.rcol);
162 –
227          scalecolor(p->v, exposure);
228  
229 <        (*dev->paintr)(greyscale?greyof(p->v):p->v, xmin, ymin, xmax, ymax);
229 >        recolor(p);                             /* paint it */
230  
231 <        if (dev->flush != NULL && nrays - lastflush >= WFLUSH) {
232 <                lastflush = nrays;
233 <                (*dev->flush)();
231 >        if (dev->flush != NULL) {               /* shall we check for input? */
232 >                static RNUMBER  lastflush = 0;
233 >                RNUMBER         counter = raynum;
234 >                int             flushintvl;
235 >                if (!ray_pnprocs) {
236 >                        counter = nrays;
237 >                        flushintvl = WFLUSH1;
238 >                } else if (ambounce == 0)
239 >                        flushintvl = ray_pnprocs*WFLUSH;
240 >                else if (niflush < WFLUSH)
241 >                        flushintvl = ray_pnprocs*niflush/(ambounce*(ambounce>0)+1);
242 >                else
243 >                        flushintvl = ray_pnprocs*WFLUSH/(ambounce*(ambounce>0)+1);
244 >                if (lastflush > counter)
245 >                        lastflush = 0;          /* counter wrapped */
246 >
247 >                if (counter - lastflush >= flushintvl) {
248 >                        lastflush = counter;
249 >                        (*dev->flush)();
250 >                        niflush++;
251 >                }
252          }
253 +        return(1);
254   }
255  
256  
257 < newimage()                              /* start a new image */
257 > int
258 > waitrays(void)                                  /* finish up pending rays */
259   {
260 +        int     nwaited = 0;
261 +        int     rval;
262 +        RAY     raydone;
263 +
264 +        if (!ray_pnprocs)                       /* immediate mode? */
265 +                return(0);
266 +        while ((rval = ray_presult(&raydone, 0)) > 0) {
267 +                PNODE  *p = (PNODE *)raydone.rno;
268 +                copycolor(p->v, raydone.rcol);
269 +                scalecolor(p->v, exposure);
270 +                recolor(p);
271 +                nwaited++;
272 +        }
273 +        if (rval < 0)
274 +                return(-1);
275 +        return(nwaited);
276 + }
277 +
278 +
279 + void
280 + newimage(                                       /* start a new image */
281 +        char *s
282 + )
283 + {
284 +        int             newnp = 0;
285 +                                                /* # rendering procs arg? */
286 +        if (s != NULL)
287 +                sscanf(s, "%d", &newnp);
288                                                  /* free old image */
289          freepkids(&ptrunk);
290                                                  /* compute resolution */
291          hresolu = dev->xsiz;
292          vresolu = dev->ysiz;
293          normaspect(viewaspect(&ourview), &dev->pixaspect, &hresolu, &vresolu);
294 <        pframe.l = pframe.d = 0;
295 <        pframe.r = hresolu; pframe.u = vresolu;
294 >        ptrunk.xmin = ptrunk.ymin = pframe.l = pframe.d = 0;
295 >        ptrunk.xmax = pframe.r = hresolu;
296 >        ptrunk.ymax = pframe.u = vresolu;
297          pdepth = 0;
298                                                  /* clear device */
299          (*dev->clear)(hresolu, vresolu);
300 <                                                /* get first value */
301 <        paint(&ptrunk, 0, 0, hresolu, vresolu);
300 >
301 >        if (newparam) {                         /* (re)start rendering procs */
302 >                if (ray_pnprocs)
303 >                        ray_pclose(0);          /* should already be closed */
304 >                if (newnp > 0)
305 >                        nproc = newnp;
306 >                if (nproc > 1)
307 >                        ray_popen(nproc);
308 >                newparam = 0;
309 >        } else if ((newnp > 0) & (newnp != nproc)) {
310 >                if (newnp == 1)                 /* change # rendering procs */
311 >                        ray_pclose(0);
312 >                else if (newnp < ray_pnprocs)
313 >                        ray_pclose(ray_pnprocs - newnp);
314 >                else
315 >                        ray_popen(newnp - ray_pnprocs);
316 >                nproc = newnp;
317 >        }
318 >        niflush = 0;                            /* get first value */
319 >        paint(&ptrunk);
320   }
321  
322  
323 < redraw()                                /* redraw the image */
323 > void
324 > redraw(void)                            /* redraw the image */
325   {
326          (*dev->clear)(hresolu, vresolu);
327          (*dev->comout)("redrawing...\n");
# Line 198 | Line 330 | redraw()                               /* redraw the image */
330   }
331  
332  
333 < repaint(xmin, ymin, xmax, ymax)                 /* repaint a region */
334 < int  xmin, ymin, xmax, ymax;
333 > void
334 > repaint(                                /* repaint a region */
335 >        int  xmin,
336 >        int  ymin,
337 >        int  xmax,
338 >        int  ymax
339 > )
340   {
341          RECT  reg;
342  
343          reg.l = xmin; reg.r = xmax;
344          reg.d = ymin; reg.u = ymax;
345  
346 <        paintrect(&ptrunk, 0, 0, hresolu, vresolu, &reg);
346 >        paintrect(&ptrunk, &reg);
347   }
348  
349  
350 < paintrect(p, xmin, ymin, xmax, ymax, r)         /* paint picture rectangle */
351 < register PNODE  *p;
352 < int  xmin, ymin, xmax, ymax;
353 < register RECT  *r;
350 > void
351 > paintrect(                              /* paint picture rectangle */
352 >        PNODE  *p,
353 >        RECT  *r
354 > )
355   {
356          int  mx, my;
357  
358 <        if (xmax - xmin <= 0 || ymax - ymin <= 0)
358 >        if (p->xmax - p->xmin <= 0 || p->ymax - p->ymin <= 0)
359                  return;
360  
361          if (p->kid == NULL) {
362                  (*dev->paintr)(greyscale?greyof(p->v):p->v,
363 <                                xmin, ymin, xmax, ymax);        /* do this */
363 >                        p->xmin, p->ymin, p->xmax, p->ymax);    /* do this */
364                  return;
365          }
366 <        mx = (xmin + xmax) >> 1;                                /* do kids */
367 <        my = (ymin + ymax) >> 1;
366 >        mx = (p->xmin + p->xmax) >> 1;                          /* do kids */
367 >        my = (p->ymin + p->ymax) >> 1;
368          if (mx > r->l) {
369                  if (my > r->d)
370 <                        paintrect(p->kid+DL, xmin, ymin, mx, my, r);
370 >                        paintrect(p->kid+DL, r);
371                  if (my < r->u)
372 <                        paintrect(p->kid+UL, xmin, my, mx, ymax, r);
372 >                        paintrect(p->kid+UL, r);
373          }
374          if (mx < r->r) {
375                  if (my > r->d)
376 <                        paintrect(p->kid+DR, mx, ymin, xmax, my, r);
376 >                        paintrect(p->kid+DR, r);
377                  if (my < r->u)
378 <                        paintrect(p->kid+UR, mx, my, xmax, ymax, r);
378 >                        paintrect(p->kid+UR, r);
379          }
380   }
381  
382  
383   PNODE *
384 < findrect(x, y, p, r, pd)                /* find a rectangle */
385 < int  x, y;
386 < register PNODE  *p;
387 < register RECT  *r;
388 < int  pd;
384 > findrect(                               /* find a rectangle */
385 >        int  x,
386 >        int  y,
387 >        PNODE  *p,
388 >        int  pd
389 > )
390   {
391          int  mx, my;
392  
393          while (p->kid != NULL && pd--) {
394  
395 <                mx = (r->l + r->r) >> 1;
396 <                my = (r->d + r->u) >> 1;
395 >                mx = (p->xmin + p->xmax) >> 1;
396 >                my = (p->ymin + p->ymax) >> 1;
397  
398                  if (x < mx) {
260 –                        r->r = mx;
399                          if (y < my) {
262 –                                r->u = my;
400                                  p = p->kid+DL;
401                          } else {
265 –                                r->d = my;
402                                  p = p->kid+UL;
403                          }
404                  } else {
269 –                        r->l = mx;
405                          if (y < my) {
271 –                                r->u = my;
406                                  p = p->kid+DR;
407                          } else {
274 –                                r->d = my;
408                                  p = p->kid+UR;
409                          }
410                  }
# Line 280 | Line 413 | int  pd;
413   }
414  
415  
416 < scalepict(p, sf)                        /* scale picture values */
417 < register PNODE  *p;
418 < double  sf;
416 > void
417 > compavg(                                /* recompute averages */
418 >        PNODE   *p
419 > )
420   {
421 +        int     i, navg;
422 +        
423 +        if (p->kid == NULL)
424 +                return;
425 +
426 +        setcolor(p->v, .0, .0, .0);
427 +        navg = 0;
428 +        for (i = 0; i < 4; i++) {
429 +                if (p->kid[i].xmin >= p->kid[i].xmax) continue;
430 +                if (p->kid[i].ymin >= p->kid[i].ymax) continue;
431 +                compavg(p->kid+i);
432 +                addcolor(p->v, p->kid[i].v);
433 +                navg++;
434 +        }
435 +        if (navg > 1)
436 +                scalecolor(p->v, 1./navg);
437 + }
438 +
439 +
440 + void
441 + scalepict(                              /* scale picture values */
442 +        PNODE  *p,
443 +        double  sf
444 + )
445 + {
446          scalecolor(p->v, sf);           /* do this node */
447  
448          if (p->kid == NULL)
# Line 296 | Line 455 | double  sf;
455   }
456  
457  
458 < getpictcolrs(yoff, scan, p, xsiz, ysiz) /* get scanline from picture */
459 < int  yoff;
460 < register COLR  *scan;
461 < register PNODE  *p;
462 < int  xsiz, ysiz;
458 > void
459 > getpictcolrs(                           /* get scanline from picture */
460 >        int  yoff,
461 >        COLR  *scan,
462 >        PNODE  *p,
463 >        int  xsiz,
464 >        int  ysiz
465 > )
466   {
467 <        register int  mx;
467 >        int  mx;
468          int  my;
469  
470          if (p->kid == NULL) {                   /* do this node */
# Line 326 | Line 488 | int  xsiz, ysiz;
488   }
489  
490  
491 < pcopy(p1, p2)                           /* copy paint node p1 into p2 */
492 < register PNODE  *p1, *p2;
491 > void
492 > freepkids(                              /* free pnode's children */
493 >        PNODE  *p
494 > )
495   {
332 –        copycolor(p2->v, p1->v);
333 –        p2->x = p1->x;
334 –        p2->y = p1->y;
335 – }
336 –
337 –
338 – freepkids(p)                            /* free pnode's children */
339 – register PNODE  *p;
340 – {
496          if (p->kid == NULL)
497                  return;
498          freepkids(p->kid+DL);
499          freepkids(p->kid+DR);
500          freepkids(p->kid+UL);
501          freepkids(p->kid+UR);
502 <        free((char *)p->kid);
502 >        free((void *)p->kid);
503          p->kid = NULL;
504   }
505  
506  
507 < newview(vp)                             /* change viewing parameters */
508 < register VIEW  *vp;
507 > void
508 > newview(                                        /* change viewing parameters */
509 >        VIEW  *vp
510 > )
511   {
512          char  *err;
513  
514          if ((err = setview(vp)) != NULL) {
515                  sprintf(errmsg, "view not set - %s", err);
516                  error(COMMAND, errmsg);
517 <        } else if (bcmp((char *)vp, (char *)&ourview, sizeof(VIEW))) {
518 <                copystruct(&oldview, &ourview);
519 <                copystruct(&ourview, vp);
520 <                newimage();             /* newimage() calls with vp=&ourview! */
517 >        } else if (memcmp((char *)vp, (char *)&ourview, sizeof(VIEW))) {
518 >                oldview = ourview;
519 >                ourview = *vp;
520 >                newimage(NULL);
521          }
522   }
523  
524  
525 < moveview(angle, elev, mag, vc)                  /* move viewpoint */
526 < double  angle, elev, mag;
527 < FVECT  vc;
525 > void
526 > moveview(                                       /* move viewpoint */
527 >        double  angle,
528 >        double  elev,
529 >        double  mag,
530 >        FVECT  vc
531 > )
532   {
372 –        extern double  sqrt(), dist2();
533          double  d;
534 <        FVECT  v1;
535 <        VIEW  nv;
376 <        register int  i;
534 >        VIEW  nv = ourview;
535 >        int  i;
536  
378 –        VCOPY(nv.vup, ourview.vup);
379 –        nv.hoff = ourview.hoff; nv.voff = ourview.voff;
537          spinvector(nv.vdir, ourview.vdir, ourview.vup, angle*(PI/180.));
538 <        if (elev != 0.0) {
539 <                fcross(v1, ourview.vup, nv.vdir);
540 <                normalize(v1);
541 <                spinvector(nv.vdir, nv.vdir, v1, elev*(PI/180.));
542 <        }
543 <        if ((nv.type = ourview.type) == VT_PAR) {
387 <                nv.horiz = ourview.horiz / mag;
388 <                nv.vert = ourview.vert / mag;
538 >        if (elev != 0.0)
539 >                geodesic(nv.vdir, nv.vdir, nv.vup, elev*(-PI/180.), GEOD_RAD);
540 >
541 >        if (nv.type == VT_PAR) {
542 >                nv.horiz /= mag;
543 >                nv.vert /= mag;
544                  d = 0.0;                        /* don't move closer */
545                  for (i = 0; i < 3; i++)
546                          d += (vc[i] - ourview.vp[i])*ourview.vdir[i];
547          } else {
393 –                nv.horiz = ourview.horiz;
394 –                nv.vert = ourview.vert;
548                  d = sqrt(dist2(ourview.vp, vc)) / mag;
549 +                if (nv.vfore > FTINY) {
550 +                        nv.vfore += d - d*mag;
551 +                        if (nv.vfore < 0.0) nv.vfore = 0.0;
552 +                }
553 +                if (nv.vaft > FTINY) {
554 +                        nv.vaft += d - d*mag;
555 +                        if (nv.vaft <= nv.vfore) nv.vaft = 0.0;
556 +                }
557 +                nv.vdist /= mag;
558          }
559          for (i = 0; i < 3; i++)
560                  nv.vp[i] = vc[i] - d*nv.vdir[i];
# Line 400 | Line 562 | FVECT  vc;
562   }
563  
564  
565 < spinvector(vres, vorig, vnorm, theta)   /* rotate vector around normal */
566 < FVECT  vres, vorig, vnorm;
567 < double  theta;
565 > void
566 > pcopy(                                  /* copy paint node p1 into p2 */
567 >        PNODE  *p1,
568 >        PNODE  *p2
569 > )
570   {
571 <        extern double  sin(), cos();
572 <        double  sint, cost, dotp;
573 <        FVECT  vperp;
574 <        register int  i;
575 <        
576 <        if (theta == 0.0) {
577 <                VCOPY(vres, vorig);
571 >        copycolor(p2->v, p1->v);
572 >        p2->x = p1->x;
573 >        p2->y = p1->y;
574 > }
575 >
576 >
577 > void
578 > zoomview(                               /* zoom in or out */
579 >        VIEW  *vp,
580 >        double  zf
581 > )
582 > {
583 >        switch (vp->type) {
584 >        case VT_PAR:                            /* parallel view */
585 >                vp->horiz /= zf;
586 >                vp->vert /= zf;
587                  return;
588 +        case VT_ANG:                            /* angular fisheye */
589 +                vp->horiz /= zf;
590 +                if (vp->horiz > 360.)
591 +                        vp->horiz = 360.;
592 +                vp->vert /= zf;
593 +                if (vp->vert > 360.)
594 +                        vp->vert = 360.;
595 +                return;
596 +        case VT_PLS:                            /* planisphere fisheye */
597 +                vp->horiz = sin((PI/180./2.)*vp->horiz) /
598 +                                (1.0 + cos((PI/180./2.)*vp->horiz)) / zf;
599 +                vp->horiz *= vp->horiz;
600 +                vp->horiz = (2.*180./PI)*acos((1. - vp->horiz) /
601 +                                                (1. + vp->horiz));
602 +                vp->vert = sin((PI/180./2.)*vp->vert) /
603 +                                (1.0 + cos((PI/180./2.)*vp->vert)) / zf;
604 +                vp->vert *= vp->vert;
605 +                vp->vert = (2.*180./PI)*acos((1. - vp->vert) /
606 +                                                (1. + vp->vert));
607 +                return;
608 +        case VT_CYL:                            /* cylindrical panorama */
609 +                vp->horiz /= zf;
610 +                if (vp->horiz > 360.)
611 +                        vp->horiz = 360.;
612 +                vp->vert = atan(tan(vp->vert*(PI/180./2.))/zf) / (PI/180./2.);
613 +                return;
614 +        case VT_PER:                            /* perspective view */
615 +                vp->horiz = atan(tan(vp->horiz*(PI/180./2.))/zf) /
616 +                                (PI/180./2.);
617 +                vp->vert = atan(tan(vp->vert*(PI/180./2.))/zf) /
618 +                                (PI/180./2.);
619 +                return;
620 +        case VT_HEM:                            /* hemispherical fisheye */
621 +                vp->horiz = sin(vp->horiz*(PI/180./2.))/zf;
622 +                if (vp->horiz >= 1.0-FTINY)
623 +                        vp->horiz = 180.;
624 +                else
625 +                        vp->horiz = asin(vp->horiz) / (PI/180./2.);
626 +                vp->vert = sin(vp->vert*(PI/180./2.))/zf;
627 +                if (vp->vert >= 1.0-FTINY)
628 +                        vp->vert = 180.;
629 +                else
630 +                        vp->vert = asin(vp->vert) / (PI/180./2.);
631 +                return;
632          }
416 –        sint = sin(theta);
417 –        cost = cos(theta);
418 –        dotp = DOT(vorig, vnorm);
419 –        fcross(vperp, vnorm, vorig);
420 –        for (i = 0; i < 3; i++)
421 –                vres[i] = vnorm[i]*dotp*(1.-cost) +
422 –                                vorig[i]*cost + vperp[i]*sint;
633   }

Diff Legend

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