ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/holo.c
Revision: 3.15
Committed: Thu Dec 3 15:18:39 1998 UTC (25 years, 4 months ago) by gwlarson
Content type: text/plain
Branch: MAIN
Changes since 3.14: +11 -11 lines
Log Message:
got rid of unnecessary constants in HOLO struct

File Contents

# Content
1 /* Copyright (c) 1998 Silicon Graphics, Inc. */
2
3 #ifndef lint
4 static char SCCSid[] = "$SunId$ SGI";
5 #endif
6
7 /*
8 * Routines for converting holodeck coordinates, etc.
9 *
10 * 10/22/97 GWLarson
11 */
12
13 #include "holo.h"
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
22
23 hdcompgrid(hp) /* compute derived grid vector and index */
24 register HOLO *hp;
25 {
26 double d;
27 register int i, j;
28 /* initialize depth map */
29 if (hd_depthmap[0] < 1.) {
30 d = 1. + .5/DCLIN;
31 for (i = 0; i < DCINF-DCLIN; i++) {
32 hd_depthmap[i] = d;
33 d *= 1. + 1./DCLIN;
34 }
35 logstep = log(1. + 1./DCLIN);
36 }
37 /* compute grid coordinate vectors */
38 for (i = 0; i < 3; i++) {
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 d = hp->grid[i] / d;
44 hp->wg[i][0] *= d; hp->wg[i][1] *= d; hp->wg[i][2] *= d;
45 }
46 /* compute linear depth range */
47 hp->tlin = VLEN(hp->xv[0]) + VLEN(hp->xv[1]) + VLEN(hp->xv[2]);
48 /* compute wall super-indices from grid */
49 hp->wi[0] = 1; /**** index values begin at 1 ****/
50 for (i = 1; i < 6; i++) {
51 hp->wi[i] = 0;
52 for (j = i; j < 6; j++)
53 hp->wi[i] += hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
54 hp->wi[i] *= hp->grid[hdwg0[i-1]] * hp->grid[hdwg1[i-1]];
55 hp->wi[i] += hp->wi[i-1];
56 }
57 }
58
59
60 HOLO *
61 hdalloc(hproto) /* allocate and set holodeck section based on grid */
62 HDGRID *hproto;
63 {
64 HOLO hdhead;
65 register HOLO *hp;
66 int n;
67 /* copy grid to temporary header */
68 bcopy((char *)hproto, (char *)&hdhead, sizeof(HDGRID));
69 /* compute grid vectors and sizes */
70 hdcompgrid(&hdhead);
71 /* allocate header with directory */
72 n = sizeof(HOLO)+nbeams(&hdhead)*sizeof(BEAMI);
73 if ((hp = (HOLO *)malloc(n)) == NULL)
74 return(NULL);
75 /* copy header information */
76 copystruct(hp, &hdhead);
77 /* allocate and clear beam list */
78 hp->bl = (BEAM **)malloc((nbeams(hp)+1)*sizeof(BEAM *)+sizeof(BEAM));
79 if (hp->bl == NULL) {
80 free((char *)hp);
81 return(NULL);
82 }
83 bzero((char *)hp->bl, (nbeams(hp)+1)*sizeof(BEAM *)+sizeof(BEAM));
84 hp->bl[0] = (BEAM *)(hp->bl+nbeams(hp)+1); /* set blglob(hp) */
85 hp->fd = -1;
86 hp->dirty = 0;
87 hp->priv = NULL;
88 /* clear beam directory */
89 bzero((char *)hp->bi, (nbeams(hp)+1)*sizeof(BEAMI));
90 return(hp); /* all is well */
91 }
92
93
94 hdbcoord(gc, hp, i) /* compute beam coordinates from index */
95 GCOORD gc[2]; /* returned */
96 register HOLO *hp;
97 register int i;
98 {
99 register int j, n;
100 int n2, reverse;
101 GCOORD g2[2];
102 /* check range */
103 if (i < 1 | i > nbeams(hp))
104 return(0);
105 if (reverse = i >= hp->wi[5])
106 i -= hp->wi[5] - 1;
107 for (j = 0; j < 5; j++) /* find w0 */
108 if (hp->wi[j+1] > i)
109 break;
110 i -= hp->wi[gc[0].w=j];
111 /* find w1 */
112 n2 = hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
113 while (++j < 5) {
114 n = n2 * hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
115 if (n > i)
116 break;
117 i -= n;
118 }
119 gc[1].w = j;
120 /* find position on w0 */
121 n2 = hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
122 n = i / n2;
123 gc[0].i[1] = n / hp->grid[hdwg0[gc[0].w]];
124 gc[0].i[0] = n - gc[0].i[1]*hp->grid[hdwg0[gc[0].w]];
125 i -= n*n2;
126 /* find position on w1 */
127 gc[1].i[1] = i / hp->grid[hdwg0[gc[1].w]];
128 gc[1].i[0] = i - gc[1].i[1]*hp->grid[hdwg0[gc[1].w]];
129 if (reverse) {
130 copystruct(g2, gc+1);
131 copystruct(gc+1, gc);
132 copystruct(gc, g2);
133 }
134 return(1); /* we're done */
135 }
136
137
138 int
139 hdbindex(hp, gc) /* compute index from beam coordinates */
140 register HOLO *hp;
141 register GCOORD gc[2];
142 {
143 GCOORD g2[2];
144 int reverse;
145 register int i, j;
146 /* check ordering and limits */
147 if (reverse = gc[0].w > gc[1].w) {
148 copystruct(g2, gc+1);
149 copystruct(g2+1, gc);
150 gc = g2;
151 } else if (gc[0].w == gc[1].w)
152 return(0);
153 if (gc[0].w < 0 | gc[1].w > 5)
154 return(0);
155 i = 0; /* compute index */
156 for (j = gc[0].w+1; j < gc[1].w; j++)
157 i += hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
158 i *= hp->grid[hdwg0[gc[0].w]] * hp->grid[hdwg1[gc[0].w]];
159 i += hp->wi[gc[0].w];
160 i += (hp->grid[hdwg0[gc[0].w]]*gc[0].i[1] + gc[0].i[0]) *
161 hp->grid[hdwg0[gc[1].w]] * hp->grid[hdwg1[gc[1].w]] ;
162 i += hp->grid[hdwg0[gc[1].w]]*gc[1].i[1] + gc[1].i[0];
163 if (reverse)
164 i += hp->wi[5] - 1;
165 return(i);
166 }
167
168
169 hdcell(cp, hp, gc) /* compute cell coordinates */
170 register FVECT cp[4]; /* returned (may be passed as FVECT cp[2][2]) */
171 register HOLO *hp;
172 register GCOORD *gc;
173 {
174 register FLOAT *v;
175 double d;
176 /* compute common component */
177 VCOPY(cp[0], hp->orig);
178 if (gc->w & 1) {
179 v = hp->xv[gc->w>>1];
180 cp[0][0] += v[0]; cp[0][1] += v[1]; cp[0][2] += v[2];
181 }
182 v = hp->xv[hdwg0[gc->w]];
183 d = (double)gc->i[0] / hp->grid[hdwg0[gc->w]];
184 VSUM(cp[0], cp[0], v, d);
185 v = hp->xv[hdwg1[gc->w]];
186 d = (double)gc->i[1] / hp->grid[hdwg1[gc->w]];
187 VSUM(cp[0], cp[0], v, d);
188 /* compute x1 sums */
189 v = hp->xv[hdwg0[gc->w]];
190 d = 1.0 / hp->grid[hdwg0[gc->w]];
191 VSUM(cp[1], cp[0], v, d);
192 VSUM(cp[3], cp[0], v, d);
193 /* compute y1 sums */
194 v = hp->xv[hdwg1[gc->w]];
195 d = 1.0 / hp->grid[hdwg1[gc->w]];
196 VSUM(cp[2], cp[0], v, d);
197 VSUM(cp[3], cp[3], v, d);
198 }
199
200
201 hdlseg(lseg, hp, gc) /* compute line segment for beam */
202 register int lseg[2][3];
203 register HOLO *hp;
204 GCOORD gc[2];
205 {
206 register int k;
207
208 for (k = 0; k < 2; k++) { /* compute end points */
209 lseg[k][gc[k].w>>1] = gc[k].w&1 ? hp->grid[gc[k].w>>1]-1 : 0 ;
210 lseg[k][hdwg0[gc[k].w]] = gc[k].i[0];
211 lseg[k][hdwg1[gc[k].w]] = gc[k].i[1];
212 }
213 return(1);
214 }
215
216
217 unsigned
218 hdcode(hp, d) /* compute depth code for d */
219 HOLO *hp;
220 double d;
221 {
222 double tl = hp->tlin;
223 register long c;
224
225 if (d <= 0.)
226 return(0);
227 if (d >= .99*FHUGE)
228 return(DCINF);
229 if (d < tl)
230 return((unsigned)(d*DCLIN/tl));
231 c = (long)(log(d/tl)/logstep) + DCLIN;
232 return(c > DCINF ? (unsigned)DCINF : (unsigned)c);
233 }
234
235
236 hdgrid(gp, hp, wp) /* compute grid coordinates */
237 FVECT gp; /* returned */
238 register HOLO *hp;
239 FVECT wp;
240 {
241 FVECT vt;
242
243 VSUB(vt, wp, hp->orig);
244 gp[0] = DOT(vt, hp->wg[0]);
245 gp[1] = DOT(vt, hp->wg[1]);
246 gp[2] = DOT(vt, hp->wg[2]);
247 }
248
249
250 hdworld(wp, hp, gp) /* compute world coordinates */
251 register FVECT wp;
252 register HOLO *hp;
253 FVECT gp;
254 {
255 register double d;
256
257 d = gp[0]/hp->grid[0];
258 VSUM(wp, hp->orig, hp->xv[0], d);
259
260 d = gp[1]/hp->grid[1];
261 VSUM(wp, wp, hp->xv[1], d);
262
263 d = gp[2]/hp->grid[2];
264 VSUM(wp, wp, hp->xv[2], d);
265 }
266
267
268 double
269 hdray(ro, rd, hp, gc, r) /* compute ray within a beam */
270 FVECT ro, rd; /* returned */
271 HOLO *hp;
272 GCOORD gc[2];
273 BYTE r[2][2];
274 {
275 FVECT cp[4], p[2];
276 register int i, j;
277 double d0, d1;
278 /* compute entry and exit points */
279 for (i = 0; i < 2; i++) {
280 hdcell(cp, hp, gc+i);
281 d0 = (1./256.)*(r[i][0]+.5);
282 d1 = (1./256.)*(r[i][1]+.5);
283 for (j = 0; j < 3; j++)
284 p[i][j] = (1.-d0-d1)*cp[0][j] +
285 d0*cp[1][j] + d1*cp[2][j];
286 }
287 VCOPY(ro, p[0]); /* assign ray origin and direction */
288 VSUB(rd, p[1], p[0]);
289 return(normalize(rd)); /* return maximum inside distance */
290 }
291
292
293 double
294 hdinter(gc, r, ed, hp, ro, rd) /* compute ray intersection with section */
295 register GCOORD gc[2]; /* returned */
296 BYTE r[2][2]; /* returned (optional) */
297 double *ed; /* returned (optional) */
298 register HOLO *hp;
299 FVECT ro, rd; /* normalization of rd affects distances */
300 {
301 FVECT p[2], vt;
302 double d, t0, t1, d0, d1;
303 register FLOAT *v;
304 register int i;
305 /* first, intersect walls */
306 gc[0].w = gc[1].w = -1;
307 t0 = -FHUGE; t1 = FHUGE;
308 VSUB(vt, ro, hp->orig);
309 for (i = 0; i < 3; i++) { /* for each wall pair */
310 d = -DOT(rd, hp->wg[i]); /* plane distance */
311 if (d <= FTINY && d >= -FTINY) /* check for parallel */
312 continue;
313 d1 = DOT(vt, hp->wg[i]); /* ray distances */
314 d0 = d1 / d;
315 d1 = (d1 - hp->grid[i]) / d;
316 if (d < 0) { /* check against best */
317 if (d0 > t0) {
318 t0 = d0;
319 gc[0].w = i<<1;
320 }
321 if (d1 < t1) {
322 t1 = d1;
323 gc[1].w = i<<1 | 1;
324 }
325 } else {
326 if (d1 > t0) {
327 t0 = d1;
328 gc[0].w = i<<1 | 1;
329 }
330 if (d0 < t1) {
331 t1 = d0;
332 gc[1].w = i<<1;
333 }
334 }
335 }
336 if (gc[0].w < 0 | gc[1].w < 0) /* paranoid check */
337 return(FHUGE);
338 /* compute intersections */
339 VSUM(p[0], ro, rd, t0);
340 VSUM(p[1], ro, rd, t1);
341 /* now, compute grid coordinates */
342 for (i = 0; i < 2; i++) {
343 VSUB(vt, p[i], hp->orig);
344 v = hp->wg[hdwg0[gc[i].w]];
345 d = DOT(vt, v);
346 if (d < 0 || d >= hp->grid[hdwg0[gc[i].w]])
347 return(FHUGE); /* outside wall */
348 gc[i].i[0] = d;
349 if (r != NULL)
350 r[i][0] = 256. * (d - gc[i].i[0]);
351 v = hp->wg[hdwg1[gc[i].w]];
352 d = DOT(vt, v);
353 if (d < 0 || d >= hp->grid[hdwg1[gc[i].w]])
354 return(FHUGE); /* outside wall */
355 gc[i].i[1] = d;
356 if (r != NULL)
357 r[i][1] = 256. * (d - gc[i].i[1]);
358 }
359 if (ed != NULL) /* assign distance to exit point */
360 *ed = t1;
361 return(t0); /* return distance to entry point */
362 }