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.2 by gregl, Mon Nov 3 11:03:23 1997 UTC vs.
Revision 3.8 by gregl, Thu Nov 20 10:52:57 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 104 | Line 93 | HDGRID *hproto;
93
94
95		hdbcoord(gc, hp, i)             /* compute beam coordinates from index */
96	<	BCOORD  gc;             /* returned */
96	>	GCOORD  gc[2];          /* returned */
97		register HOLO   *hp;
98		register int    i;
99		{
100		register int    j, n;
101		int     n2, reverse;
102	<	BCOORD  g2;
102	>	GCOORD  g2[2];
103		/* check range */
104		if (i < 1 | i > nbeams(hp))
105		return(0);
#	Line 150 | Line 139 | register int   i;
139		int
140		hdbindex(hp, gc)                /* compute index from beam coordinates */
141		register HOLO   *hp;
142	<	register BCOORD gc;
142	>	register GCOORD gc[2];
143		{
144	<	BCOORD  g2;
144	>	GCOORD  g2[2];
145		int     reverse;
146		register int    i, j;
147		/* check ordering and limits */
#	Line 178 | Line 167 | register BCOORD        gc;
167		}
168
169
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, i)                     /* compute line segment for beam */
203		register int    lseg[2][3];
204		register HOLO   *hp;
205		int     i;
206		{
207	<	BCOORD  gc;
207	>	GCOORD  gc[2];
208		register int    k;
209
210		if (!hdbcoord(gc, hp, i))               /* compute grid coordinates */
#	Line 216 | Line 237 | double d;
237		}
238
239
240	+	hdgrid(gp, hp, wp)              /* compute grid coordinates */
241	+	FVECT   gp;             /* returned */
242	+	register HOLO   *hp;
243	+	FVECT   wp;
244	+	{
245	+	FVECT   vt;
246	+
247	+	vt[0] = wp[0] - hp->orig[0];
248	+	vt[1] = wp[1] - hp->orig[1];
249	+	vt[2] = wp[2] - hp->orig[2];
250	+	gp[0] = DOT(vt, hp->wn[0]) * hp->wg[0];
251	+	gp[1] = DOT(vt, hp->wn[1]) * hp->wg[1];
252	+	gp[2] = DOT(vt, hp->wn[2]) * hp->wg[2];
253	+	}
254	+
255	+
256	+	hdworld(wp, hp, gp)             /* compute world coordinates */
257	+	register FVECT  wp;
258	+	register HOLO   *hp;
259	+	FVECT   gp;
260	+	{
261	+	register double d;
262	+
263	+	d = gp[0]/hp->grid[0];
264	+	VSUM(wp, hp->orig, hp->xv[0], d);
265	+
266	+	d = gp[1]/hp->grid[1];
267	+	VSUM(wp, wp, hp->xv[1], d);
268	+
269	+	d = gp[2]/hp->grid[2];
270	+	VSUM(wp, wp, hp->xv[2], d);
271	+	}
272	+
273	+
274		double
275		hdray(ro, rd, hp, gc, r)        /* compute ray within a beam */
276		FVECT   ro, rd;         /* returned */
277	<	register HOLO   *hp;
278	<	register BCOORD gc;
277	>	HOLO    *hp;
278	>	GCOORD  gc[2];
279		BYTE    r[2][2];
280		{
281	<	FVECT   p[2];
282	<	register int    i;
283	<	register FLOAT  *v;
229	<	double  d;
281	>	FVECT   cp[4], p[2];
282	>	register int    i, j;
283	>	double  d0, d1;
284		/* compute entry and exit points */
285		for (i = 0; i < 2; i++) {
286	<	VCOPY(p[i], hp->orig);
287	<	if (gc[i].w & 1) {
288	<	v = hp->xv[gc[i].w>>1];
289	<	p[i][0] += *v++; p[i][1] += *v++; p[i][2] += *v;
290	<	}
291	<	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;
286	>	hdcell(cp, hp, gc+i);
287	>	d0 = (1./256.)*(r[i][0]+.5);
288	>	d1 = (1./256.)*(r[i][1]+.5);
289	>	for (j = 0; j < 3; j++)
290	>	p[i][j] = (1.-d0-d1)*cp[0][j] +
291	>	d0*cp[1][j] + d1*cp[2][j];
292		}
293		VCOPY(ro, p[0]);                /* assign ray origin and direction */
294		rd[0] = p[1][0] - p[0][0];
#	Line 253 | Line 300 | BYTE   r[2][2];
300
301		double
302		hdinter(gc, r, hp, ro, rd)      /* compute ray intersection with section */
303	<	register BCOORD gc;     /* returned */
303	>	register GCOORD gc[2];  /* returned */
304		BYTE    r[2][2];        /* returned */
305		register HOLO   *hp;
306		FVECT   ro, rd;         /* rd should be normalized */
#	Line 304 | Line 351 | FVECT  ro, rd;         /* rd should be normalized */
351		vt[0] = p[i][0] - hp->orig[0];
352		vt[1] = p[i][1] - hp->orig[1];
353		vt[2] = p[i][2] - hp->orig[2];
354	<	if (gc[i].w & 1) {
355	<	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);
354	>	v = hp->wn[wg0[gc[i].w]];
355	>	d = DOT(vt, v) * hp->wg[wg0[gc[i].w]];
356		if (d < 0. || (gc[i].i[0] = d) >= hp->grid[wg0[gc[i].w]])
357		return(FHUGE);          /* outside wall */
358		r[i][0] = 256. * (d - gc[i].i[0]);
359	<	v = hp->gv[gc[i].w>>1][1];
360	<	d = DOT(vt, v);
359	>	v = hp->wn[wg1[gc[i].w]];
360	>	d = DOT(vt, v) * hp->wg[wg1[gc[i].w]];
361		if (d < 0. || (gc[i].i[1] = d) >= hp->grid[wg1[gc[i].w]])
362		return(FHUGE);          /* outside wall */
363		r[i][1] = 256. * (d - gc[i].i[1]);

Diff Legend

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