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

# 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     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 gregl 3.3 GCOORD gc[2]; /* returned */
96 gregl 3.1 register HOLO *hp;
97     register int i;
98     {
99     register int j, n;
100     int n2, reverse;
101 gregl 3.3 GCOORD g2[2];
102 gregl 3.1 /* 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 gregl 3.13 n2 = hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
113 gregl 3.1 while (++j < 5) {
114 gregl 3.13 n = n2 * hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
115 gregl 3.1 if (n > i)
116     break;
117     i -= n;
118     }
119     gc[1].w = j;
120     /* find position on w0 */
121 gregl 3.13 n2 = hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
122 gregl 3.1 n = i / n2;
123 gregl 3.13 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 gregl 3.1 i -= n*n2;
126     /* find position on w1 */
127 gregl 3.13 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 gregl 3.1 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 gregl 3.3 register GCOORD gc[2];
142 gregl 3.1 {
143 gregl 3.3 GCOORD g2[2];
144 gregl 3.1 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 gregl 3.13 i += hp->grid[hdwg0[j]] * hp->grid[hdwg1[j]];
158     i *= hp->grid[hdwg0[gc[0].w]] * hp->grid[hdwg1[gc[0].w]];
159 gregl 3.1 i += hp->wi[gc[0].w];
160 gregl 3.13 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 gregl 3.1 if (reverse)
164     i += hp->wi[5] - 1;
165     return(i);
166     }
167    
168    
169 gregl 3.4 hdcell(cp, hp, gc) /* compute cell coordinates */
170     register FVECT cp[4]; /* returned (may be passed as FVECT cp[2][2]) */
171 gregl 3.5 register HOLO *hp;
172 gregl 3.4 register GCOORD *gc;
173     {
174     register FLOAT *v;
175     double d;
176 gregl 3.5 /* 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 gregl 3.4 }
182 gregl 3.13 v = hp->xv[hdwg0[gc->w]];
183     d = (double)gc->i[0] / hp->grid[hdwg0[gc->w]];
184 gregl 3.5 VSUM(cp[0], cp[0], v, d);
185 gregl 3.13 v = hp->xv[hdwg1[gc->w]];
186     d = (double)gc->i[1] / hp->grid[hdwg1[gc->w]];
187 gregl 3.5 VSUM(cp[0], cp[0], v, d);
188     /* compute x1 sums */
189 gregl 3.13 v = hp->xv[hdwg0[gc->w]];
190     d = 1.0 / hp->grid[hdwg0[gc->w]];
191 gregl 3.5 VSUM(cp[1], cp[0], v, d);
192     VSUM(cp[3], cp[0], v, d);
193     /* compute y1 sums */
194 gregl 3.13 v = hp->xv[hdwg1[gc->w]];
195     d = 1.0 / hp->grid[hdwg1[gc->w]];
196 gregl 3.5 VSUM(cp[2], cp[0], v, d);
197     VSUM(cp[3], cp[3], v, d);
198 gregl 3.4 }
199    
200    
201 gregl 3.9 hdlseg(lseg, hp, gc) /* compute line segment for beam */
202 gregl 3.2 register int lseg[2][3];
203 gregl 3.1 register HOLO *hp;
204 gregl 3.9 GCOORD gc[2];
205 gregl 3.1 {
206     register int k;
207    
208 gregl 3.2 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 gregl 3.13 lseg[k][hdwg0[gc[k].w]] = gc[k].i[0];
211     lseg[k][hdwg1[gc[k].w]] = gc[k].i[1];
212 gregl 3.2 }
213 gregl 3.1 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 gregl 3.12 register long c;
224 gregl 3.1
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 gregl 3.12 c = (long)(log(d/tl)/logstep) + DCLIN;
232     return(c > DCINF ? (unsigned)DCINF : (unsigned)c);
233 gregl 3.1 }
234    
235    
236 gregl 3.6 hdgrid(gp, hp, wp) /* compute grid coordinates */
237     FVECT gp; /* returned */
238     register HOLO *hp;
239     FVECT wp;
240     {
241     FVECT vt;
242    
243 gwlarson 3.14 VSUB(vt, wp, hp->orig);
244 gregl 3.13 gp[0] = DOT(vt, hp->wg[0]);
245     gp[1] = DOT(vt, hp->wg[1]);
246     gp[2] = DOT(vt, hp->wg[2]);
247 gregl 3.6 }
248    
249    
250 gregl 3.7 hdworld(wp, hp, gp) /* compute world coordinates */
251     register FVECT wp;
252     register HOLO *hp;
253 gregl 3.8 FVECT gp;
254 gregl 3.7 {
255 gregl 3.8 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 gregl 3.7 }
266    
267    
268 gregl 3.1 double
269     hdray(ro, rd, hp, gc, r) /* compute ray within a beam */
270     FVECT ro, rd; /* returned */
271 gregl 3.5 HOLO *hp;
272     GCOORD gc[2];
273 gregl 3.1 BYTE r[2][2];
274     {
275 gregl 3.5 FVECT cp[4], p[2];
276     register int i, j;
277     double d0, d1;
278 gregl 3.1 /* compute entry and exit points */
279     for (i = 0; i < 2; i++) {
280 gregl 3.5 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 gregl 3.1 }
287     VCOPY(ro, p[0]); /* assign ray origin and direction */
288 gwlarson 3.14 VSUB(rd, p[1], p[0]);
289 gregl 3.1 return(normalize(rd)); /* return maximum inside distance */
290     }
291    
292    
293     double
294 gregl 3.10 hdinter(gc, r, ed, hp, ro, rd) /* compute ray intersection with section */
295 gregl 3.3 register GCOORD gc[2]; /* returned */
296 gregl 3.11 BYTE r[2][2]; /* returned (optional) */
297 gregl 3.10 double *ed; /* returned (optional) */
298 gregl 3.1 register HOLO *hp;
299 gregl 3.11 FVECT ro, rd; /* normalization of rd affects distances */
300 gregl 3.1 {
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 gwlarson 3.15 VSUB(vt, ro, hp->orig);
309 gregl 3.1 for (i = 0; i < 3; i++) { /* for each wall pair */
310 gregl 3.13 d = -DOT(rd, hp->wg[i]); /* plane distance */
311 gregl 3.1 if (d <= FTINY && d >= -FTINY) /* check for parallel */
312     continue;
313 gwlarson 3.15 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 gregl 3.1 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 gwlarson 3.14 VSUM(p[0], ro, rd, t0);
340     VSUM(p[1], ro, rd, t1);
341 gregl 3.1 /* now, compute grid coordinates */
342     for (i = 0; i < 2; i++) {
343 gwlarson 3.14 VSUB(vt, p[i], hp->orig);
344 gregl 3.13 v = hp->wg[hdwg0[gc[i].w]];
345     d = DOT(vt, v);
346 gwlarson 3.15 if (d < 0 || d >= hp->grid[hdwg0[gc[i].w]])
347 gregl 3.1 return(FHUGE); /* outside wall */
348 gwlarson 3.15 gc[i].i[0] = d;
349 gregl 3.11 if (r != NULL)
350     r[i][0] = 256. * (d - gc[i].i[0]);
351 gregl 3.13 v = hp->wg[hdwg1[gc[i].w]];
352     d = DOT(vt, v);
353 gwlarson 3.15 if (d < 0 || d >= hp->grid[hdwg1[gc[i].w]])
354 gregl 3.1 return(FHUGE); /* outside wall */
355 gwlarson 3.15 gc[i].i[1] = d;
356 gregl 3.11 if (r != NULL)
357     r[i][1] = 256. * (d - gc[i].i[1]);
358 gregl 3.1 }
359 gregl 3.10 if (ed != NULL) /* assign distance to exit point */
360     *ed = t1;
361     return(t0); /* return distance to entry point */
362 gregl 3.1 }