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.1 by gregl, Fri Oct 31 10:23:29 1997 UTC vs.
Revision 3.2 by gregl, Mon Nov 3 11:03:23 1997 UTC

#	Line 16 | Line 16 | float  hd_depthmap[DCINF-DCLIN];
16
17		static double   logstep;
18
19	+	static int      wg0[6] = {1,1,2,2,0,0};
20	+	static int      wg1[6] = {2,2,0,0,1,1};
21
22	+
23		hdcompgrid(hp)                  /* compute derived grid vector and index */
24		register HOLO   *hp;
25		{
#	Line 59 | Line 62 | register HOLO  *hp;
62		for (i = 1; i < 6; i++) {
63		hp->wi[i] = 0;
64		for (j = i; j < 6; j++)
65	<	hp->wi[i] += hp->grid[((j>>1)+1)%3] *
66	<	hp->grid[((j>>1)+2)%3];
64	<	hp->wi[i] *= hp->grid[(((i-1)>>1)+1)%3] *
65	<	hp->grid[(((i-1)>>1)+2)%3];
65	>	hp->wi[i] += hp->grid[wg0[j]] * hp->grid[wg1[j]];
66	>	hp->wi[i] *= hp->grid[wg0[i-1]] * hp->grid[wg1[i-1]];
67		hp->wi[i] += hp->wi[i-1];
68		}
69		}
#	Line 120 | Line 121 | register int   i;
121		break;
122		i -= hp->wi[gc[0].w=j];
123		/* find w1 */
124	<	n2 = hp->grid[((j>>1)+1)%3] * hp->grid[((j>>1)+2)%3];
124	>	n2 = hp->grid[wg0[j]] * hp->grid[wg1[j]];
125		while (++j < 5) {
126	<	n = n2 * hp->grid[((j>>1)+1)%3] * hp->grid[((j>>1)+2)%3];
126	>	n = n2 * hp->grid[wg0[j]] * hp->grid[wg1[j]];
127		if (n > i)
128		break;
129		i -= n;
130		}
131		gc[1].w = j;
132		/* find position on w0 */
133	<	n2 = hp->grid[((j>>1)+1)%3] * hp->grid[((j>>1)+2)%3];
133	>	n2 = hp->grid[wg0[j]] * hp->grid[wg1[j]];
134		n = i / n2;
135	<	gc[0].i[1] = n / hp->grid[((gc[0].w>>1)+1)%3];
136	<	gc[0].i[0] = n - gc[0].i[1]*hp->grid[((gc[0].w>>1)+1)%3];
135	>	gc[0].i[1] = n / hp->grid[wg0[gc[0].w]];
136	>	gc[0].i[0] = n - gc[0].i[1]*hp->grid[wg0[gc[0].w]];
137		i -= n*n2;
138		/* find position on w1 */
139	<	gc[1].i[1] = i / hp->grid[((gc[1].w>>1)+1)%3];
140	<	gc[1].i[0] = i - gc[1].i[1]*hp->grid[((gc[1].w>>1)+1)%3];
139	>	gc[1].i[1] = i / hp->grid[wg0[gc[1].w]];
140	>	gc[1].i[0] = i - gc[1].i[1]*hp->grid[wg0[gc[1].w]];
141		if (reverse) {
142		copystruct(g2, gc+1);
143		copystruct(gc+1, gc);
#	Line 165 | Line 166 | register BCOORD        gc;
166		return(0);
167		i = 0;                          /* compute index */
168		for (j = gc[0].w+1; j < gc[1].w; j++)
169	<	i += hp->grid[((j>>1)+1)%3] * hp->grid[((j>>1)+2)%3];
170	<	i *= hp->grid[((gc[0].w>>1)+1)%3] * hp->grid[((gc[0].w>>1)+2)%3];
169	>	i += hp->grid[wg0[j]] * hp->grid[wg1[j]];
170	>	i *= hp->grid[wg0[gc[0].w]] * hp->grid[wg1[gc[0].w]];
171		i += hp->wi[gc[0].w];
172	<	i += (hp->grid[((gc[0].w>>1)+1)%3]*gc[0].i[1] + gc[0].i[0]) *
173	<	hp->grid[((gc[1].w>>1)+1)%3] *
174	<	hp->grid[((gc[1].w>>1)+2)%3] ;
174	<	i += hp->grid[((gc[1].w>>1)+1)%3]*gc[1].i[1] + gc[1].i[0];
172	>	i += (hp->grid[wg0[gc[0].w]]*gc[0].i[1] + gc[0].i[0]) *
173	>	hp->grid[wg0[gc[1].w]] * hp->grid[wg1[gc[1].w]] ;
174	>	i += hp->grid[wg0[gc[1].w]]*gc[1].i[1] + gc[1].i[0];
175		if (reverse)
176		i += hp->wi[5] - 1;
177		return(i);
#	Line 179 | Line 179 | register BCOORD        gc;
179
180
181		hdlseg(lseg, hp, i)                     /* compute line segment for beam */
182	<	int     lseg[2][3];
182	>	register int    lseg[2][3];
183		register HOLO   *hp;
184		int     i;
185		{
186		BCOORD  gc;
187		register int    k;
188
189	<	if (!hdbcoord(gc, hp, i))
189	>	if (!hdbcoord(gc, hp, i))               /* compute grid coordinates */
190		return(0);
191	<	for (k = 0; k < 2; k++)         /* compute line segment */
192	<	switch (gc[k].w>>1) {
193	<	case 0:
194	<	lseg[k][0] = (gc[k].w & 1) * (hp->grid[0]-1);
195	<	lseg[k][1] = gc[k].i[0];
196	<	lseg[k][2] = gc[k].i[1];
197	<	break;
198	<	case 1:
199	<	lseg[k][0] = gc[k].i[1];
200	<	lseg[k][1] = (gc[k].w & 1) * (hp->grid[1]-1);
201	<	lseg[k][2] = gc[k].i[0];
202	<	break;
203	<	case 2:
204	<	lseg[k][0] = gc[k].i[0];
205	<	lseg[k][1] = gc[k].i[1];
206	<	lseg[k][2] = (gc[k].w & 1) * (hp->grid[2]-1);
207	<	break;
208	<	}
191	>	for (k = 0; k < 2; k++) {               /* compute end points */
192	>	lseg[k][gc[k].w>>1] = gc[k].w&1 ? hp->grid[gc[k].w>>1]-1 : 0 ;
193	>	lseg[k][wg0[gc[k].w]] = gc[k].i[0];
194	>	lseg[k][wg1[gc[k].w]] = gc[k].i[1];
195	>	}
196		return(1);
197		}
198
#	Line 248 | Line 235 | BYTE   r[2][2];
235		p[i][0] += *v++; p[i][1] += *v++; p[i][2] += *v;
236		}
237		d = ( gc[i].i[0] + (1./256.)*(r[i][0]+.5) ) /
238	<	hp->grid[((gc[i].w>>1)+1)%3];
239	<	v = hp->xv[((gc[i].w>>1)+1)%3];
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[((gc[i].w>>1)+2)%3];
243	<	v = hp->xv[((gc[i].w>>1)+2)%3];
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;
245		}
246		VCOPY(ro, p[0]);                /* assign ray origin and direction */
#	Line 323 | Line 310 | FVECT  ro, rd;         /* rd should be normalized */
310		}
311		v = hp->gv[gc[i].w>>1][0];
312		d = DOT(vt, v);
313	<	if (d < 0. || (gc[i].i[0] = d) >= hp->grid[((gc[i].w>>1)+1)%3])
313	>	if (d < 0. || (gc[i].i[0] = d) >= hp->grid[wg0[gc[i].w]])
314		return(FHUGE);          /* outside wall */
315		r[i][0] = 256. * (d - gc[i].i[0]);
316		v = hp->gv[gc[i].w>>1][1];
317		d = DOT(vt, v);
318	<	if (d < 0. || (gc[i].i[1] = d) >= hp->grid[((gc[i].w>>1)+2)%3])
318	>	if (d < 0. || (gc[i].i[1] = d) >= hp->grid[wg1[gc[i].w]])
319		return(FHUGE);          /* outside wall */
320		r[i][1] = 256. * (d - gc[i].i[1]);
321		}

Diff Legend

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