ViewVC Help

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

root/Development/ray/src/hd/holo.c

Comparing ray/src/hd/holo.c (file contents):
Revision 3.3 by gregl, Thu Nov 6 16:37:45 1997 UTC vs.
Revision 3.14 by gwlarson, Mon Aug 31 15:40:13 1998 UTC

#	Line 14 | Line 14 | static char SCCSid[] = "$SunId$ SGI";
14
15		float   hd_depthmap[DCINF-DCLIN];
16
17	+	int     hdwg0[6] = {1,1,2,2,0,0};
18	+	int     hdwg1[6] = {2,2,0,0,1,1};
19	+
20		static double   logstep;
21
19	–	static int      wg0[6] = {1,1,2,2,0,0};
20	–	static int      wg1[6] = {2,2,0,0,1,1};
22
22	–
23		hdcompgrid(hp)                  /* compute derived grid vector and index */
24		register HOLO   *hp;
25		{
26	–	FVECT   AxB;
26		double  d;
28	–	register FLOAT  *v;
27		register int    i, j;
28		/* initialize depth map */
29		if (hd_depthmap[0] < 1.) {
#	Line 38 | Line 36 | register HOLO  *hp;
36		}
37		/* compute grid coordinate vectors */
38		for (i = 0; i < 3; i++) {
39	<	fcross(AxB, hp->xv[(i+1)%3], v=hp->xv[(i+2)%3]);
40	<	VCOPY(hp->wn[i], AxB);
41	<	if (normalize(hp->wn[i]) == 0.)
39	>	fcross(hp->wg[i], hp->xv[(i+1)%3], hp->xv[(i+2)%3]);
40	>	d = DOT(hp->wg[i],hp->xv[i]);
41	>	if (d <= FTINY & d >= -FTINY)
42		error(USER, "degenerate holodeck section");
43	<	hp->wo[i<<1] = DOT(hp->wn[i],hp->orig);
44	<	hp->wo[i<<1|1] = hp->wo[i<<1] + DOT(hp->wn[i],hp->xv[i]);
45	<	fcross(hp->gv[i][0], v, AxB);
46	<	d = DOT(v,v) / DOT(hp->gv[i][0],hp->gv[i][0]) *
47	<	hp->grid[(i+1)%3];
50	<	for (j = 0; j < 3; j++)
51	<	hp->gv[i][0][j] *= d;
52	<	fcross(hp->gv[i][1], AxB, v=hp->xv[(i+1)%3]);
53	<	d = DOT(v,v) / DOT(hp->gv[i][1],hp->gv[i][1]) *
54	<	hp->grid[(i+2)%3];
55	<	for (j = 0; j < 3; j++)
56	<	hp->gv[i][1][j] *= d;
43	>	d = (double)hp->grid[i] / d;
44	>	hp->wg[i][0] *= d; hp->wg[i][1] *= d; hp->wg[i][2] *= d;
45	>	hp->wo[i<<1] = DOT(hp->wg[i],hp->orig);
46	>	d = DOT(hp->wg[i],hp->xv[i]);
47	>	hp->wo[i<<1|1] = hp->wo[i<<1] + d;
48		}
49		/* compute linear depth range */
50		hp->tlin = VLEN(hp->xv[0]) + VLEN(hp->xv[1]) + VLEN(hp->xv[2]);
#	Line 62 | Line 53 | register HOLO  *hp;
53		for (i = 1; i < 6; i++) {
54		hp->wi[i] = 0;
55		for (j = i; j < 6; j++)
56	<	hp->wi[i] += hp->grid[wg0[j]] * hp->grid[wg1[j]];
57	<	hp->wi[i] *= hp->grid[wg0[i-1]] * hp->grid[wg1[i-1]];
56	>	hp->wi[i] += hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
57	>	hp->wi[i] *= hp->grid[hdwg0[i-1]] * hp->grid[hdwg1[i-1]];
58		hp->wi[i] += hp->wi[i-1];
59		}
60		}
#	Line 121 | Line 112 | register int   i;
112		break;
113		i -= hp->wi[gc[0].w=j];
114		/* find w1 */
115	<	n2 = hp->grid[wg0[j]] * hp->grid[wg1[j]];
115	>	n2 = hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
116		while (++j < 5) {
117	<	n = n2 * hp->grid[wg0[j]] * hp->grid[wg1[j]];
117	>	n = n2 * hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
118		if (n > i)
119		break;
120		i -= n;
121		}
122		gc[1].w = j;
123		/* find position on w0 */
124	<	n2 = hp->grid[wg0[j]] * hp->grid[wg1[j]];
124	>	n2 = hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
125		n = i / n2;
126	<	gc[0].i[1] = n / hp->grid[wg0[gc[0].w]];
127	<	gc[0].i[0] = n - gc[0].i[1]*hp->grid[wg0[gc[0].w]];
126	>	gc[0].i[1] = n / hp->grid[hdwg0[gc[0].w]];
127	>	gc[0].i[0] = n - gc[0].i[1]*hp->grid[hdwg0[gc[0].w]];
128		i -= n*n2;
129		/* find position on w1 */
130	<	gc[1].i[1] = i / hp->grid[wg0[gc[1].w]];
131	<	gc[1].i[0] = i - gc[1].i[1]*hp->grid[wg0[gc[1].w]];
130	>	gc[1].i[1] = i / hp->grid[hdwg0[gc[1].w]];
131	>	gc[1].i[0] = i - gc[1].i[1]*hp->grid[hdwg0[gc[1].w]];
132		if (reverse) {
133		copystruct(g2, gc+1);
134		copystruct(gc+1, gc);
#	Line 166 | Line 157 | register GCOORD        gc[2];
157		return(0);
158		i = 0;                          /* compute index */
159		for (j = gc[0].w+1; j < gc[1].w; j++)
160	<	i += hp->grid[wg0[j]] * hp->grid[wg1[j]];
161	<	i *= hp->grid[wg0[gc[0].w]] * hp->grid[wg1[gc[0].w]];
160	>	i += hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
161	>	i *= hp->grid[hdwg0[gc[0].w]] * hp->grid[hdwg1[gc[0].w]];
162		i += hp->wi[gc[0].w];
163	<	i += (hp->grid[wg0[gc[0].w]]*gc[0].i[1] + gc[0].i[0]) *
164	<	hp->grid[wg0[gc[1].w]] * hp->grid[wg1[gc[1].w]] ;
165	<	i += hp->grid[wg0[gc[1].w]]*gc[1].i[1] + gc[1].i[0];
163	>	i += (hp->grid[hdwg0[gc[0].w]]*gc[0].i[1] + gc[0].i[0]) *
164	>	hp->grid[hdwg0[gc[1].w]] * hp->grid[hdwg1[gc[1].w]] ;
165	>	i += hp->grid[hdwg0[gc[1].w]]*gc[1].i[1] + gc[1].i[0];
166		if (reverse)
167		i += hp->wi[5] - 1;
168		return(i);
169		}
170
171
172	<	hdlseg(lseg, hp, i)                     /* compute line segment for beam */
172	>	hdcell(cp, hp, gc)              /* compute cell coordinates */
173	>	register FVECT  cp[4];  /* returned (may be passed as FVECT cp[2][2]) */
174	>	register HOLO   *hp;
175	>	register GCOORD *gc;
176	>	{
177	>	register FLOAT  *v;
178	>	double  d;
179	>	/* compute common component */
180	>	VCOPY(cp[0], hp->orig);
181	>	if (gc->w & 1) {
182	>	v = hp->xv[gc->w>>1];
183	>	cp[0][0] += v[0]; cp[0][1] += v[1]; cp[0][2] += v[2];
184	>	}
185	>	v = hp->xv[hdwg0[gc->w]];
186	>	d = (double)gc->i[0] / hp->grid[hdwg0[gc->w]];
187	>	VSUM(cp[0], cp[0], v, d);
188	>	v = hp->xv[hdwg1[gc->w]];
189	>	d = (double)gc->i[1] / hp->grid[hdwg1[gc->w]];
190	>	VSUM(cp[0], cp[0], v, d);
191	>	/* compute x1 sums */
192	>	v = hp->xv[hdwg0[gc->w]];
193	>	d = 1.0 / hp->grid[hdwg0[gc->w]];
194	>	VSUM(cp[1], cp[0], v, d);
195	>	VSUM(cp[3], cp[0], v, d);
196	>	/* compute y1 sums */
197	>	v = hp->xv[hdwg1[gc->w]];
198	>	d = 1.0 / hp->grid[hdwg1[gc->w]];
199	>	VSUM(cp[2], cp[0], v, d);
200	>	VSUM(cp[3], cp[3], v, d);
201	>	}
202	>
203	>
204	>	hdlseg(lseg, hp, gc)                    /* compute line segment for beam */
205		register int    lseg[2][3];
206		register HOLO   *hp;
207	<	int     i;
207	>	GCOORD  gc[2];
208		{
186	–	GCOORD  gc[2];
209		register int    k;
210
189	–	if (!hdbcoord(gc, hp, i))               /* compute grid coordinates */
190	–	return(0);
211		for (k = 0; k < 2; k++) {               /* compute end points */
212		lseg[k][gc[k].w>>1] = gc[k].w&1 ? hp->grid[gc[k].w>>1]-1 : 0 ;
213	<	lseg[k][wg0[gc[k].w]] = gc[k].i[0];
214	<	lseg[k][wg1[gc[k].w]] = gc[k].i[1];
213	>	lseg[k][hdwg0[gc[k].w]] = gc[k].i[0];
214	>	lseg[k][hdwg1[gc[k].w]] = gc[k].i[1];
215		}
216		return(1);
217		}
#	Line 203 | Line 223 | HOLO   *hp;
223		double  d;
224		{
225		double  tl = hp->tlin;
226	<	register unsigned       c;
226	>	register long   c;
227
228		if (d <= 0.)
229		return(0);
#	Line 211 | Line 231 | double d;
231		return(DCINF);
232		if (d < tl)
233		return((unsigned)(d*DCLIN/tl));
234	<	c = (unsigned)(log(d/tl)/logstep) + DCLIN;
235	<	return(c > DCINF ? DCINF : c);
234	>	c = (long)(log(d/tl)/logstep) + DCLIN;
235	>	return(c > DCINF ? (unsigned)DCINF : (unsigned)c);
236		}
237
238
239	+	hdgrid(gp, hp, wp)              /* compute grid coordinates */
240	+	FVECT   gp;             /* returned */
241	+	register HOLO   *hp;
242	+	FVECT   wp;
243	+	{
244	+	FVECT   vt;
245	+
246	+	VSUB(vt, wp, hp->orig);
247	+	gp[0] = DOT(vt, hp->wg[0]);
248	+	gp[1] = DOT(vt, hp->wg[1]);
249	+	gp[2] = DOT(vt, hp->wg[2]);
250	+	}
251	+
252	+
253	+	hdworld(wp, hp, gp)             /* compute world coordinates */
254	+	register FVECT  wp;
255	+	register HOLO   *hp;
256	+	FVECT   gp;
257	+	{
258	+	register double d;
259	+
260	+	d = gp[0]/hp->grid[0];
261	+	VSUM(wp, hp->orig, hp->xv[0], d);
262	+
263	+	d = gp[1]/hp->grid[1];
264	+	VSUM(wp, wp, hp->xv[1], d);
265	+
266	+	d = gp[2]/hp->grid[2];
267	+	VSUM(wp, wp, hp->xv[2], d);
268	+	}
269	+
270	+
271		double
272		hdray(ro, rd, hp, gc, r)        /* compute ray within a beam */
273		FVECT   ro, rd;         /* returned */
274	<	register HOLO   *hp;
275	<	register GCOORD gc[2];
274	>	HOLO    *hp;
275	>	GCOORD  gc[2];
276		BYTE    r[2][2];
277		{
278	<	FVECT   p[2];
279	<	register int    i;
280	<	register FLOAT  *v;
229	<	double  d;
278	>	FVECT   cp[4], p[2];
279	>	register int    i, j;
280	>	double  d0, d1;
281		/* compute entry and exit points */
282		for (i = 0; i < 2; i++) {
283	<	VCOPY(p[i], hp->orig);
284	<	if (gc[i].w & 1) {
285	<	v = hp->xv[gc[i].w>>1];
286	<	p[i][0] += *v++; p[i][1] += *v++; p[i][2] += *v;
287	<	}
288	<	d = ( gc[i].i[0] + (1./256.)*(r[i][0]+.5) ) /
238	<	hp->grid[wg0[gc[i].w]];
239	<	v = hp->xv[wg0[gc[i].w]];
240	<	p[i][0] += d * *v++; p[i][1] += d * *v++; p[i][2] += d * *v;
241	<	d = (gc[i].i[1] + (1./256.)*(r[i][1]+.5)) /
242	<	hp->grid[wg1[gc[i].w]];
243	<	v = hp->xv[wg1[gc[i].w]];
244	<	p[i][0] += d * *v++; p[i][1] += d * *v++; p[i][2] += d * *v;
283	>	hdcell(cp, hp, gc+i);
284	>	d0 = (1./256.)*(r[i][0]+.5);
285	>	d1 = (1./256.)*(r[i][1]+.5);
286	>	for (j = 0; j < 3; j++)
287	>	p[i][j] = (1.-d0-d1)*cp[0][j] +
288	>	d0*cp[1][j] + d1*cp[2][j];
289		}
290		VCOPY(ro, p[0]);                /* assign ray origin and direction */
291	<	rd[0] = p[1][0] - p[0][0];
248	<	rd[1] = p[1][1] - p[0][1];
249	<	rd[2] = p[1][2] - p[0][2];
291	>	VSUB(rd, p[1], p[0]);
292		return(normalize(rd));          /* return maximum inside distance */
293		}
294
295
296		double
297	<	hdinter(gc, r, hp, ro, rd)      /* compute ray intersection with section */
297	>	hdinter(gc, r, ed, hp, ro, rd)  /* compute ray intersection with section */
298		register GCOORD gc[2];  /* returned */
299	<	BYTE    r[2][2];        /* returned */
299	>	BYTE    r[2][2];        /* returned (optional) */
300	>	double  *ed;            /* returned (optional) */
301		register HOLO   *hp;
302	<	FVECT   ro, rd;         /* rd should be normalized */
302	>	FVECT   ro, rd;         /* normalization of rd affects distances */
303		{
304		FVECT   p[2], vt;
305		double  d, t0, t1, d0, d1;
#	Line 266 | Line 309 | FVECT  ro, rd;         /* rd should be normalized */
309		gc[0].w = gc[1].w = -1;
310		t0 = -FHUGE; t1 = FHUGE;
311		for (i = 0; i < 3; i++) {               /* for each wall pair */
312	<	d = -DOT(rd, hp->wn[i]);        /* plane distance */
312	>	d = -DOT(rd, hp->wg[i]);        /* plane distance */
313		if (d <= FTINY && d >= -FTINY)  /* check for parallel */
314		continue;
315	<	d1 = DOT(ro, hp->wn[i]);        /* ray distances */
315	>	d1 = DOT(ro, hp->wg[i]);        /* ray distances */
316		d0 = (d1 - hp->wo[i<<1]) / d;
317		d1 = (d1 - hp->wo[i<<1|1]) / d;
318		if (d0 < d1) {          /* check against best */
#	Line 295 | Line 338 | FVECT  ro, rd;         /* rd should be normalized */
338		if (gc[0].w < 0 | gc[1].w < 0)          /* paranoid check */
339		return(FHUGE);
340		/* compute intersections */
341	<	for (i = 0; i < 3; i++) {
342	<	p[0][i] = ro[i] + rd[i]*t0;
300	<	p[1][i] = ro[i] + rd[i]*t1;
301	<	}
341	>	VSUM(p[0], ro, rd, t0);
342	>	VSUM(p[1], ro, rd, t1);
343		/* now, compute grid coordinates */
344		for (i = 0; i < 2; i++) {
345	<	vt[0] = p[i][0] - hp->orig[0];
346	<	vt[1] = p[i][1] - hp->orig[1];
306	<	vt[2] = p[i][2] - hp->orig[2];
307	<	if (gc[i].w & 1) {
308	<	v = hp->xv[gc[i].w>>1];
309	<	vt[0] -= *v++; vt[1] -= *v++; vt[2] -= *v;
310	<	}
311	<	v = hp->gv[gc[i].w>>1][0];
345	>	VSUB(vt, p[i], hp->orig);
346	>	v = hp->wg[hdwg0[gc[i].w]];
347		d = DOT(vt, v);
348	<	if (d < 0. || (gc[i].i[0] = d) >= hp->grid[wg0[gc[i].w]])
348	>	if (d < 0. || (gc[i].i[0] = d) >= hp->grid[hdwg0[gc[i].w]])
349		return(FHUGE);          /* outside wall */
350	<	r[i][0] = 256. * (d - gc[i].i[0]);
351	<	v = hp->gv[gc[i].w>>1][1];
350	>	if (r != NULL)
351	>	r[i][0] = 256. * (d - gc[i].i[0]);
352	>	v = hp->wg[hdwg1[gc[i].w]];
353		d = DOT(vt, v);
354	<	if (d < 0. || (gc[i].i[1] = d) >= hp->grid[wg1[gc[i].w]])
354	>	if (d < 0. || (gc[i].i[1] = d) >= hp->grid[hdwg1[gc[i].w]])
355		return(FHUGE);          /* outside wall */
356	<	r[i][1] = 256. * (d - gc[i].i[1]);
356	>	if (r != NULL)
357	>	r[i][1] = 256. * (d - gc[i].i[1]);
358		}
359	<	/* return distance from entry point */
360	<	vt[0] = ro[0] - p[0][0];
361	<	vt[1] = ro[1] - p[0][1];
325	<	vt[2] = ro[2] - p[0][2];
326	<	return(DOT(vt,rd));
359	>	if (ed != NULL)                 /* assign distance to exit point */
360	>	*ed = t1;
361	>	return(t0);                     /* return distance to entry point */
362		}

Diff Legend

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