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 */ |
590 |
|
|
591 |
|
|
592 |
|
double |
593 |
< |
l_hermite() |
593 |
> |
l_hermite(char *nm) |
594 |
|
{ |
595 |
|
double t; |
596 |
|
|
603 |
|
|
604 |
|
|
605 |
|
double |
606 |
< |
l_bezier() |
606 |
> |
l_bezier(char *nm) |
607 |
|
{ |
608 |
|
double t; |
609 |
|
|
616 |
|
|
617 |
|
|
618 |
|
double |
619 |
< |
l_bspline() |
619 |
> |
l_bspline(char *nm) |
620 |
|
{ |
621 |
|
double t; |
622 |
|
|