| 23 |
|
hdcompgrid(hp) /* compute derived grid vector and index */ |
| 24 |
|
register HOLO *hp; |
| 25 |
|
{ |
| 26 |
– |
FVECT AxB; |
| 26 |
|
double d; |
| 28 |
– |
register FLOAT *v; |
| 27 |
|
register int i, j; |
| 28 |
|
/* initialize depth map */ |
| 29 |
|
if (hd_depthmap[0] < 1.) { |
| 36 |
|
} |
| 37 |
|
/* compute grid coordinate vectors */ |
| 38 |
|
for (i = 0; i < 3; i++) { |
| 39 |
< |
fcross(AxB, hp->xv[(i+1)%3], v=hp->xv[(i+2)%3]); |
| 42 |
< |
VCOPY(hp->wn[i], AxB); |
| 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 |
< |
hp->wo[i<<1|1] = hp->wo[i<<1] + DOT(hp->wn[i],hp->xv[i]); |
| 44 |
< |
fcross(hp->gv[i][0], v, AxB); |
| 45 |
< |
d = DOT(v,v) / DOT(hp->gv[i][0],hp->gv[i][0]) * |
| 49 |
< |
hp->grid[(i+1)%3]; |
| 50 |
< |
for (j = 0; j < 3; j++) |
| 51 |
< |
hp->gv[i][0][j] *= d; |
| 52 |
< |
fcross(hp->gv[i][1], AxB, v=hp->xv[(i+1)%3]); |
| 53 |
< |
d = DOT(v,v) / DOT(hp->gv[i][1],hp->gv[i][1]) * |
| 54 |
< |
hp->grid[(i+2)%3]; |
| 55 |
< |
for (j = 0; j < 3; j++) |
| 56 |
< |
hp->gv[i][1][j] *= d; |
| 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]); |
| 237 |
|
} |
| 238 |
|
|
| 239 |
|
|
| 240 |
+ |
hdgrid(gp, hp, wp) /* compute grid coordinates */ |
| 241 |
+ |
FVECT gp; /* returned */ |
| 242 |
+ |
register HOLO *hp; |
| 243 |
+ |
FVECT wp; |
| 244 |
+ |
{ |
| 245 |
+ |
FVECT vt; |
| 246 |
+ |
|
| 247 |
+ |
vt[0] = wp[0] - hp->orig[0]; |
| 248 |
+ |
vt[1] = wp[1] - hp->orig[1]; |
| 249 |
+ |
vt[2] = wp[2] - hp->orig[2]; |
| 250 |
+ |
gp[0] = DOT(vt, hp->wn[0]) * hp->wg[0]; |
| 251 |
+ |
gp[1] = DOT(vt, hp->wn[1]) * hp->wg[1]; |
| 252 |
+ |
gp[2] = DOT(vt, hp->wn[2]) * hp->wg[2]; |
| 253 |
+ |
} |
| 254 |
+ |
|
| 255 |
+ |
|
| 256 |
|
double |
| 257 |
|
hdray(ro, rd, hp, gc, r) /* compute ray within a beam */ |
| 258 |
|
FVECT ro, rd; /* returned */ |
| 333 |
|
vt[0] = p[i][0] - hp->orig[0]; |
| 334 |
|
vt[1] = p[i][1] - hp->orig[1]; |
| 335 |
|
vt[2] = p[i][2] - hp->orig[2]; |
| 336 |
< |
if (gc[i].w & 1) { |
| 337 |
< |
v = hp->xv[gc[i].w>>1]; |
| 333 |
< |
vt[0] -= *v++; vt[1] -= *v++; vt[2] -= *v; |
| 334 |
< |
} |
| 335 |
< |
v = hp->gv[gc[i].w>>1][0]; |
| 336 |
< |
d = DOT(vt, v); |
| 336 |
> |
v = hp->wn[wg0[gc[i].w]]; |
| 337 |
> |
d = DOT(vt, v) * hp->wg[wg0[gc[i].w]]; |
| 338 |
|
if (d < 0. || (gc[i].i[0] = d) >= hp->grid[wg0[gc[i].w]]) |
| 339 |
|
return(FHUGE); /* outside wall */ |
| 340 |
|
r[i][0] = 256. * (d - gc[i].i[0]); |
| 341 |
< |
v = hp->gv[gc[i].w>>1][1]; |
| 342 |
< |
d = DOT(vt, v); |
| 341 |
> |
v = hp->wn[wg1[gc[i].w]]; |
| 342 |
> |
d = DOT(vt, v) * hp->wg[wg1[gc[i].w]]; |
| 343 |
|
if (d < 0. || (gc[i].i[1] = d) >= hp->grid[wg1[gc[i].w]]) |
| 344 |
|
return(FHUGE); /* outside wall */ |
| 345 |
|
r[i][1] = 256. * (d - gc[i].i[1]); |
