| 199 |
|
} |
| 200 |
|
|
| 201 |
|
|
| 202 |
< |
hdlseg(lseg, hp, i) /* compute line segment for beam */ |
| 202 |
> |
hdlseg(lseg, hp, gc) /* compute line segment for beam */ |
| 203 |
|
register int lseg[2][3]; |
| 204 |
|
register HOLO *hp; |
| 205 |
< |
int i; |
| 205 |
> |
GCOORD gc[2]; |
| 206 |
|
{ |
| 207 |
– |
GCOORD gc[2]; |
| 207 |
|
register int k; |
| 208 |
|
|
| 210 |
– |
if (!hdbcoord(gc, hp, i)) /* compute grid coordinates */ |
| 211 |
– |
return(0); |
| 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]; |
| 221 |
|
double d; |
| 222 |
|
{ |
| 223 |
|
double tl = hp->tlin; |
| 224 |
< |
register unsigned c; |
| 224 |
> |
register long c; |
| 225 |
|
|
| 226 |
|
if (d <= 0.) |
| 227 |
|
return(0); |
| 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); |
| 232 |
> |
c = (long)(log(d/tl)/logstep) + DCLIN; |
| 233 |
> |
return(c > DCINF ? (unsigned)DCINF : (unsigned)c); |
| 234 |
|
} |
| 235 |
|
|
| 236 |
|
|
| 253 |
|
hdworld(wp, hp, gp) /* compute world coordinates */ |
| 254 |
|
register FVECT wp; |
| 255 |
|
register HOLO *hp; |
| 256 |
< |
register FVECT gp; |
| 256 |
> |
FVECT gp; |
| 257 |
|
{ |
| 258 |
< |
VSUM(wp, hp->orig, hp->xv[0], gp[0]); |
| 259 |
< |
VSUM(wp, wp, hp->xv[1], gp[1]); |
| 260 |
< |
VSUM(wp, wp, hp->xv[2], gp[2]); |
| 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 |
|
|
| 296 |
|
|
| 297 |
|
|
| 298 |
|
double |
| 299 |
< |
hdinter(gc, r, hp, ro, rd) /* compute ray intersection with section */ |
| 299 |
> |
hdinter(gc, r, ed, hp, ro, rd) /* compute ray intersection with section */ |
| 300 |
|
register GCOORD gc[2]; /* returned */ |
| 301 |
< |
BYTE r[2][2]; /* returned */ |
| 301 |
> |
BYTE r[2][2]; /* returned (optional) */ |
| 302 |
> |
double *ed; /* returned (optional) */ |
| 303 |
|
register HOLO *hp; |
| 304 |
< |
FVECT ro, rd; /* rd should be normalized */ |
| 304 |
> |
FVECT ro, rd; /* normalization of rd affects distances */ |
| 305 |
|
{ |
| 306 |
|
FVECT p[2], vt; |
| 307 |
|
double d, t0, t1, d0, d1; |
| 353 |
|
d = DOT(vt, v) * hp->wg[wg0[gc[i].w]]; |
| 354 |
|
if (d < 0. || (gc[i].i[0] = d) >= hp->grid[wg0[gc[i].w]]) |
| 355 |
|
return(FHUGE); /* outside wall */ |
| 356 |
< |
r[i][0] = 256. * (d - gc[i].i[0]); |
| 356 |
> |
if (r != NULL) |
| 357 |
> |
r[i][0] = 256. * (d - gc[i].i[0]); |
| 358 |
|
v = hp->wn[wg1[gc[i].w]]; |
| 359 |
|
d = DOT(vt, v) * hp->wg[wg1[gc[i].w]]; |
| 360 |
|
if (d < 0. || (gc[i].i[1] = d) >= hp->grid[wg1[gc[i].w]]) |
| 361 |
|
return(FHUGE); /* outside wall */ |
| 362 |
< |
r[i][1] = 256. * (d - gc[i].i[1]); |
| 362 |
> |
if (r != NULL) |
| 363 |
> |
r[i][1] = 256. * (d - gc[i].i[1]); |
| 364 |
|
} |
| 365 |
< |
/* return distance from entry point */ |
| 366 |
< |
vt[0] = ro[0] - p[0][0]; |
| 367 |
< |
vt[1] = ro[1] - p[0][1]; |
| 361 |
< |
vt[2] = ro[2] - p[0][2]; |
| 362 |
< |
return(DOT(vt,rd)); |
| 365 |
> |
if (ed != NULL) /* assign distance to exit point */ |
| 366 |
> |
*ed = t1; |
| 367 |
> |
return(t0); /* return distance to entry point */ |
| 368 |
|
} |
