src/rt/rv3.c

/* Copyright (c) 1987 Regents of the University of California */

#ifndef lint
static char SCCSid[] = "$SunId$ LBL";
#endif

/*
 *  rv3.c - miscellaneous routines for rview.
 *
 *     5/11/87
 */

#include  "ray.h"

#include  "octree.h"

#include  "rpaint.h"

#include  "random.h"


getrect(s, r)                           /* get a box */
char  *s;
register RECT  *r;
{
        int  x0, y0, x1, y1;

        if (*s && !strncmp(s, "all", strlen(s))) {
                r->l = r->d = 0;
                r->r = hresolu;
                r->u = vresolu;
                return(0);
        }
        if (sscanf(s, "%d %d %d %d", &x0, &y0, &x1, &y1) != 4) {
                if (dev->getcur == NULL)
                        return(-1);
                (*dev->comout)("Pick first corner\n");
                if ((*dev->getcur)(&x0, &y0) == ABORT)
                        return(-1);
                (*dev->comout)("Pick second corner\n");
                if ((*dev->getcur)(&x1, &y1) == ABORT)
                        return(-1);
        }
        if (x0 < x1) {
                r->l = x0;
                r->r = x1;
        } else {
                r->l = x1;
                r->r = x0;
        }
        if (y0 < y1) {
                r->d = y0;
                r->u = y1;
        } else {
                r->d = y1;
                r->u = y0;
        }
        if (r->l < 0) r->l = 0;
        if (r->d < 0) r->d = 0;
        if (r->r > hresolu) r->r = hresolu;
        if (r->u > vresolu) r->u = vresolu;
        if (r->l > r->r) r->l = r->r;
        if (r->d > r->u) r->d = r->u;
        return(0);
}


getinterest(s, direc, vec, mp)          /* get area of interest */
char  *s;
int  direc;
FVECT  vec;
double  *mp;
{
        int  x, y;
        RAY  thisray;
        register int  i;

        if (sscanf(s, "%lf", mp) != 1)
                *mp = 1.0;
        else if (*mp < -FTINY)          /* negative zoom is reduction */
                *mp = -1.0 / *mp;
        else if (*mp <= FTINY) {        /* too small */
                error(COMMAND, "illegal magnification");
                return(-1);
        }
        if (sscanf(s, "%*lf %lf %lf %lf", &vec[0], &vec[1], &vec[2]) != 3) {
                if (dev->getcur == NULL)
                        return(-1);
                (*dev->comout)("Pick view center\n");
                if ((*dev->getcur)(&x, &y) == ABORT)
                        return(-1);
                viewray(thisray.rorg, thisray.rdir, &ourview,
                                (x+.5)/hresolu, (y+.5)/vresolu);
                if (!direc || ourview.type == VT_PAR) {
                        rayorigin(&thisray, NULL, PRIMARY, 1.0);
                        if (!localhit(&thisray, &thescene)) {
                                error(COMMAND, "not a local object");
                                return(-1);
                        }
                }
                if (direc)
                        if (ourview.type == VT_PAR)
                                for (i = 0; i < 3; i++)
                                        vec[i] = thisray.rop[i] - ourview.vp[i];
                        else
                                VCOPY(vec, thisray.rdir);
                else
                        VCOPY(vec, thisray.rop);
        } else if (direc)
                        for (i = 0; i < 3; i++)
                                vec[i] -= ourview.vp[i];
        return(0);
}


float *         /* keep consistent with COLOR typedef */
greyof(col)                             /* convert color to greyscale */
register COLOR  col;
{
        static COLOR  gcol;
        double  b;

        b = bright(col);
        setcolor(gcol, b, b, b);
        return(gcol);
}


paint(p, xmin, ymin, xmax, ymax)        /* compute and paint a rectangle */
register PNODE  *p;
int  xmin, ymin, xmax, ymax;
{
        static RAY  thisray;
        double  h, v;
        register int  i;

        if (xmax - xmin <= 0 || ymax - ymin <= 0) {     /* empty */
                p->x = xmin;
                p->y = ymin;
                setcolor(p->v, 0.0, 0.0, 0.0);
                return;
        }
                                                /* jitter ray direction */
        p->x = h = xmin + (xmax-xmin)*frandom();
        h /= hresolu;
        p->y = v = ymin + (ymax-ymin)*frandom();
        v /= vresolu;
        
        viewray(thisray.rorg, thisray.rdir, &ourview, h, v);

        rayorigin(&thisray, NULL, PRIMARY, 1.0);
        
        rayvalue(&thisray);

        copycolor(p->v, thisray.rcol);

        scalecolor(p->v, exposure);

        (*dev->paintr)(greyscale?greyof(p->v):p->v, xmin, ymin, xmax, ymax);
}


newimage()                              /* start a new image */
{
                                                /* free old image */
        freepkids(&ptrunk);
                                                /* compute resolution */
        if (viewaspect(&ourview)*dev->xsiz > dev->pixaspect*dev->ysiz) {
                vresolu = dev->ysiz;
                hresolu = vresolu/viewaspect(&ourview)*dev->pixaspect;
        } else {
                hresolu = dev->xsiz;
                vresolu = hresolu*viewaspect(&ourview)/dev->pixaspect;
        }
        pframe.l = pframe.d = 0;
        pframe.r = hresolu; pframe.u = vresolu;
        pdepth = 0;
                                                /* clear device */
        (*dev->clear)(hresolu, vresolu);
                                                /* get first value */
        paint(&ptrunk, 0, 0, hresolu, vresolu);
}


redraw()                                /* redraw the image */
{
        (*dev->clear)(hresolu, vresolu);
        (*dev->comout)("redrawing...\n");
        repaint(0, 0, hresolu, vresolu);
        (*dev->comout)("\n");
}


repaint(xmin, ymin, xmax, ymax)                 /* repaint a region */
int  xmin, ymin, xmax, ymax;
{
        RECT  reg;

        reg.l = xmin; reg.r = xmax;
        reg.d = ymin; reg.u = ymax;

        paintrect(&ptrunk, 0, 0, hresolu, vresolu, &reg);
}


paintrect(p, xmin, ymin, xmax, ymax, r)         /* paint picture rectangle */
register PNODE  *p;
int  xmin, ymin, xmax, ymax;
register RECT  *r;
{
        int  mx, my;

        if (xmax - xmin <= 0 || ymax - ymin <= 0)
                return;

        if (p->kid == NULL) {
                (*dev->paintr)(greyscale?greyof(p->v):p->v,
                                xmin, ymin, xmax, ymax);        /* do this */
                return;
        }
        mx = (xmin + xmax) >> 1;                                /* do kids */
        my = (ymin + ymax) >> 1;
        if (mx > r->l) {
                if (my > r->d)
                        paintrect(p->kid+DL, xmin, ymin, mx, my, r);
                if (my < r->u)
                        paintrect(p->kid+UL, xmin, my, mx, ymax, r);
        }
        if (mx < r->r) {
                if (my > r->d)
                        paintrect(p->kid+DR, mx, ymin, xmax, my, r);
                if (my < r->u)
                        paintrect(p->kid+UR, mx, my, xmax, ymax, r);
        }
}


PNODE *
findrect(x, y, p, r, pd)                /* find a rectangle */
int  x, y;
register PNODE  *p;
register RECT  *r;
int  pd;
{
        int  mx, my;

        while (p->kid != NULL && pd--) {

                mx = (r->l + r->r) >> 1;
                my = (r->d + r->u) >> 1;

                if (x < mx) {
                        r->r = mx;
                        if (y < my) {
                                r->u = my;
                                p = p->kid+DL;
                        } else {
                                r->d = my;
                                p = p->kid+UL;
                        }
                } else {
                        r->l = mx;
                        if (y < my) {
                                r->u = my;
                                p = p->kid+DR;
                        } else {
                                r->d = my;
                                p = p->kid+UR;
                        }
                }
        }
        return(p);
}


scalepict(p, sf)                        /* scale picture values */
register PNODE  *p;
double  sf;
{
        scalecolor(p->v, sf);           /* do this node */

        if (p->kid == NULL)
                return;
                                        /* do children */
        scalepict(p->kid+DL, sf);
        scalepict(p->kid+DR, sf);
        scalepict(p->kid+UL, sf);
        scalepict(p->kid+UR, sf);
}


getpictcolrs(yoff, scan, p, xsiz, ysiz) /* get scanline from picture */
int  yoff;
register COLR  *scan;
register PNODE  *p;
int  xsiz, ysiz;
{
        register int  mx;
        int  my;

        if (p->kid == NULL) {                   /* do this node */
                setcolr(scan[0], colval(p->v,RED),
                                colval(p->v,GRN),
                                colval(p->v,BLU));
                for (mx = 1; mx < xsiz; mx++)
                        copycolr(scan[mx], scan[0]);
                return;
        }
                                                /* do kids */
        mx = xsiz >> 1;
        my = ysiz >> 1;
        if (yoff < my) {
                getpictcolrs(yoff, scan, p->kid+DL, mx, my);
                getpictcolrs(yoff, scan+mx, p->kid+DR, xsiz-mx, my);
        } else {
                getpictcolrs(yoff-my, scan, p->kid+UL, mx, ysiz-my);
                getpictcolrs(yoff-my, scan+mx, p->kid+UR, xsiz-mx, ysiz-my);
        }
}


pcopy(p1, p2)                           /* copy paint node p1 into p2 */
register PNODE  *p1, *p2;
{
        copycolor(p2->v, p1->v);
        p2->x = p1->x;
        p2->y = p1->y;
}


freepkids(p)                            /* free pnode's children */
register PNODE  *p;
{
        if (p->kid == NULL)
                return;
        freepkids(p->kid+DL);
        freepkids(p->kid+DR);
        freepkids(p->kid+UL);
        freepkids(p->kid+UR);
        free((char *)p->kid);
        p->kid = NULL;
}


newview(vp)                             /* change viewing parameters */
register VIEW  *vp;
{
        char  *err;

        if ((err = setview(vp)) != NULL) {
                sprintf(errmsg, "view not set - %s", err);
                error(COMMAND, errmsg);
        } else if (bcmp(vp, &ourview, sizeof(VIEW))) {
                copyview(&oldview, &ourview);
                copyview(&ourview, vp);
                newimage();             /* newimage() calls with vp=&ourview! */
        }
}


moveview(angle, elev, mag, vc)                  /* move viewpoint */
double  angle, elev, mag;
FVECT  vc;
{
        extern double  sqrt(), dist2();
        double  d;
        FVECT  v1;
        VIEW  nv;
        register int  i;

        VCOPY(nv.vup, ourview.vup);
        nv.hoff = ourview.hoff; nv.voff = ourview.voff;
        spinvector(nv.vdir, ourview.vdir, ourview.vup, angle*(PI/180.));
        if (elev != 0.0) {
                fcross(v1, ourview.vup, nv.vdir);
                normalize(v1);
                spinvector(nv.vdir, nv.vdir, v1, elev*(PI/180.));
        }
        if ((nv.type = ourview.type) == VT_PAR) {
                nv.horiz = ourview.horiz / mag;
                nv.vert = ourview.vert / mag;
                d = 0.0;                        /* don't move closer */
                for (i = 0; i < 3; i++)
                        d += (vc[i] - ourview.vp[i])*ourview.vdir[i];
        } else {
                nv.horiz = ourview.horiz;
                nv.vert = ourview.vert;
                d = sqrt(dist2(ourview.vp, vc)) / mag;
        }
        for (i = 0; i < 3; i++)
                nv.vp[i] = vc[i] - d*nv.vdir[i];
        newview(&nv);
}


spinvector(vres, vorig, vnorm, theta)   /* rotate vector around normal */
FVECT  vres, vorig, vnorm;
double  theta;
{
        extern double  sin(), cos();
        double  sint, cost, dotp;
        FVECT  vperp;
        register int  i;
        
        if (theta == 0.0) {
                VCOPY(vres, vorig);
                return;
        }
        sint = sin(theta);
        cost = cos(theta);
        dotp = DOT(vorig, vnorm);
        fcross(vperp, vnorm, vorig);
        for (i = 0; i < 3; i++)
                vres[i] = vnorm[i]*dotp*(1.-cost) +
                                vorig[i]*cost + vperp[i]*sint;
}
Revision:	1.9
Committed:	Mon Jan 8 13:38:09 1990 UTC (35 years, 10 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.8:	+26 -26 lines
Log Message:	Changed handling of view parameters
#	User	Rev	Content
1	greg	1.1	/* Copyright (c) 1987 Regents of the University of California */
2
3			#ifndef lint
4			static char SCCSid[] = "$SunId$ LBL";
5			#endif
6
7			/*
8			* rv3.c - miscellaneous routines for rview.
9			*
10			* 5/11/87
11			*/
12
13			#include "ray.h"
14
15	greg	1.7	#include "octree.h"
16
17	greg	1.1	#include "rpaint.h"
18
19			#include "random.h"
20	greg	1.7
21
22			getrect(s, r) /* get a box */
23			char *s;
24			register RECT *r;
25			{
26			int x0, y0, x1, y1;
27
28			if (*s && !strncmp(s, "all", strlen(s))) {
29			r->l = r->d = 0;
30	greg	1.9	r->r = hresolu;
31			r->u = vresolu;
32	greg	1.7	return(0);
33			}
34			if (sscanf(s, "%d %d %d %d", &x0, &y0, &x1, &y1) != 4) {
35			if (dev->getcur == NULL)
36			return(-1);
37			(*dev->comout)("Pick first corner\n");
38			if ((*dev->getcur)(&x0, &y0) == ABORT)
39			return(-1);
40			(*dev->comout)("Pick second corner\n");
41			if ((*dev->getcur)(&x1, &y1) == ABORT)
42			return(-1);
43			}
44			if (x0 < x1) {
45			r->l = x0;
46			r->r = x1;
47			} else {
48			r->l = x1;
49			r->r = x0;
50			}
51			if (y0 < y1) {
52			r->d = y0;
53			r->u = y1;
54			} else {
55			r->d = y1;
56			r->u = y0;
57			}
58			if (r->l < 0) r->l = 0;
59			if (r->d < 0) r->d = 0;
60	greg	1.9	if (r->r > hresolu) r->r = hresolu;
61			if (r->u > vresolu) r->u = vresolu;
62	greg	1.7	if (r->l > r->r) r->l = r->r;
63			if (r->d > r->u) r->d = r->u;
64			return(0);
65			}
66
67
68			getinterest(s, direc, vec, mp) /* get area of interest */
69			char *s;
70			int direc;
71			FVECT vec;
72			double *mp;
73			{
74			int x, y;
75			RAY thisray;
76			register int i;
77
78			if (sscanf(s, "%lf", mp) != 1)
79			*mp = 1.0;
80			else if (mp < -FTINY) / negative zoom is reduction */
81			mp = -1.0 / mp;
82			else if (mp <= FTINY) { / too small */
83			error(COMMAND, "illegal magnification");
84			return(-1);
85			}
86			if (sscanf(s, "%*lf %lf %lf %lf", &vec[0], &vec[1], &vec[2]) != 3) {
87			if (dev->getcur == NULL)
88			return(-1);
89			(*dev->comout)("Pick view center\n");
90			if ((*dev->getcur)(&x, &y) == ABORT)
91			return(-1);
92	greg	1.9	viewray(thisray.rorg, thisray.rdir, &ourview,
93			(x+.5)/hresolu, (y+.5)/vresolu);
94	greg	1.7	if (!direc \|\| ourview.type == VT_PAR) {
95			rayorigin(&thisray, NULL, PRIMARY, 1.0);
96			if (!localhit(&thisray, &thescene)) {
97			error(COMMAND, "not a local object");
98			return(-1);
99			}
100			}
101			if (direc)
102			if (ourview.type == VT_PAR)
103			for (i = 0; i < 3; i++)
104			vec[i] = thisray.rop[i] - ourview.vp[i];
105			else
106			VCOPY(vec, thisray.rdir);
107			else
108			VCOPY(vec, thisray.rop);
109			} else if (direc)
110			for (i = 0; i < 3; i++)
111			vec[i] -= ourview.vp[i];
112			return(0);
113			}
114	greg	1.1
115
116			float * /* keep consistent with COLOR typedef */
117			greyof(col) /* convert color to greyscale */
118			register COLOR col;
119			{
120			static COLOR gcol;
121			double b;
122
123			b = bright(col);
124			setcolor(gcol, b, b, b);
125			return(gcol);
126			}
127
128
129			paint(p, xmin, ymin, xmax, ymax) /* compute and paint a rectangle */
130			register PNODE *p;
131			int xmin, ymin, xmax, ymax;
132			{
133			static RAY thisray;
134			double h, v;
135			register int i;
136
137			if (xmax - xmin <= 0 \|\| ymax - ymin <= 0) { /* empty */
138			p->x = xmin;
139			p->y = ymin;
140			setcolor(p->v, 0.0, 0.0, 0.0);
141			return;
142			}
143			/* jitter ray direction */
144			p->x = h = xmin + (xmax-xmin)*frandom();
145	greg	1.9	h /= hresolu;
146	greg	1.1	p->y = v = ymin + (ymax-ymin)*frandom();
147	greg	1.9	v /= vresolu;
148	greg	1.1
149	greg	1.9	viewray(thisray.rorg, thisray.rdir, &ourview, h, v);
150	greg	1.1
151			rayorigin(&thisray, NULL, PRIMARY, 1.0);
152
153			rayvalue(&thisray);
154
155			copycolor(p->v, thisray.rcol);
156
157			scalecolor(p->v, exposure);
158
159			(*dev->paintr)(greyscale?greyof(p->v):p->v, xmin, ymin, xmax, ymax);
160			}
161
162
163			newimage() /* start a new image */
164			{
165			/* free old image */
166			freepkids(&ptrunk);
167	greg	1.9	/* compute resolution */
168			if (viewaspect(&ourview)dev->xsiz > dev->pixaspectdev->ysiz) {
169			vresolu = dev->ysiz;
170			hresolu = vresolu/viewaspect(&ourview)*dev->pixaspect;
171			} else {
172			hresolu = dev->xsiz;
173			vresolu = hresolu*viewaspect(&ourview)/dev->pixaspect;
174			}
175	greg	1.1	pframe.l = pframe.d = 0;
176	greg	1.9	pframe.r = hresolu; pframe.u = vresolu;
177	greg	1.1	pdepth = 0;
178			/* clear device */
179	greg	1.9	(*dev->clear)(hresolu, vresolu);
180	greg	1.1	/* get first value */
181	greg	1.9	paint(&ptrunk, 0, 0, hresolu, vresolu);
182	greg	1.1	}
183
184
185			redraw() /* redraw the image */
186			{
187	greg	1.9	(*dev->clear)(hresolu, vresolu);
188	greg	1.1	(*dev->comout)("redrawing...\n");
189	greg	1.9	repaint(0, 0, hresolu, vresolu);
190	greg	1.1	(*dev->comout)("\n");
191			}
192
193
194			repaint(xmin, ymin, xmax, ymax) /* repaint a region */
195			int xmin, ymin, xmax, ymax;
196			{
197			RECT reg;
198
199			reg.l = xmin; reg.r = xmax;
200			reg.d = ymin; reg.u = ymax;
201
202	greg	1.9	paintrect(&ptrunk, 0, 0, hresolu, vresolu, &reg);
203	greg	1.1	}
204
205
206			paintrect(p, xmin, ymin, xmax, ymax, r) /* paint picture rectangle */
207			register PNODE *p;
208			int xmin, ymin, xmax, ymax;
209			register RECT *r;
210			{
211			int mx, my;
212
213			if (xmax - xmin <= 0 \|\| ymax - ymin <= 0)
214			return;
215
216			if (p->kid == NULL) {
217			(*dev->paintr)(greyscale?greyof(p->v):p->v,
218			xmin, ymin, xmax, ymax); /* do this */
219			return;
220			}
221			mx = (xmin + xmax) >> 1; /* do kids */
222			my = (ymin + ymax) >> 1;
223			if (mx > r->l) {
224			if (my > r->d)
225			paintrect(p->kid+DL, xmin, ymin, mx, my, r);
226			if (my < r->u)
227			paintrect(p->kid+UL, xmin, my, mx, ymax, r);
228			}
229			if (mx < r->r) {
230			if (my > r->d)
231			paintrect(p->kid+DR, mx, ymin, xmax, my, r);
232			if (my < r->u)
233			paintrect(p->kid+UR, mx, my, xmax, ymax, r);
234			}
235			}
236
237
238			PNODE *
239			findrect(x, y, p, r, pd) /* find a rectangle */
240			int x, y;
241			register PNODE *p;
242			register RECT *r;
243			int pd;
244			{
245			int mx, my;
246
247			while (p->kid != NULL && pd--) {
248
249			mx = (r->l + r->r) >> 1;
250			my = (r->d + r->u) >> 1;
251
252			if (x < mx) {
253			r->r = mx;
254			if (y < my) {
255			r->u = my;
256			p = p->kid+DL;
257			} else {
258			r->d = my;
259			p = p->kid+UL;
260			}
261			} else {
262			r->l = mx;
263			if (y < my) {
264			r->u = my;
265			p = p->kid+DR;
266			} else {
267			r->d = my;
268			p = p->kid+UR;
269			}
270			}
271			}
272			return(p);
273			}
274
275
276			scalepict(p, sf) /* scale picture values */
277			register PNODE *p;
278			double sf;
279			{
280			scalecolor(p->v, sf); /* do this node */
281
282			if (p->kid == NULL)
283			return;
284			/* do children */
285			scalepict(p->kid+DL, sf);
286			scalepict(p->kid+DR, sf);
287			scalepict(p->kid+UL, sf);
288			scalepict(p->kid+UR, sf);
289			}
290
291
292			getpictcolrs(yoff, scan, p, xsiz, ysiz) /* get scanline from picture */
293			int yoff;
294			register COLR *scan;
295			register PNODE *p;
296			int xsiz, ysiz;
297			{
298			register int mx;
299			int my;
300
301			if (p->kid == NULL) { /* do this node */
302			setcolr(scan[0], colval(p->v,RED),
303			colval(p->v,GRN),
304			colval(p->v,BLU));
305			for (mx = 1; mx < xsiz; mx++)
306			copycolr(scan[mx], scan[0]);
307			return;
308			}
309			/* do kids */
310			mx = xsiz >> 1;
311			my = ysiz >> 1;
312			if (yoff < my) {
313			getpictcolrs(yoff, scan, p->kid+DL, mx, my);
314			getpictcolrs(yoff, scan+mx, p->kid+DR, xsiz-mx, my);
315			} else {
316			getpictcolrs(yoff-my, scan, p->kid+UL, mx, ysiz-my);
317			getpictcolrs(yoff-my, scan+mx, p->kid+UR, xsiz-mx, ysiz-my);
318			}
319			}
320
321
322			pcopy(p1, p2) /* copy paint node p1 into p2 */
323			register PNODE p1, p2;
324			{
325			copycolor(p2->v, p1->v);
326			p2->x = p1->x;
327			p2->y = p1->y;
328			}
329
330
331			freepkids(p) /* free pnode's children */
332			register PNODE *p;
333			{
334			if (p->kid == NULL)
335			return;
336			freepkids(p->kid+DL);
337			freepkids(p->kid+DR);
338			freepkids(p->kid+UL);
339			freepkids(p->kid+UR);
340			free((char *)p->kid);
341			p->kid = NULL;
342			}
343
344
345			newview(vp) /* change viewing parameters */
346			register VIEW *vp;
347			{
348			char *err;
349
350	greg	1.6	if ((err = setview(vp)) != NULL) {
351	greg	1.1	sprintf(errmsg, "view not set - %s", err);
352			error(COMMAND, errmsg);
353			} else if (bcmp(vp, &ourview, sizeof(VIEW))) {
354	greg	1.9	copyview(&oldview, &ourview);
355			copyview(&ourview, vp);
356	greg	1.6	newimage(); /* newimage() calls with vp=&ourview! */
357	greg	1.1	}
358			}
359
360
361	greg	1.4	moveview(angle, elev, mag, vc) /* move viewpoint */
362			double angle, elev, mag;
363	greg	1.1	FVECT vc;
364			{
365			extern double sqrt(), dist2();
366			double d;
367	greg	1.4	FVECT v1;
368	greg	1.1	VIEW nv;
369			register int i;
370
371			VCOPY(nv.vup, ourview.vup);
372	greg	1.9	nv.hoff = ourview.hoff; nv.voff = ourview.voff;
373	greg	1.1	spinvector(nv.vdir, ourview.vdir, ourview.vup, angle*(PI/180.));
374	greg	1.4	if (elev != 0.0) {
375	greg	1.5	fcross(v1, ourview.vup, nv.vdir);
376	greg	1.4	normalize(v1);
377			spinvector(nv.vdir, nv.vdir, v1, elev*(PI/180.));
378			}
379	greg	1.1	if ((nv.type = ourview.type) == VT_PAR) {
380			nv.horiz = ourview.horiz / mag;
381			nv.vert = ourview.vert / mag;
382	greg	1.3	d = 0.0; /* don't move closer */
383	greg	1.2	for (i = 0; i < 3; i++)
384	greg	1.3	d += (vc[i] - ourview.vp[i])*ourview.vdir[i];
385	greg	1.1	} else {
386			nv.horiz = ourview.horiz;
387			nv.vert = ourview.vert;
388	greg	1.2	d = sqrt(dist2(ourview.vp, vc)) / mag;
389	greg	1.1	}
390	greg	1.2	for (i = 0; i < 3; i++)
391			nv.vp[i] = vc[i] - d*nv.vdir[i];
392	greg	1.1	newview(&nv);
393			}
394
395
396			spinvector(vres, vorig, vnorm, theta) /* rotate vector around normal */
397			FVECT vres, vorig, vnorm;
398			double theta;
399			{
400			extern double sin(), cos();
401			double sint, cost, dotp;
402			FVECT vperp;
403			register int i;
404
405			if (theta == 0.0) {
406			VCOPY(vres, vorig);
407			return;
408			}
409			sint = sin(theta);
410			cost = cos(theta);
411			dotp = DOT(vorig, vnorm);
412			fcross(vperp, vnorm, vorig);
413			for (i = 0; i < 3; i++)
414			vres[i] = vnorm[i]dotp(1.-cost) +
415			vorig[i]cost + vperp[i]sint;
416			}