ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/holo.c
Revision: 3.16
Committed: Fri Mar 12 09:37:47 1999 UTC (25 years ago) by gwlarson
Content type: text/plain
Branch: MAIN
Changes since 3.15: +0 -34 lines
Log Message:
moved hdalloc() from holo.c to holofile.c

File Contents

# User Rev Content
1 gwlarson 3.15 /* Copyright (c) 1998 Silicon Graphics, Inc. */
2 gregl 3.1
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 gregl 3.13 int hdwg0[6] = {1,1,2,2,0,0};
18     int hdwg1[6] = {2,2,0,0,1,1};
19    
20 gregl 3.1 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 gregl 3.13 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 gregl 3.1 error(USER, "degenerate holodeck section");
43 gwlarson 3.15 d = hp->grid[i] / d;
44 gregl 3.13 hp->wg[i][0] *= d; hp->wg[i][1] *= d; hp->wg[i][2] *= d;
45 gregl 3.1 }
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 gregl 3.13 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 gregl 3.1 hp->wi[i] += hp->wi[i-1];
56     }
57     }
58    
59    
60     hdbcoord(gc, hp, i) /* compute beam coordinates from index */
61 gregl 3.3 GCOORD gc[2]; /* returned */
62 gregl 3.1 register HOLO *hp;
63     register int i;
64     {
65     register int j, n;
66     int n2, reverse;
67 gregl 3.3 GCOORD g2[2];
68 gregl 3.1 /* check range */
69     if (i < 1 | i > nbeams(hp))
70     return(0);
71     if (reverse = i >= hp->wi[5])
72     i -= hp->wi[5] - 1;
73     for (j = 0; j < 5; j++) /* find w0 */
74     if (hp->wi[j+1] > i)
75     break;
76     i -= hp->wi[gc[0].w=j];
77     /* find w1 */
78 gregl 3.13 n2 = hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
79 gregl 3.1 while (++j < 5) {
80 gregl 3.13 n = n2 * hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
81 gregl 3.1 if (n > i)
82     break;
83     i -= n;
84     }
85     gc[1].w = j;
86     /* find position on w0 */
87 gregl 3.13 n2 = hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
88 gregl 3.1 n = i / n2;
89 gregl 3.13 gc[0].i[1] = n / hp->grid[hdwg0[gc[0].w]];
90     gc[0].i[0] = n - gc[0].i[1]*hp->grid[hdwg0[gc[0].w]];
91 gregl 3.1 i -= n*n2;
92     /* find position on w1 */
93 gregl 3.13 gc[1].i[1] = i / hp->grid[hdwg0[gc[1].w]];
94     gc[1].i[0] = i - gc[1].i[1]*hp->grid[hdwg0[gc[1].w]];
95 gregl 3.1 if (reverse) {
96     copystruct(g2, gc+1);
97     copystruct(gc+1, gc);
98     copystruct(gc, g2);
99     }
100     return(1); /* we're done */
101     }
102    
103    
104     int
105     hdbindex(hp, gc) /* compute index from beam coordinates */
106     register HOLO *hp;
107 gregl 3.3 register GCOORD gc[2];
108 gregl 3.1 {
109 gregl 3.3 GCOORD g2[2];
110 gregl 3.1 int reverse;
111     register int i, j;
112     /* check ordering and limits */
113     if (reverse = gc[0].w > gc[1].w) {
114     copystruct(g2, gc+1);
115     copystruct(g2+1, gc);
116     gc = g2;
117     } else if (gc[0].w == gc[1].w)
118     return(0);
119     if (gc[0].w < 0 | gc[1].w > 5)
120     return(0);
121     i = 0; /* compute index */
122     for (j = gc[0].w+1; j < gc[1].w; j++)
123 gregl 3.13 i += hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
124     i *= hp->grid[hdwg0[gc[0].w]] * hp->grid[hdwg1[gc[0].w]];
125 gregl 3.1 i += hp->wi[gc[0].w];
126 gregl 3.13 i += (hp->grid[hdwg0[gc[0].w]]*gc[0].i[1] + gc[0].i[0]) *
127     hp->grid[hdwg0[gc[1].w]] * hp->grid[hdwg1[gc[1].w]] ;
128     i += hp->grid[hdwg0[gc[1].w]]*gc[1].i[1] + gc[1].i[0];
129 gregl 3.1 if (reverse)
130     i += hp->wi[5] - 1;
131     return(i);
132     }
133    
134    
135 gregl 3.4 hdcell(cp, hp, gc) /* compute cell coordinates */
136     register FVECT cp[4]; /* returned (may be passed as FVECT cp[2][2]) */
137 gregl 3.5 register HOLO *hp;
138 gregl 3.4 register GCOORD *gc;
139     {
140     register FLOAT *v;
141     double d;
142 gregl 3.5 /* compute common component */
143     VCOPY(cp[0], hp->orig);
144     if (gc->w & 1) {
145     v = hp->xv[gc->w>>1];
146     cp[0][0] += v[0]; cp[0][1] += v[1]; cp[0][2] += v[2];
147 gregl 3.4 }
148 gregl 3.13 v = hp->xv[hdwg0[gc->w]];
149     d = (double)gc->i[0] / hp->grid[hdwg0[gc->w]];
150 gregl 3.5 VSUM(cp[0], cp[0], v, d);
151 gregl 3.13 v = hp->xv[hdwg1[gc->w]];
152     d = (double)gc->i[1] / hp->grid[hdwg1[gc->w]];
153 gregl 3.5 VSUM(cp[0], cp[0], v, d);
154     /* compute x1 sums */
155 gregl 3.13 v = hp->xv[hdwg0[gc->w]];
156     d = 1.0 / hp->grid[hdwg0[gc->w]];
157 gregl 3.5 VSUM(cp[1], cp[0], v, d);
158     VSUM(cp[3], cp[0], v, d);
159     /* compute y1 sums */
160 gregl 3.13 v = hp->xv[hdwg1[gc->w]];
161     d = 1.0 / hp->grid[hdwg1[gc->w]];
162 gregl 3.5 VSUM(cp[2], cp[0], v, d);
163     VSUM(cp[3], cp[3], v, d);
164 gregl 3.4 }
165    
166    
167 gregl 3.9 hdlseg(lseg, hp, gc) /* compute line segment for beam */
168 gregl 3.2 register int lseg[2][3];
169 gregl 3.1 register HOLO *hp;
170 gregl 3.9 GCOORD gc[2];
171 gregl 3.1 {
172     register int k;
173    
174 gregl 3.2 for (k = 0; k < 2; k++) { /* compute end points */
175     lseg[k][gc[k].w>>1] = gc[k].w&1 ? hp->grid[gc[k].w>>1]-1 : 0 ;
176 gregl 3.13 lseg[k][hdwg0[gc[k].w]] = gc[k].i[0];
177     lseg[k][hdwg1[gc[k].w]] = gc[k].i[1];
178 gregl 3.2 }
179 gregl 3.1 return(1);
180     }
181    
182    
183     unsigned
184     hdcode(hp, d) /* compute depth code for d */
185     HOLO *hp;
186     double d;
187     {
188     double tl = hp->tlin;
189 gregl 3.12 register long c;
190 gregl 3.1
191     if (d <= 0.)
192     return(0);
193     if (d >= .99*FHUGE)
194     return(DCINF);
195     if (d < tl)
196     return((unsigned)(d*DCLIN/tl));
197 gregl 3.12 c = (long)(log(d/tl)/logstep) + DCLIN;
198     return(c > DCINF ? (unsigned)DCINF : (unsigned)c);
199 gregl 3.1 }
200    
201    
202 gregl 3.6 hdgrid(gp, hp, wp) /* compute grid coordinates */
203     FVECT gp; /* returned */
204     register HOLO *hp;
205     FVECT wp;
206     {
207     FVECT vt;
208    
209 gwlarson 3.14 VSUB(vt, wp, hp->orig);
210 gregl 3.13 gp[0] = DOT(vt, hp->wg[0]);
211     gp[1] = DOT(vt, hp->wg[1]);
212     gp[2] = DOT(vt, hp->wg[2]);
213 gregl 3.6 }
214    
215    
216 gregl 3.7 hdworld(wp, hp, gp) /* compute world coordinates */
217     register FVECT wp;
218     register HOLO *hp;
219 gregl 3.8 FVECT gp;
220 gregl 3.7 {
221 gregl 3.8 register double d;
222    
223     d = gp[0]/hp->grid[0];
224     VSUM(wp, hp->orig, hp->xv[0], d);
225    
226     d = gp[1]/hp->grid[1];
227     VSUM(wp, wp, hp->xv[1], d);
228    
229     d = gp[2]/hp->grid[2];
230     VSUM(wp, wp, hp->xv[2], d);
231 gregl 3.7 }
232    
233    
234 gregl 3.1 double
235     hdray(ro, rd, hp, gc, r) /* compute ray within a beam */
236     FVECT ro, rd; /* returned */
237 gregl 3.5 HOLO *hp;
238     GCOORD gc[2];
239 gregl 3.1 BYTE r[2][2];
240     {
241 gregl 3.5 FVECT cp[4], p[2];
242     register int i, j;
243     double d0, d1;
244 gregl 3.1 /* compute entry and exit points */
245     for (i = 0; i < 2; i++) {
246 gregl 3.5 hdcell(cp, hp, gc+i);
247     d0 = (1./256.)*(r[i][0]+.5);
248     d1 = (1./256.)*(r[i][1]+.5);
249     for (j = 0; j < 3; j++)
250     p[i][j] = (1.-d0-d1)*cp[0][j] +
251     d0*cp[1][j] + d1*cp[2][j];
252 gregl 3.1 }
253     VCOPY(ro, p[0]); /* assign ray origin and direction */
254 gwlarson 3.14 VSUB(rd, p[1], p[0]);
255 gregl 3.1 return(normalize(rd)); /* return maximum inside distance */
256     }
257    
258    
259     double
260 gregl 3.10 hdinter(gc, r, ed, hp, ro, rd) /* compute ray intersection with section */
261 gregl 3.3 register GCOORD gc[2]; /* returned */
262 gregl 3.11 BYTE r[2][2]; /* returned (optional) */
263 gregl 3.10 double *ed; /* returned (optional) */
264 gregl 3.1 register HOLO *hp;
265 gregl 3.11 FVECT ro, rd; /* normalization of rd affects distances */
266 gregl 3.1 {
267     FVECT p[2], vt;
268     double d, t0, t1, d0, d1;
269     register FLOAT *v;
270     register int i;
271     /* first, intersect walls */
272     gc[0].w = gc[1].w = -1;
273     t0 = -FHUGE; t1 = FHUGE;
274 gwlarson 3.15 VSUB(vt, ro, hp->orig);
275 gregl 3.1 for (i = 0; i < 3; i++) { /* for each wall pair */
276 gregl 3.13 d = -DOT(rd, hp->wg[i]); /* plane distance */
277 gregl 3.1 if (d <= FTINY && d >= -FTINY) /* check for parallel */
278     continue;
279 gwlarson 3.15 d1 = DOT(vt, hp->wg[i]); /* ray distances */
280     d0 = d1 / d;
281     d1 = (d1 - hp->grid[i]) / d;
282     if (d < 0) { /* check against best */
283 gregl 3.1 if (d0 > t0) {
284     t0 = d0;
285     gc[0].w = i<<1;
286     }
287     if (d1 < t1) {
288     t1 = d1;
289     gc[1].w = i<<1 | 1;
290     }
291     } else {
292     if (d1 > t0) {
293     t0 = d1;
294     gc[0].w = i<<1 | 1;
295     }
296     if (d0 < t1) {
297     t1 = d0;
298     gc[1].w = i<<1;
299     }
300     }
301     }
302     if (gc[0].w < 0 | gc[1].w < 0) /* paranoid check */
303     return(FHUGE);
304     /* compute intersections */
305 gwlarson 3.14 VSUM(p[0], ro, rd, t0);
306     VSUM(p[1], ro, rd, t1);
307 gregl 3.1 /* now, compute grid coordinates */
308     for (i = 0; i < 2; i++) {
309 gwlarson 3.14 VSUB(vt, p[i], hp->orig);
310 gregl 3.13 v = hp->wg[hdwg0[gc[i].w]];
311     d = DOT(vt, v);
312 gwlarson 3.15 if (d < 0 || d >= hp->grid[hdwg0[gc[i].w]])
313 gregl 3.1 return(FHUGE); /* outside wall */
314 gwlarson 3.15 gc[i].i[0] = d;
315 gregl 3.11 if (r != NULL)
316     r[i][0] = 256. * (d - gc[i].i[0]);
317 gregl 3.13 v = hp->wg[hdwg1[gc[i].w]];
318     d = DOT(vt, v);
319 gwlarson 3.15 if (d < 0 || d >= hp->grid[hdwg1[gc[i].w]])
320 gregl 3.1 return(FHUGE); /* outside wall */
321 gwlarson 3.15 gc[i].i[1] = d;
322 gregl 3.11 if (r != NULL)
323     r[i][1] = 256. * (d - gc[i].i[1]);
324 gregl 3.1 }
325 gregl 3.10 if (ed != NULL) /* assign distance to exit point */
326     *ed = t1;
327     return(t0); /* return distance to entry point */
328 gregl 3.1 }