ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/hd/holo.c
Revision: 3.18
Committed: Thu Jun 26 00:58:10 2003 UTC (20 years, 9 months ago) by schorsch
Content type: text/plain
Branch: MAIN
Changes since 3.17: +3 -3 lines
Log Message:
Abstracted process and path handling for Windows.
Renamed FLOAT to RREAL because of conflict on Windows.
Added conditional compiles for some signal handlers.

File Contents

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