ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/rt/rv3.c

Comparing ray/src/rt/rv3.c (file contents):
Revision 1.3 by greg, Wed May 24 13:55:54 1989 UTC vs.
Revision 2.2 by greg, Fri Jan 17 09:27:21 1992 UTC

#	Line 12 | Line 12 | static char SCCSid[] = "$SunId$ LBL";
12
13		#include  "ray.h"
14
15	+	#include  "octree.h"
16	+
17		#include  "rpaint.h"
18
19		#include  "random.h"
20
21	+	#ifndef WFLUSH
22	+	#define WFLUSH          30              /* flush after this many rays */
23	+	#endif
24
25	+	#ifdef  SMLFLT
26	+	#define  sscanvec(s,v)  (sscanf(s,"%f %f %f",v,v+1,v+2)==3)
27	+	#else
28	+	#define  sscanvec(s,v)  (sscanf(s,"%lf %lf %lf",v,v+1,v+2)==3)
29	+	#endif
30	+
31	+
32	+	getrect(s, r)                           /* get a box */
33	+	char  *s;
34	+	register RECT  *r;
35	+	{
36	+	int  x0, y0, x1, y1;
37	+
38	+	if (*s && !strncmp(s, "all", strlen(s))) {
39	+	r->l = r->d = 0;
40	+	r->r = hresolu;
41	+	r->u = vresolu;
42	+	return(0);
43	+	}
44	+	if (sscanf(s, "%d %d %d %d", &x0, &y0, &x1, &y1) != 4) {
45	+	if (dev->getcur == NULL)
46	+	return(-1);
47	+	(*dev->comout)("Pick first corner\n");
48	+	if ((*dev->getcur)(&x0, &y0) == ABORT)
49	+	return(-1);
50	+	(*dev->comout)("Pick second corner\n");
51	+	if ((*dev->getcur)(&x1, &y1) == ABORT)
52	+	return(-1);
53	+	}
54	+	if (x0 < x1) {
55	+	r->l = x0;
56	+	r->r = x1;
57	+	} else {
58	+	r->l = x1;
59	+	r->r = x0;
60	+	}
61	+	if (y0 < y1) {
62	+	r->d = y0;
63	+	r->u = y1;
64	+	} else {
65	+	r->d = y1;
66	+	r->u = y0;
67	+	}
68	+	if (r->l < 0) r->l = 0;
69	+	if (r->d < 0) r->d = 0;
70	+	if (r->r > hresolu) r->r = hresolu;
71	+	if (r->u > vresolu) r->u = vresolu;
72	+	if (r->l > r->r) r->l = r->r;
73	+	if (r->d > r->u) r->d = r->u;
74	+	return(0);
75	+	}
76	+
77	+
78	+	getinterest(s, direc, vec, mp)          /* get area of interest */
79	+	char  *s;
80	+	int  direc;
81	+	FVECT  vec;
82	+	double  *mp;
83	+	{
84	+	int  x, y;
85	+	RAY  thisray;
86	+	register int  i;
87	+
88	+	if (sscanf(s, "%lf", mp) != 1)
89	+	*mp = 1.0;
90	+	else if (*mp < -FTINY)          /* negative zoom is reduction */
91	+	*mp = -1.0 / *mp;
92	+	else if (*mp <= FTINY) {        /* too small */
93	+	error(COMMAND, "illegal magnification");
94	+	return(-1);
95	+	}
96	+	if (!sscanvec(sskip(s), vec)) {
97	+	if (dev->getcur == NULL)
98	+	return(-1);
99	+	(*dev->comout)("Pick view center\n");
100	+	if ((*dev->getcur)(&x, &y) == ABORT)
101	+	return(-1);
102	+	if (viewray(thisray.rorg, thisray.rdir, &ourview,
103	+	(x+.5)/hresolu, (y+.5)/vresolu) < 0) {
104	+	error(COMMAND, "not on image");
105	+	return(-1);
106	+	}
107	+	if (!direc || ourview.type == VT_PAR) {
108	+	rayorigin(&thisray, NULL, PRIMARY, 1.0);
109	+	if (!localhit(&thisray, &thescene)) {
110	+	error(COMMAND, "not a local object");
111	+	return(-1);
112	+	}
113	+	}
114	+	if (direc)
115	+	if (ourview.type == VT_PAR)
116	+	for (i = 0; i < 3; i++)
117	+	vec[i] = thisray.rop[i] - ourview.vp[i];
118	+	else
119	+	VCOPY(vec, thisray.rdir);
120	+	else
121	+	VCOPY(vec, thisray.rop);
122	+	} else if (direc)
123	+	for (i = 0; i < 3; i++)
124	+	vec[i] -= ourview.vp[i];
125	+	return(0);
126	+	}
127	+
128	+
129		float *         /* keep consistent with COLOR typedef */
130		greyof(col)                             /* convert color to greyscale */
131		register COLOR  col;
#	Line 34 | Line 143 | paint(p, xmin, ymin, xmax, ymax)       /* compute and paint
143		register PNODE  *p;
144		int  xmin, ymin, xmax, ymax;
145		{
146	+	extern long  nrays;
147	+	static long  lastflush = 0;
148		static RAY  thisray;
149		double  h, v;
39	–	register int  i;
150
151		if (xmax - xmin <= 0 || ymax - ymin <= 0) {     /* empty */
152		p->x = xmin;
#	Line 45 | Line 155 | int  xmin, ymin, xmax, ymax;
155		return;
156		}
157		/* jitter ray direction */
158	<	p->x = h = xmin + (xmax-xmin)*frandom();
159	<	p->y = v = ymin + (ymax-ymin)*frandom();
158	>	h = xmin + (xmax-xmin)*frandom();
159	>	v = ymin + (ymax-ymin)*frandom();
160
161	<	rayview(thisray.rorg, thisray.rdir, &ourview, h, v);
161	>	if (viewray(thisray.rorg, thisray.rdir, &ourview,
162	>	h/hresolu, v/vresolu) < 0) {
163	>	setcolor(thisray.rcol, 0.0, 0.0, 0.0);
164	>	} else {
165	>	rayorigin(&thisray, NULL, PRIMARY, 1.0);
166	>	samplendx++;
167	>	rayvalue(&thisray);
168	>	}
169
170	<	rayorigin(&thisray, NULL, PRIMARY, 1.0);
171	<
55	<	rayvalue(&thisray);
56	<
170	>	p->x = h;
171	>	p->y = v;
172		copycolor(p->v, thisray.rcol);
58	–
173		scalecolor(p->v, exposure);
174
175		(*dev->paintr)(greyscale?greyof(p->v):p->v, xmin, ymin, xmax, ymax);
176	+
177	+	if (dev->flush != NULL && nrays - lastflush >= WFLUSH) {
178	+	lastflush = nrays;
179	+	(*dev->flush)();
180	+	}
181		}
182
183
#	Line 66 | Line 185 | newimage()                             /* start a new image */
185		{
186		/* free old image */
187		freepkids(&ptrunk);
188	<	/* set up frame */
189	<	if (ourview.hresolu > dev->xsiz || ourview.vresolu > dev->ysiz)
190	<	error(USER, "resolution mismatch");
188	>	/* save reserve memory */
189	>	fillreserves();
190	>	/* compute resolution */
191	>	hresolu = dev->xsiz;
192	>	vresolu = dev->ysiz;
193	>	normaspect(viewaspect(&ourview), &dev->pixaspect, &hresolu, &vresolu);
194		pframe.l = pframe.d = 0;
195	<	pframe.r = ourview.hresolu; pframe.u = ourview.vresolu;
195	>	pframe.r = hresolu; pframe.u = vresolu;
196		pdepth = 0;
197		/* clear device */
198	<	(*dev->clear)(ourview.hresolu, ourview.vresolu);
198	>	(*dev->clear)(hresolu, vresolu);
199		/* get first value */
200	<	paint(&ptrunk, 0, 0, ourview.hresolu, ourview.vresolu);
200	>	paint(&ptrunk, 0, 0, hresolu, vresolu);
201		}
202
203
204		redraw()                                /* redraw the image */
205		{
206	<	(*dev->clear)(ourview.hresolu, ourview.vresolu);
206	>	(*dev->clear)(hresolu, vresolu);
207		(*dev->comout)("redrawing...\n");
208	<	repaint(0, 0, ourview.hresolu, ourview.vresolu);
208	>	repaint(0, 0, hresolu, vresolu);
209		(*dev->comout)("\n");
210		}
211
#	Line 96 | Line 218 | int  xmin, ymin, xmax, ymax;
218		reg.l = xmin; reg.r = xmax;
219		reg.d = ymin; reg.u = ymax;
220
221	<	paintrect(&ptrunk, 0, 0, ourview.hresolu, ourview.vresolu, &reg);
221	>	paintrect(&ptrunk, 0, 0, hresolu, vresolu, &reg);
222		}
223
224
#	Line 107 | Line 229 | register RECT  *r;
229		{
230		int  mx, my;
231
110	–	if (dev->inpready)
111	–	return;                         /* break for input */
112	–
232		if (xmax - xmin <= 0 || ymax - ymin <= 0)
233		return;
234
#	Line 247 | Line 366 | register VIEW  *vp;
366		{
367		char  *err;
368
369	<	if (vp->hresolu > dev->xsiz || vp->vresolu > dev->ysiz) {
251	<	error(COMMAND, "view not set - resolution mismatch");
252	<	} else if ((err = setview(vp)) != NULL) {
369	>	if ((err = setview(vp)) != NULL) {
370		sprintf(errmsg, "view not set - %s", err);
371		error(COMMAND, errmsg);
372	<	} else if (bcmp(vp, &ourview, sizeof(VIEW))) {
373	<	bcopy(&ourview, &oldview, sizeof(VIEW));
374	<	bcopy(vp, &ourview, sizeof(VIEW));
372	>	} else if (bcmp((char *)vp, (char *)&ourview, sizeof(VIEW))) {
373	>	copystruct(&oldview, &ourview);
374	>	copystruct(&ourview, vp);
375		newimage();
376		}
377		}
378
379
380	<	moveview(angle, mag, vc)                        /* move viewpoint */
381	<	double  angle, mag;
380	>	moveview(angle, elev, mag, vc)                  /* move viewpoint */
381	>	double  angle, elev, mag;
382		FVECT  vc;
383		{
384		extern double  sqrt(), dist2();
385		double  d;
386	+	FVECT  v1;
387		VIEW  nv;
388		register int  i;
389
390		VCOPY(nv.vup, ourview.vup);
391	<	nv.hresolu = ourview.hresolu; nv.vresolu = ourview.vresolu;
391	>	nv.hoff = ourview.hoff; nv.voff = ourview.voff;
392		spinvector(nv.vdir, ourview.vdir, ourview.vup, angle*(PI/180.));
393	+	if (elev != 0.0) {
394	+	fcross(v1, ourview.vup, nv.vdir);
395	+	normalize(v1);
396	+	spinvector(nv.vdir, nv.vdir, v1, elev*(PI/180.));
397	+	}
398		if ((nv.type = ourview.type) == VT_PAR) {
399		nv.horiz = ourview.horiz / mag;
400		nv.vert = ourview.vert / mag;
#	Line 289 | Line 412 | FVECT  vc;
412		}
413
414
415	<	spinvector(vres, vorig, vnorm, theta)   /* rotate vector around normal */
416	<	FVECT  vres, vorig, vnorm;
417	<	double  theta;
415	>	zoomview(vp, zf)                        /* zoom in our out */
416	>	register VIEW  *vp;
417	>	double  zf;
418		{
419	<	extern double  sin(), cos();
420	<	double  sint, cost, dotp;
421	<	FVECT  vperp;
422	<	register int  i;
423	<
301	<	if (theta == 0.0) {
302	<	VCOPY(vres, vorig);
419	>	switch (vp->type) {
420	>	case VT_PAR:                            /* parallel view */
421	>	case VT_ANG:                            /* angular fisheye */
422	>	vp->horiz /= zf;
423	>	vp->vert /= zf;
424		return;
425	+	case VT_PER:                            /* perspective view */
426	+	vp->horiz = atan(tan(vp->horiz*(PI/180./2.))/zf) /
427	+	(PI/180./2.);
428	+	vp->vert = atan(tan(vp->vert*(PI/180./2.))/zf) /
429	+	(PI/180./2.);
430	+	return;
431	+	case VT_HEM:                            /* hemispherical fisheye */
432	+	vp->horiz = sin(vp->horiz*(PI/180./2.))/zf;
433	+	if (vp->horiz >= 1.0-FTINY)
434	+	vp->horiz = 180.;
435	+	else
436	+	vp->horiz = asin(vp->horiz) / (PI/180./2.);
437	+	vp->vert = sin(vp->vert*(PI/180./2.))/zf;
438	+	if (vp->vert >= 1.0-FTINY)
439	+	vp->vert = 180.;
440	+	else
441	+	vp->vert = asin(vp->vert) / (PI/180./2.);
442	+	return;
443		}
305	–	sint = sin(theta);
306	–	cost = cos(theta);
307	–	dotp = DOT(vorig, vnorm);
308	–	fcross(vperp, vnorm, vorig);
309	–	for (i = 0; i < 3; i++)
310	–	vres[i] = vnorm[i]*dotp*(1.-cost) +
311	–	vorig[i]*cost + vperp[i]*sint;
444		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)