| 25 |
|
|
| 26 |
|
#define ABS(x) ((x)>=0 ? (x) : -(x)) |
| 27 |
|
|
| 28 |
+ |
#define ZEROVECT(v) (DOT(v,v) <= FTINY*FTINY) |
| 29 |
+ |
|
| 30 |
|
#define pvect(p) printf(vformat, (p)[0], (p)[1], (p)[2]) |
| 31 |
|
|
| 32 |
|
char vformat[] = "%15.9g %15.9g %15.9g\n"; |
| 45 |
|
struct { |
| 46 |
|
int flags; /* data type */ |
| 47 |
|
short m, n; /* number of s and t values */ |
| 48 |
< |
FLOAT *data; /* the data itself, s major sort */ |
| 48 |
> |
RREAL *data; /* the data itself, s major sort */ |
| 49 |
|
} datarec; /* our recorded data */ |
| 50 |
|
|
| 51 |
|
double l_hermite(), l_bezier(), l_bspline(), l_dataval(); |
| 55 |
|
int valid; /* point is valid (vertex number) */ |
| 56 |
|
FVECT p; /* vertex position */ |
| 57 |
|
FVECT n; /* average normal */ |
| 58 |
< |
FLOAT uv[2]; /* (u,v) position */ |
| 58 |
> |
RREAL uv[2]; /* (u,v) position */ |
| 59 |
|
} POINT; |
| 60 |
|
|
| 61 |
|
|
| 180 |
|
FILE *fp; |
| 181 |
|
char word[64]; |
| 182 |
|
register int size; |
| 183 |
< |
register FLOAT *dp; |
| 183 |
> |
register RREAL *dp; |
| 184 |
|
|
| 185 |
|
datarec.flags = HASBORDER; /* assume border values */ |
| 186 |
|
datarec.m = m+1; |
| 188 |
|
size = datarec.m*datarec.n*pointsize; |
| 189 |
|
if (pointsize == 3) |
| 190 |
|
datarec.flags |= TRIPLETS; |
| 191 |
< |
dp = (FLOAT *)malloc(size*sizeof(FLOAT)); |
| 191 |
> |
dp = (RREAL *)malloc(size*sizeof(RREAL)); |
| 192 |
|
if ((datarec.data = dp) == NULL) { |
| 193 |
|
fputs("Out of memory\n", stderr); |
| 194 |
|
exit(1); |
| 211 |
|
size--; |
| 212 |
|
} |
| 213 |
|
if (size == (m+n+1)*pointsize) { /* no border after all */ |
| 214 |
< |
dp = (FLOAT *)realloc((char *)datarec.data, |
| 215 |
< |
m*n*pointsize*sizeof(FLOAT)); |
| 214 |
> |
dp = (RREAL *)realloc((void *)datarec.data, |
| 215 |
> |
m*n*pointsize*sizeof(RREAL)); |
| 216 |
|
if (dp != NULL) |
| 217 |
|
datarec.data = dp; |
| 218 |
|
datarec.flags &= ~HASBORDER; |
| 236 |
|
{ |
| 237 |
|
double u, v; |
| 238 |
|
register int i, j; |
| 239 |
< |
register FLOAT *dp; |
| 239 |
> |
register RREAL *dp; |
| 240 |
|
double d00, d01, d10, d11; |
| 241 |
|
/* compute coordinates */ |
| 242 |
|
u = argument(1); v = argument(2); |
| 282 |
|
if (!rp->valid) |
| 283 |
|
continue; |
| 284 |
|
fputs("v ", stdout); |
| 285 |
< |
printf(vformat, rp->p[0], rp->p[1], rp->p[2]); |
| 286 |
< |
if (smooth) |
| 285 |
> |
pvect(rp->p); |
| 286 |
> |
if (smooth && !ZEROVECT(rp->n)) |
| 287 |
|
printf("\tvn %.9g %.9g %.9g\n", |
| 288 |
|
rp->n[0], rp->n[1], rp->n[2]); |
| 289 |
|
printf("\tvt %.9g %.9g\n", rp->uv[0], rp->uv[1]); |
| 303 |
|
/* compute exact normals */ |
| 304 |
|
ok1 = (p0->valid && p1->valid && p2->valid); |
| 305 |
|
if (ok1) { |
| 306 |
< |
fvsum(v1, p1->p, p0->p, -1.0); |
| 307 |
< |
fvsum(v2, p2->p, p0->p, -1.0); |
| 306 |
> |
VSUB(v1, p1->p, p0->p); |
| 307 |
> |
VSUB(v2, p2->p, p0->p); |
| 308 |
|
fcross(vc1, v1, v2); |
| 309 |
|
ok1 = (normalize(vc1) != 0.0); |
| 310 |
|
} |
| 311 |
|
ok2 = (p1->valid && p2->valid && p3->valid); |
| 312 |
|
if (ok2) { |
| 313 |
< |
fvsum(v1, p2->p, p3->p, -1.0); |
| 314 |
< |
fvsum(v2, p1->p, p3->p, -1.0); |
| 313 |
> |
VSUB(v1, p2->p, p3->p); |
| 314 |
> |
VSUB(v2, p1->p, p3->p); |
| 315 |
|
fcross(vc2, v1, v2); |
| 316 |
|
ok2 = (normalize(vc2) != 0.0); |
| 317 |
|
} |
| 320 |
|
if (objout) { /* output .OBJ faces */ |
| 321 |
|
int p0n=0, p1n=0, p2n=0, p3n=0; |
| 322 |
|
if (smooth) { |
| 323 |
< |
p0n = p0->valid; |
| 324 |
< |
p1n = p1->valid; |
| 325 |
< |
p2n = p2->valid; |
| 326 |
< |
p3n = p3->valid; |
| 323 |
> |
if (!ZEROVECT(p0->n)) |
| 324 |
> |
p0n = p0->valid; |
| 325 |
> |
if (!ZEROVECT(p1->n)) |
| 326 |
> |
p1n = p1->valid; |
| 327 |
> |
if (!ZEROVECT(p2->n)) |
| 328 |
> |
p2n = p2->valid; |
| 329 |
> |
if (!ZEROVECT(p3->n)) |
| 330 |
> |
p3n = p3->valid; |
| 331 |
|
} |
| 332 |
|
if (ok1 & ok2 && fdot(vc1,vc2) >= 1.0-FTINY*FTINY) { |
| 333 |
|
printf("f %d/%d/%d %d/%d/%d %d/%d/%d %d/%d/%d\n", |
| 334 |
< |
p0->valid, p0n, p0->valid, |
| 335 |
< |
p1->valid, p1n, p1->valid, |
| 336 |
< |
p3->valid, p3n, p3->valid, |
| 337 |
< |
p2->valid, p2n, p2->valid); |
| 334 |
> |
p0->valid, p0->valid, p0n, |
| 335 |
> |
p1->valid, p1->valid, p1n, |
| 336 |
> |
p3->valid, p3->valid, p3n, |
| 337 |
> |
p2->valid, p2->valid, p2n); |
| 338 |
|
return; |
| 339 |
|
} |
| 340 |
|
if (ok1) |
| 341 |
|
printf("f %d/%d/%d %d/%d/%d %d/%d/%d\n", |
| 342 |
< |
p0->valid, p0n, p0->valid, |
| 343 |
< |
p1->valid, p1n, p1->valid, |
| 344 |
< |
p2->valid, p2n, p2->valid); |
| 342 |
> |
p0->valid, p0->valid, p0n, |
| 343 |
> |
p1->valid, p1->valid, p1n, |
| 344 |
> |
p2->valid, p2->valid, p2n); |
| 345 |
|
if (ok2) |
| 346 |
|
printf("f %d/%d/%d %d/%d/%d %d/%d/%d\n", |
| 347 |
< |
p2->valid, p2n, p2->valid, |
| 348 |
< |
p1->valid, p1n, p1->valid, |
| 349 |
< |
p3->valid, p3n, p3->valid); |
| 347 |
> |
p2->valid, p2->valid, p2n, |
| 348 |
> |
p1->valid, p1->valid, p1n, |
| 349 |
> |
p3->valid, p3->valid, p3n); |
| 350 |
|
return; |
| 351 |
|
} |
| 352 |
|
/* compute normal interpolation */ |
