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.10 by gregl, Thu Dec 18 09:33:12 1997 UTC

#	Line 23 | Line 23 | static int     wg1[6] = {2,2,0,0,1,1};
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]);
42	<	VCOPY(hp->wn[i], AxB);
39	>	fcross(hp->wn[i], hp->xv[(i+1)%3], hp->xv[(i+2)%3]);
40		if (normalize(hp->wn[i]) == 0.)
41		error(USER, "degenerate holodeck section");
42		hp->wo[i<<1] = DOT(hp->wn[i],hp->orig);
43	<	hp->wo[i<<1|1] = hp->wo[i<<1] + DOT(hp->wn[i],hp->xv[i]);
44	<	fcross(hp->gv[i][0], v, AxB);
45	<	d = DOT(v,v) / DOT(hp->gv[i][0],hp->gv[i][0]) *
49	<	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 = DOT(hp->wn[i],hp->xv[i]);
44	>	hp->wo[i<<1|1] = hp->wo[i<<1] + d;
45	>	hp->wg[i] = (double)hp->grid[i] / d;
46		}
47		/* compute linear depth range */
48		hp->tlin = VLEN(hp->xv[0]) + VLEN(hp->xv[1]) + VLEN(hp->xv[2]);
#	Line 178 | Line 167 | register GCOORD        gc[2];
167		}
168
169
170	<	hdlseg(lseg, hp, i)                     /* compute line segment for beam */
170	>	hdcell(cp, hp, gc)              /* compute cell coordinates */
171	>	register FVECT  cp[4];  /* returned (may be passed as FVECT cp[2][2]) */
172	>	register HOLO   *hp;
173	>	register GCOORD *gc;
174	>	{
175	>	register FLOAT  *v;
176	>	double  d;
177	>	/* compute common component */
178	>	VCOPY(cp[0], hp->orig);
179	>	if (gc->w & 1) {
180	>	v = hp->xv[gc->w>>1];
181	>	cp[0][0] += v[0]; cp[0][1] += v[1]; cp[0][2] += v[2];
182	>	}
183	>	v = hp->xv[wg0[gc->w]];
184	>	d = (double)gc->i[0] / hp->grid[wg0[gc->w]];
185	>	VSUM(cp[0], cp[0], v, d);
186	>	v = hp->xv[wg1[gc->w]];
187	>	d = (double)gc->i[1] / hp->grid[wg1[gc->w]];
188	>	VSUM(cp[0], cp[0], v, d);
189	>	/* compute x1 sums */
190	>	v = hp->xv[wg0[gc->w]];
191	>	d = 1.0 / hp->grid[wg0[gc->w]];
192	>	VSUM(cp[1], cp[0], v, d);
193	>	VSUM(cp[3], cp[0], v, d);
194	>	/* compute y1 sums */
195	>	v = hp->xv[wg1[gc->w]];
196	>	d = 1.0 / hp->grid[wg1[gc->w]];
197	>	VSUM(cp[2], cp[0], v, d);
198	>	VSUM(cp[3], cp[3], v, d);
199	>	}
200	>
201	>
202	>	hdlseg(lseg, hp, gc)                    /* compute line segment for beam */
203		register int    lseg[2][3];
204		register HOLO   *hp;
205	<	int     i;
205	>	GCOORD  gc[2];
206		{
186	–	GCOORD  gc[2];
207		register int    k;
208
189	–	if (!hdbcoord(gc, hp, i))               /* compute grid coordinates */
190	–	return(0);
209		for (k = 0; k < 2; k++) {               /* compute end points */
210		lseg[k][gc[k].w>>1] = gc[k].w&1 ? hp->grid[gc[k].w>>1]-1 : 0 ;
211		lseg[k][wg0[gc[k].w]] = gc[k].i[0];
#	Line 216 | Line 234 | double d;
234		}
235
236
237	+	hdgrid(gp, hp, wp)              /* compute grid coordinates */
238	+	FVECT   gp;             /* returned */
239	+	register HOLO   *hp;
240	+	FVECT   wp;
241	+	{
242	+	FVECT   vt;
243	+
244	+	vt[0] = wp[0] - hp->orig[0];
245	+	vt[1] = wp[1] - hp->orig[1];
246	+	vt[2] = wp[2] - hp->orig[2];
247	+	gp[0] = DOT(vt, hp->wn[0]) * hp->wg[0];
248	+	gp[1] = DOT(vt, hp->wn[1]) * hp->wg[1];
249	+	gp[2] = DOT(vt, hp->wn[2]) * 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];
#	Line 252 | Line 296 | BYTE   r[2][2];
296
297
298		double
299	<	hdinter(gc, r, hp, ro, rd)      /* compute ray intersection with section */
299	>	hdinter(gc, r, ed, hp, ro, rd)  /* compute ray intersection with section */
300		register GCOORD gc[2];  /* returned */
301		BYTE    r[2][2];        /* returned */
302	+	double  *ed;            /* returned (optional) */
303		register HOLO   *hp;
304		FVECT   ro, rd;         /* rd should be normalized */
305		{
#	Line 304 | Line 349 | FVECT  ro, rd;         /* rd should be normalized */
349		vt[0] = p[i][0] - hp->orig[0];
350		vt[1] = p[i][1] - hp->orig[1];
351		vt[2] = p[i][2] - hp->orig[2];
352	<	if (gc[i].w & 1) {
353	<	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];
312	<	d = DOT(vt, v);
352	>	v = hp->wn[wg0[gc[i].w]];
353	>	d = DOT(vt, v) * hp->wg[wg0[gc[i].w]];
354		if (d < 0. || (gc[i].i[0] = d) >= hp->grid[wg0[gc[i].w]])
355		return(FHUGE);          /* outside wall */
356		r[i][0] = 256. * (d - gc[i].i[0]);
357	<	v = hp->gv[gc[i].w>>1][1];
358	<	d = DOT(vt, v);
357	>	v = hp->wn[wg1[gc[i].w]];
358	>	d = DOT(vt, v) * hp->wg[wg1[gc[i].w]];
359		if (d < 0. || (gc[i].i[1] = d) >= hp->grid[wg1[gc[i].w]])
360		return(FHUGE);          /* outside wall */
361		r[i][1] = 256. * (d - gc[i].i[1]);
362		}
363	<	/* return distance from entry point */
364	<	vt[0] = ro[0] - p[0][0];
365	<	vt[1] = ro[1] - p[0][1];
366	<	vt[2] = ro[2] - p[0][2];
326	<	return(DOT(vt,rd));
363	>
364	>	if (ed != NULL)                 /* assign distance to exit point */
365	>	*ed = t1;
366	>	return(t0);                     /* return distance to entry point */
367		}

Diff Legend

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