ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/holo.c
Revision: 3.9
Committed: Mon Dec 15 20:43:24 1997 UTC (26 years, 3 months ago) by gregl
Content type: text/plain
Branch: MAIN
Changes since 3.8: +2 -5 lines
Log Message:
changed hdlseg() arguments

File Contents

# Content
1 /* Copyright (c) 1997 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 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 {
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->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 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]);
49 /* compute wall super-indices from grid */
50 hp->wi[0] = 1; /**** index values begin at 1 ****/
51 for (i = 1; i < 6; i++) {
52 hp->wi[i] = 0;
53 for (j = i; j < 6; j++)
54 hp->wi[i] += hp->grid[wg0[j]] * hp->grid[wg1[j]];
55 hp->wi[i] *= hp->grid[wg0[i-1]] * hp->grid[wg1[i-1]];
56 hp->wi[i] += hp->wi[i-1];
57 }
58 }
59
60
61 HOLO *
62 hdalloc(hproto) /* allocate and set holodeck section based on grid */
63 HDGRID *hproto;
64 {
65 HOLO hdhead;
66 register HOLO *hp;
67 int n;
68 /* copy grid to temporary header */
69 bcopy((char *)hproto, (char *)&hdhead, sizeof(HDGRID));
70 /* compute grid vectors and sizes */
71 hdcompgrid(&hdhead);
72 /* allocate header with directory */
73 n = sizeof(HOLO)+nbeams(&hdhead)*sizeof(BEAMI);
74 if ((hp = (HOLO *)malloc(n)) == NULL)
75 return(NULL);
76 /* copy header information */
77 copystruct(hp, &hdhead);
78 /* allocate and clear beam list */
79 hp->bl = (BEAM **)malloc((nbeams(hp)+1)*sizeof(BEAM *)+sizeof(BEAM));
80 if (hp->bl == NULL) {
81 free((char *)hp);
82 return(NULL);
83 }
84 bzero((char *)hp->bl, (nbeams(hp)+1)*sizeof(BEAM *)+sizeof(BEAM));
85 hp->bl[0] = (BEAM *)(hp->bl+nbeams(hp)+1); /* set blglob(hp) */
86 hp->fd = -1;
87 hp->dirty = 0;
88 hp->priv = NULL;
89 /* clear beam directory */
90 bzero((char *)hp->bi, (nbeams(hp)+1)*sizeof(BEAMI));
91 return(hp); /* all is well */
92 }
93
94
95 hdbcoord(gc, hp, i) /* compute beam coordinates from index */
96 GCOORD gc[2]; /* returned */
97 register HOLO *hp;
98 register int i;
99 {
100 register int j, n;
101 int n2, reverse;
102 GCOORD g2[2];
103 /* check range */
104 if (i < 1 | i > nbeams(hp))
105 return(0);
106 if (reverse = i >= hp->wi[5])
107 i -= hp->wi[5] - 1;
108 for (j = 0; j < 5; j++) /* find w0 */
109 if (hp->wi[j+1] > i)
110 break;
111 i -= hp->wi[gc[0].w=j];
112 /* find w1 */
113 n2 = hp->grid[wg0[j]] * hp->grid[wg1[j]];
114 while (++j < 5) {
115 n = n2 * hp->grid[wg0[j]] * hp->grid[wg1[j]];
116 if (n > i)
117 break;
118 i -= n;
119 }
120 gc[1].w = j;
121 /* find position on w0 */
122 n2 = hp->grid[wg0[j]] * hp->grid[wg1[j]];
123 n = i / n2;
124 gc[0].i[1] = n / hp->grid[wg0[gc[0].w]];
125 gc[0].i[0] = n - gc[0].i[1]*hp->grid[wg0[gc[0].w]];
126 i -= n*n2;
127 /* find position on w1 */
128 gc[1].i[1] = i / hp->grid[wg0[gc[1].w]];
129 gc[1].i[0] = i - gc[1].i[1]*hp->grid[wg0[gc[1].w]];
130 if (reverse) {
131 copystruct(g2, gc+1);
132 copystruct(gc+1, gc);
133 copystruct(gc, g2);
134 }
135 return(1); /* we're done */
136 }
137
138
139 int
140 hdbindex(hp, gc) /* compute index from beam coordinates */
141 register HOLO *hp;
142 register GCOORD gc[2];
143 {
144 GCOORD g2[2];
145 int reverse;
146 register int i, j;
147 /* check ordering and limits */
148 if (reverse = gc[0].w > gc[1].w) {
149 copystruct(g2, gc+1);
150 copystruct(g2+1, gc);
151 gc = g2;
152 } else if (gc[0].w == gc[1].w)
153 return(0);
154 if (gc[0].w < 0 | gc[1].w > 5)
155 return(0);
156 i = 0; /* compute index */
157 for (j = gc[0].w+1; j < gc[1].w; j++)
158 i += hp->grid[wg0[j]] * hp->grid[wg1[j]];
159 i *= hp->grid[wg0[gc[0].w]] * hp->grid[wg1[gc[0].w]];
160 i += hp->wi[gc[0].w];
161 i += (hp->grid[wg0[gc[0].w]]*gc[0].i[1] + gc[0].i[0]) *
162 hp->grid[wg0[gc[1].w]] * hp->grid[wg1[gc[1].w]] ;
163 i += hp->grid[wg0[gc[1].w]]*gc[1].i[1] + gc[1].i[0];
164 if (reverse)
165 i += hp->wi[5] - 1;
166 return(i);
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, gc) /* compute line segment for beam */
203 register int lseg[2][3];
204 register HOLO *hp;
205 GCOORD gc[2];
206 {
207 register int k;
208
209 for (k = 0; k < 2; k++) { /* compute end points */
210 lseg[k][gc[k].w>>1] = gc[k].w&1 ? hp->grid[gc[k].w>>1]-1 : 0 ;
211 lseg[k][wg0[gc[k].w]] = gc[k].i[0];
212 lseg[k][wg1[gc[k].w]] = gc[k].i[1];
213 }
214 return(1);
215 }
216
217
218 unsigned
219 hdcode(hp, d) /* compute depth code for d */
220 HOLO *hp;
221 double d;
222 {
223 double tl = hp->tlin;
224 register unsigned c;
225
226 if (d <= 0.)
227 return(0);
228 if (d >= .99*FHUGE)
229 return(DCINF);
230 if (d < tl)
231 return((unsigned)(d*DCLIN/tl));
232 c = (unsigned)(log(d/tl)/logstep) + DCLIN;
233 return(c > DCINF ? DCINF : c);
234 }
235
236
237 hdgrid(gp, hp, wp) /* compute grid coordinates */
238 FVECT gp; /* returned */
239 register HOLO *hp;
240 FVECT wp;
241 {
242 FVECT vt;
243
244 vt[0] = wp[0] - hp->orig[0];
245 vt[1] = wp[1] - hp->orig[1];
246 vt[2] = wp[2] - hp->orig[2];
247 gp[0] = DOT(vt, hp->wn[0]) * hp->wg[0];
248 gp[1] = DOT(vt, hp->wn[1]) * hp->wg[1];
249 gp[2] = DOT(vt, hp->wn[2]) * hp->wg[2];
250 }
251
252
253 hdworld(wp, hp, gp) /* compute world coordinates */
254 register FVECT wp;
255 register HOLO *hp;
256 FVECT gp;
257 {
258 register double d;
259
260 d = gp[0]/hp->grid[0];
261 VSUM(wp, hp->orig, hp->xv[0], d);
262
263 d = gp[1]/hp->grid[1];
264 VSUM(wp, wp, hp->xv[1], d);
265
266 d = gp[2]/hp->grid[2];
267 VSUM(wp, wp, hp->xv[2], d);
268 }
269
270
271 double
272 hdray(ro, rd, hp, gc, r) /* compute ray within a beam */
273 FVECT ro, rd; /* returned */
274 HOLO *hp;
275 GCOORD gc[2];
276 BYTE r[2][2];
277 {
278 FVECT cp[4], p[2];
279 register int i, j;
280 double d0, d1;
281 /* compute entry and exit points */
282 for (i = 0; i < 2; i++) {
283 hdcell(cp, hp, gc+i);
284 d0 = (1./256.)*(r[i][0]+.5);
285 d1 = (1./256.)*(r[i][1]+.5);
286 for (j = 0; j < 3; j++)
287 p[i][j] = (1.-d0-d1)*cp[0][j] +
288 d0*cp[1][j] + d1*cp[2][j];
289 }
290 VCOPY(ro, p[0]); /* assign ray origin and direction */
291 rd[0] = p[1][0] - p[0][0];
292 rd[1] = p[1][1] - p[0][1];
293 rd[2] = p[1][2] - p[0][2];
294 return(normalize(rd)); /* return maximum inside distance */
295 }
296
297
298 double
299 hdinter(gc, r, hp, ro, rd) /* compute ray intersection with section */
300 register GCOORD gc[2]; /* returned */
301 BYTE r[2][2]; /* returned */
302 register HOLO *hp;
303 FVECT ro, rd; /* rd should be normalized */
304 {
305 FVECT p[2], vt;
306 double d, t0, t1, d0, d1;
307 register FLOAT *v;
308 register int i;
309 /* first, intersect walls */
310 gc[0].w = gc[1].w = -1;
311 t0 = -FHUGE; t1 = FHUGE;
312 for (i = 0; i < 3; i++) { /* for each wall pair */
313 d = -DOT(rd, hp->wn[i]); /* plane distance */
314 if (d <= FTINY && d >= -FTINY) /* check for parallel */
315 continue;
316 d1 = DOT(ro, hp->wn[i]); /* ray distances */
317 d0 = (d1 - hp->wo[i<<1]) / d;
318 d1 = (d1 - hp->wo[i<<1|1]) / d;
319 if (d0 < d1) { /* check against best */
320 if (d0 > t0) {
321 t0 = d0;
322 gc[0].w = i<<1;
323 }
324 if (d1 < t1) {
325 t1 = d1;
326 gc[1].w = i<<1 | 1;
327 }
328 } else {
329 if (d1 > t0) {
330 t0 = d1;
331 gc[0].w = i<<1 | 1;
332 }
333 if (d0 < t1) {
334 t1 = d0;
335 gc[1].w = i<<1;
336 }
337 }
338 }
339 if (gc[0].w < 0 | gc[1].w < 0) /* paranoid check */
340 return(FHUGE);
341 /* compute intersections */
342 for (i = 0; i < 3; i++) {
343 p[0][i] = ro[i] + rd[i]*t0;
344 p[1][i] = ro[i] + rd[i]*t1;
345 }
346 /* now, compute grid coordinates */
347 for (i = 0; i < 2; i++) {
348 vt[0] = p[i][0] - hp->orig[0];
349 vt[1] = p[i][1] - hp->orig[1];
350 vt[2] = p[i][2] - hp->orig[2];
351 v = hp->wn[wg0[gc[i].w]];
352 d = DOT(vt, v) * hp->wg[wg0[gc[i].w]];
353 if (d < 0. || (gc[i].i[0] = d) >= hp->grid[wg0[gc[i].w]])
354 return(FHUGE); /* outside wall */
355 r[i][0] = 256. * (d - gc[i].i[0]);
356 v = hp->wn[wg1[gc[i].w]];
357 d = DOT(vt, v) * hp->wg[wg1[gc[i].w]];
358 if (d < 0. || (gc[i].i[1] = d) >= hp->grid[wg1[gc[i].w]])
359 return(FHUGE); /* outside wall */
360 r[i][1] = 256. * (d - gc[i].i[1]);
361 }
362 /* return distance from entry point */
363 vt[0] = ro[0] - p[0][0];
364 vt[1] = ro[1] - p[0][1];
365 vt[2] = ro[2] - p[0][2];
366 return(DOT(vt,rd));
367 }