ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/cv/obj2rad.c
Revision: 2.3
Committed: Wed Apr 13 14:08:55 1994 UTC (29 years, 11 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.2: +242 -61 lines
Log Message:
added mapping file to obj2rad

File Contents

# Content
1 /* Copyright (c) 1994 Regents of the University of California */
2
3 #ifndef lint
4 static char SCCSid[] = "$SunId$ LBL";
5 #endif
6
7 /*
8 * Convert a Wavefront .obj file to Radiance format.
9 *
10 * Currently, we support only polygonal geometry, and faces
11 * must be either quads or triangles for smoothing to work.
12 * Also, texture map indices only work for triangles, though
13 * I'm not sure they work correctly.
14 */
15
16 #include "standard.h"
17
18 #include "trans.h"
19
20 #include <ctype.h>
21
22 #define TCALNAME "tmesh.cal" /* triangle interp. file */
23 #define QCALNAME "surf.cal" /* quad interp. file */
24 #define PATNAME "M-pat" /* mesh pattern name (reused) */
25 #define TEXNAME "M-nor" /* mesh texture name (reused) */
26 #define DEFOBJ "unnamed" /* default object name */
27 #define DEFMAT "white" /* default material name */
28
29 #define ABS(x) ((x)>=0 ? (x) : -(x))
30
31 #define pvect(v) printf("%18.12g %18.12g %18.12g\n",(v)[0],(v)[1],(v)[2])
32
33 FVECT *vlist; /* our vertex list */
34 int nvs; /* number of vertices in our list */
35 FVECT *vnlist; /* vertex normal list */
36 int nvns;
37 FLOAT (*vtlist)[2]; /* map vertex list */
38 int nvts;
39
40 typedef FLOAT BARYCCM[3][4]; /* barycentric coordinate system */
41
42 typedef int VNDX[3]; /* vertex index (point,map,normal) */
43
44 #define CHUNKSIZ 256 /* vertex allocation chunk size */
45
46 #define MAXARG 64 /* maximum # arguments in a statement */
47
48 /* qualifiers */
49 #define Q_MTL 0
50 #define Q_MAP 1
51 #define Q_GRP 2
52 #define Q_OBJ 3
53 #define Q_FAC 4
54 #define NQUALS 5
55
56 char *qname[NQUALS] = {
57 "Material",
58 "Map",
59 "Group",
60 "Object",
61 "Face",
62 };
63
64 QLIST qlist = {NQUALS, qname};
65 /* valid qualifier ids */
66 IDLIST qual[NQUALS];
67 /* mapping rules */
68 RULEHD *ourmapping = NULL;
69
70 char *defmat = DEFMAT; /* default (starting) material name */
71 char *defobj = DEFOBJ; /* default (starting) object name */
72 int donames = 0; /* only get qualifier names */
73
74 char *getmtl(), *getonm();
75
76 char mapname[128]; /* current picture file */
77 char matname[64]; /* current material name */
78 char group[16][32]; /* current group names */
79 char objname[128]; /* current object name */
80 int lineno; /* current line number */
81 int faceno; /* number of faces read */
82
83
84 main(argc, argv) /* read in .obj file and convert */
85 int argc;
86 char *argv[];
87 {
88 char *fname;
89 int i;
90
91 for (i = 1; i < argc && argv[i][0] == '-'; i++)
92 switch (argv[i][1]) {
93 case 'o': /* object name */
94 defobj = argv[++i];
95 break;
96 case 'n': /* just produce name list */
97 donames++;
98 break;
99 case 'm': /* use custom mapfile */
100 ourmapping = getmapping(argv[++i], &qlist);
101 break;
102 default:
103 goto userr;
104 }
105 if (i > argc | i < argc-1)
106 goto userr;
107 if (i == argc)
108 fname = "<stdin>";
109 else if (freopen(fname=argv[i], "r", stdin) == NULL) {
110 fprintf(stderr, "%s: cannot open\n", fname);
111 exit(1);
112 }
113 if (donames) { /* scan for ids */
114 getnames(stdin);
115 printf("filename \"%s\"\n", fname);
116 printf("filetype \"Wavefront\"\n");
117 write_quals(&qlist, qual, stdout);
118 printf("qualifier %s begin\n", qlist.qual[Q_FAC]);
119 printf("[%d:%d]\n", 1, faceno);
120 printf("end\n");
121 } else { /* translate file */
122 printf("# ");
123 printargs(argc, argv, stdout);
124 convert(fname, stdin);
125 }
126 exit(0);
127 userr:
128 fprintf(stderr, "Usage: %s [-o obj][-m mapping][-n] [file.obj]\n",
129 argv[0]);
130 exit(1);
131 }
132
133
134 getnames(fp) /* get valid qualifier names */
135 FILE *fp;
136 {
137 char *argv[MAXARG];
138 int argc;
139 ID tmpid;
140 register int i;
141
142 while (argc = getstmt(argv, fp))
143 switch (argv[0][0]) {
144 case 'f': /* face */
145 if (!argv[0][1])
146 faceno++;
147 break;
148 case 'u':
149 if (!strcmp(argv[0], "usemtl")) { /* material */
150 if (argc < 2)
151 break; /* not fatal */
152 tmpid.number = 0;
153 tmpid.name = argv[1];
154 findid(&qual[Q_MTL], &tmpid, 1);
155 } else if (!strcmp(argv[0], "usemap")) {/* map */
156 if (argc < 2 || !strcmp(argv[1], "off"))
157 break; /* not fatal */
158 tmpid.number = 0;
159 tmpid.name = argv[1];
160 findid(&qual[Q_MAP], &tmpid, 1);
161 }
162 break;
163 case 'o': /* object name */
164 if (argv[0][1] || argc < 2)
165 break;
166 tmpid.number = 0;
167 tmpid.name = argv[1];
168 findid(&qual[Q_OBJ], &tmpid, 1);
169 break;
170 case 'g': /* group name(s) */
171 if (argv[0][1])
172 break;
173 tmpid.number = 0;
174 for (i = 1; i < argc; i++) {
175 tmpid.name = argv[i];
176 findid(&qual[Q_GRP], &tmpid, 1);
177 }
178 break;
179 }
180 }
181
182
183 convert(fname, fp) /* convert a T-mesh */
184 char *fname;
185 FILE *fp;
186 {
187 char *argv[MAXARG];
188 int argc;
189 int nstats, nunknown;
190 register int i;
191 /* start fresh */
192 freeverts();
193 mapname[0] = '\0';
194 strcpy(matname, defmat);
195 strcpy(objname, defobj);
196 lineno = 0;
197 nstats = nunknown = 0;
198 /* scan until EOF */
199 while (argc = getstmt(argv, fp)) {
200 switch (argv[0][0]) {
201 case 'v': /* vertex */
202 switch (argv[0][1]) {
203 case '\0': /* point */
204 if (badarg(argc-1,argv+1,"fff"))
205 syntax(fname, lineno, "Bad vertex");
206 newv(atof(argv[1]), atof(argv[2]),
207 atof(argv[3]));
208 break;
209 case 'n': /* normal */
210 if (argv[0][2])
211 goto unknown;
212 if (badarg(argc-1,argv+1,"fff"))
213 syntax(fname, lineno, "Bad normal");
214 if (!newvn(atof(argv[1]), atof(argv[2]),
215 atof(argv[3])))
216 syntax(fname, lineno, "Zero normal");
217 break;
218 case 't': /* texture map */
219 if (argv[0][2])
220 goto unknown;
221 if (badarg(argc-1,argv+1,"ff"))
222 goto unknown;
223 newvt(atof(argv[1]), atof(argv[2]));
224 break;
225 default:
226 goto unknown;
227 }
228 break;
229 case 'f': /* face */
230 if (argv[0][1])
231 goto unknown;
232 faceno++;
233 switch (argc-1) {
234 case 0: case 1: case 2:
235 syntax(fname, lineno, "Too few vertices");
236 break;
237 case 3:
238 if (!puttri(argv[1], argv[2], argv[3]))
239 syntax(fname, lineno, "Bad triangle");
240 break;
241 case 4:
242 if (!putquad(argv[1], argv[2],
243 argv[3], argv[4]))
244 syntax(fname, lineno, "Bad quad");
245 break;
246 default:
247 if (!putface(argc-1, argv+1))
248 syntax(fname, lineno, "Bad face");
249 break;
250 }
251 break;
252 case 'u':
253 if (!strcmp(argv[0], "usemtl")) { /* material */
254 if (argc < 2)
255 break; /* not fatal */
256 strcpy(matname, argv[1]);
257 } else if (!strcmp(argv[0], "usemap")) {/* map */
258 if (argc < 2)
259 break; /* not fatal */
260 if (!strcmp(argv[1], "off"))
261 mapname[0] = '\0';
262 else
263 strcpy(mapname, argv[1]);
264 } else
265 goto unknown;
266 break;
267 case 'o': /* object name */
268 if (argv[0][1])
269 goto unknown;
270 if (argc < 2)
271 break; /* not fatal */
272 strcpy(objname, argv[1]);
273 break;
274 case 'g': /* group name(s) */
275 if (argv[0][1])
276 goto unknown;
277 for (i = 1; i < argc; i++)
278 strcpy(group[i-1], argv[i]);
279 group[i-1][0] = '\0';
280 break;
281 case '#': /* comment */
282 break;
283 default:; /* something we don't deal with */
284 unknown:
285 nunknown++;
286 break;
287 }
288 nstats++;
289 }
290 printf("\n# Done processing file: %s\n", fname);
291 printf("# %d lines, %d statements, %d unrecognized\n",
292 lineno, nstats, nunknown);
293 }
294
295
296 int
297 getstmt(av, fp) /* read the next statement from fp */
298 register char *av[MAXARG];
299 FILE *fp;
300 {
301 extern char *fgetline();
302 static char sbuf[MAXARG*10];
303 register char *cp;
304 register int i;
305
306 do {
307 if (fgetline(cp=sbuf, sizeof(sbuf), fp) == NULL)
308 return(0);
309 i = 0;
310 for ( ; ; ) {
311 while (isspace(*cp) || *cp == '\\') {
312 if (*cp == '\n')
313 lineno++;
314 *cp++ = '\0';
315 }
316 if (!*cp || i >= MAXARG-1)
317 break;
318 av[i++] = cp;
319 while (*++cp && !isspace(*cp))
320 ;
321 }
322 av[i] = NULL;
323 lineno++;
324 } while (!i);
325
326 return(i);
327 }
328
329
330 char *
331 getmtl() /* figure material for this face */
332 {
333 register RULEHD *rp = ourmapping;
334
335 if (rp == NULL) /* no rule set */
336 return(matname);
337 /* check for match */
338 do {
339 if (matchrule(rp)) {
340 if (!strcmp(rp->mnam, VOIDID))
341 return(NULL); /* match is null */
342 return(rp->mnam);
343 }
344 rp = rp->next;
345 } while (rp != NULL);
346 /* no match found */
347 return(NULL);
348 }
349
350
351 char *
352 getonm() /* invent a good name for object */
353 {
354 static char name[64];
355 register char *cp1, *cp2;
356 register int i;
357
358 if (!group[0][0] || strcmp(objname, DEFOBJ))
359 return(objname); /* good enough for us */
360
361 cp1 = name; /* else make name out of groups */
362 for (i = 0; group[i][0]; i++) {
363 cp2 = group[i];
364 if (cp1 > name)
365 *cp1++ = '.';
366 while (*cp1 = *cp2++)
367 if (++cp1 >= name+sizeof(name)-2) {
368 *cp1 = '\0';
369 return(name);
370 }
371 }
372 return(name);
373 }
374
375
376 matchrule(rp) /* check for a match on this rule */
377 register RULEHD *rp;
378 {
379 ID tmpid;
380 int gotmatch;
381 register int i;
382
383 if (rp->qflg & FL(Q_MTL)) {
384 tmpid.number = 0;
385 tmpid.name = matname;
386 if (!matchid(&tmpid, &idm(rp)[Q_MTL]))
387 return(0);
388 }
389 if (rp->qflg & FL(Q_MAP)) {
390 tmpid.number = 0;
391 tmpid.name = mapname;
392 if (!matchid(&tmpid, &idm(rp)[Q_MAP]))
393 return(0);
394 }
395 if (rp->qflg & FL(Q_GRP)) {
396 tmpid.number = 0;
397 gotmatch = 0;
398 for (i = 0; group[i][0]; i++) {
399 tmpid.name = group[i];
400 gotmatch |= matchid(&tmpid, &idm(rp)[Q_GRP]);
401 }
402 if (!gotmatch)
403 return(0);
404 }
405 if (rp->qflg & FL(Q_OBJ)) {
406 tmpid.number = 0;
407 tmpid.name = objname;
408 if (!matchid(&tmpid, &idm(rp)[Q_OBJ]))
409 return(0);
410 }
411 if (rp->qflg & FL(Q_FAC)) {
412 tmpid.name = NULL;
413 tmpid.number = faceno;
414 if (!matchid(&tmpid, &idm(rp)[Q_FAC]))
415 return(0);
416 }
417 return(1);
418 }
419
420
421 cvtndx(vi, vs) /* convert vertex string to index */
422 register VNDX vi;
423 register char *vs;
424 {
425 /* get point */
426 vi[0] = atoi(vs);
427 if (vi[0] > 0) {
428 if (vi[0]-- > nvs)
429 return(0);
430 } else if (vi[0] < 0) {
431 vi[0] = nvs + vi[0];
432 if (vi[0] < 0)
433 return(0);
434 } else
435 return(0);
436 /* get map */
437 while (*vs)
438 if (*vs++ == '/')
439 break;
440 vi[1] = atoi(vs);
441 if (vi[1] > 0) {
442 if (vi[1]-- > nvts)
443 return(0);
444 } else if (vi[1] < 0) {
445 vi[1] = nvts + vi[1];
446 if (vi[1] < 0)
447 return(0);
448 } else
449 vi[1] = -1;
450 /* get normal */
451 while (*vs)
452 if (*vs++ == '/')
453 break;
454 vi[2] = atoi(vs);
455 if (vi[2] > 0) {
456 if (vi[2]-- > nvns)
457 return(0);
458 } else if (vi[2] < 0) {
459 vi[2] = nvns + vi[2];
460 if (vi[2] < 0)
461 return(0);
462 } else
463 vi[2] = -1;
464 return(1);
465 }
466
467
468 putface(ac, av) /* put out an N-sided polygon */
469 register int ac;
470 register char **av;
471 {
472 VNDX vi;
473 char *mod;
474
475 if ((mod = getmtl()) == NULL)
476 return(-1);
477 printf("\n%s polygon %s.%d\n", mod, getonm(), faceno);
478 printf("0\n0\n%d\n", 3*ac);
479 while (ac--) {
480 if (!cvtndx(vi, *av++))
481 return(0);
482 pvect(vlist[vi[0]]);
483 }
484 return(1);
485 }
486
487
488 puttri(v1, v2, v3) /* put out a triangle */
489 char *v1, *v2, *v3;
490 {
491 char *mod;
492 VNDX v1i, v2i, v3i;
493 BARYCCM bvecs;
494 int texOK, patOK;
495
496 if ((mod = getmtl()) == NULL)
497 return(-1);
498
499 if (!cvtndx(v1i, v1) || !cvtndx(v2i, v2) || !cvtndx(v3i, v3))
500 return(0);
501 /* compute barycentric coordinates */
502 texOK = (v1i[2]>=0 && v2i[2]>=0 && v3i[2]>=0);
503 patOK = mapname[0] && (v1i[1]>=0 && v2i[1]>=0 && v3i[1]>=0);
504 if (texOK | patOK)
505 if (comp_baryc(bvecs, vlist[v1i[0]], vlist[v2i[0]],
506 vlist[v3i[0]]) < 0)
507 return(-1);
508 /* put out texture (if any) */
509 if (texOK) {
510 printf("\n%s texfunc %s\n", mod, TEXNAME);
511 mod = TEXNAME;
512 printf("4 dx dy dz %s\n", TCALNAME);
513 printf("0\n21\n");
514 put_baryc(bvecs);
515 printf("\t%14.12g %14.12g %14.12g\n",
516 vnlist[v1i[2]][0], vnlist[v2i[2]][0],
517 vnlist[v3i[2]][0]);
518 printf("\t%14.12g %14.12g %14.12g\n",
519 vnlist[v1i[2]][1], vnlist[v2i[2]][1],
520 vnlist[v3i[2]][1]);
521 printf("\t%14.12g %14.12g %14.12g\n",
522 vnlist[v1i[2]][2], vnlist[v2i[2]][2],
523 vnlist[v3i[2]][2]);
524 }
525 /* put out pattern (if any) */
526 if (patOK) {
527 printf("\n%s colorpict %s\n", mod, PATNAME);
528 mod = PATNAME;
529 printf("7 noneg noneg noneg %s %s u v\n", mapname, TCALNAME);
530 printf("0\n18\n");
531 put_baryc(bvecs);
532 printf("\t%f %f %f\n", vtlist[v1i[1]][0],
533 vtlist[v2i[1]][0], vtlist[v3i[1]][0]);
534 printf("\t%f %f %f\n", vtlist[v1i[1]][1],
535 vtlist[v2i[1]][1], vtlist[v3i[1]][1]);
536 }
537 /* put out triangle */
538 printf("\n%s polygon %s.%d\n", mod, getonm(), faceno);
539 printf("0\n0\n9\n");
540 pvect(vlist[v1i[0]]);
541 pvect(vlist[v2i[0]]);
542 pvect(vlist[v3i[0]]);
543
544 return(1);
545 }
546
547
548 int
549 comp_baryc(bcm, v1, v2, v3) /* compute barycentric vectors */
550 register BARYCCM bcm;
551 FLOAT *v1, *v2, *v3;
552 {
553 FLOAT *vt;
554 FVECT va, vab, vcb;
555 double d;
556 register int i, j;
557
558 for (j = 0; j < 3; j++) {
559 for (i = 0; i < 3; i++) {
560 vab[i] = v1[i] - v2[i];
561 vcb[i] = v3[i] - v2[i];
562 }
563 d = DOT(vcb,vcb);
564 if (d <= FTINY)
565 return(-1);
566 d = DOT(vcb,vab)/d;
567 for (i = 0; i < 3; i++)
568 va[i] = vab[i] - vcb[i]*d;
569 d = DOT(va,va);
570 if (d <= FTINY)
571 return(-1);
572 for (i = 0; i < 3; i++) {
573 va[i] /= d;
574 bcm[j][i] = va[i];
575 }
576 bcm[j][3] = -DOT(v2,va);
577 /* rotate vertices */
578 vt = v1;
579 v1 = v2;
580 v2 = v3;
581 v3 = vt;
582 }
583 return(0);
584 }
585
586
587 put_baryc(bcm) /* put barycentric coord. vectors */
588 register BARYCCM bcm;
589 {
590 register int i;
591
592 for (i = 0; i < 3; i++)
593 printf("%14.8f %14.8f %14.8f %14.8f\n",
594 bcm[i][0], bcm[i][1], bcm[i][2], bcm[i][3]);
595 }
596
597
598 putquad(p0, p1, p2, p3) /* put out a quadrilateral */
599 char *p0, *p1, *p2, *p3;
600 {
601 VNDX p0i, p1i, p2i, p3i;
602 FVECT norm[4];
603 char *mod, *name;
604 int axis;
605 FVECT v1, v2, vc1, vc2;
606 int ok1, ok2;
607
608 if ((mod = getmtl()) == NULL)
609 return(-1);
610 name = getonm();
611 /* get actual indices */
612 if (!cvtndx(p0i,p0) || !cvtndx(p1i,p1) ||
613 !cvtndx(p2i,p2) || !cvtndx(p3i,p3))
614 return(0);
615 /* compute exact normals */
616 fvsum(v1, vlist[p1i[0]], vlist[p0i[0]], -1.0);
617 fvsum(v2, vlist[p2i[0]], vlist[p0i[0]], -1.0);
618 fcross(vc1, v1, v2);
619 ok1 = normalize(vc1) != 0.0;
620 fvsum(v1, vlist[p2i[0]], vlist[p3i[0]], -1.0);
621 fvsum(v2, vlist[p1i[0]], vlist[p3i[0]], -1.0);
622 fcross(vc2, v1, v2);
623 ok2 = normalize(vc2) != 0.0;
624 if (!(ok1 | ok2))
625 return(-1);
626 /* compute normal interpolation */
627 axis = norminterp(norm, p0i, p1i, p2i, p3i);
628
629 /* put out quadrilateral? */
630 if (ok1 & ok2 && fdot(vc1,vc2) >= 1.0-FTINY*FTINY) {
631 printf("\n%s ", mod);
632 if (axis != -1) {
633 printf("texfunc %s\n", TEXNAME);
634 printf("4 surf_dx surf_dy surf_dz %s\n", QCALNAME);
635 printf("0\n13\t%d\n", axis);
636 pvect(norm[0]);
637 pvect(norm[1]);
638 pvect(norm[2]);
639 fvsum(v1, norm[3], vc1, -0.5);
640 fvsum(v1, v1, vc2, -0.5);
641 pvect(v1);
642 printf("\n%s ", TEXNAME);
643 }
644 printf("polygon %s.%d\n", name, faceno);
645 printf("0\n0\n12\n");
646 pvect(vlist[p0i[0]]);
647 pvect(vlist[p1i[0]]);
648 pvect(vlist[p3i[0]]);
649 pvect(vlist[p2i[0]]);
650 return(1);
651 }
652 /* put out triangles? */
653 if (ok1) {
654 printf("\n%s ", mod);
655 if (axis != -1) {
656 printf("texfunc %s\n", TEXNAME);
657 printf("4 surf_dx surf_dy surf_dz %s\n", QCALNAME);
658 printf("0\n13\t%d\n", axis);
659 pvect(norm[0]);
660 pvect(norm[1]);
661 pvect(norm[2]);
662 fvsum(v1, norm[3], vc1, -1.0);
663 pvect(v1);
664 printf("\n%s ", TEXNAME);
665 }
666 printf("polygon %s.%da\n", name, faceno);
667 printf("0\n0\n9\n");
668 pvect(vlist[p0i[0]]);
669 pvect(vlist[p1i[0]]);
670 pvect(vlist[p2i[0]]);
671 }
672 if (ok2) {
673 printf("\n%s ", mod);
674 if (axis != -1) {
675 printf("texfunc %s\n", TEXNAME);
676 printf("4 surf_dx surf_dy surf_dz %s\n", QCALNAME);
677 printf("0\n13\t%d\n", axis);
678 pvect(norm[0]);
679 pvect(norm[1]);
680 pvect(norm[2]);
681 fvsum(v2, norm[3], vc2, -1.0);
682 pvect(v2);
683 printf("\n%s ", TEXNAME);
684 }
685 printf("polygon %s.%db\n", name, faceno);
686 printf("0\n0\n9\n");
687 pvect(vlist[p2i[0]]);
688 pvect(vlist[p1i[0]]);
689 pvect(vlist[p3i[0]]);
690 }
691 return(1);
692 }
693
694
695 int
696 norminterp(resmat, p0i, p1i, p2i, p3i) /* compute normal interpolation */
697 register FVECT resmat[4];
698 register VNDX p0i, p1i, p2i, p3i;
699 {
700 #define u ((ax+1)%3)
701 #define v ((ax+2)%3)
702
703 register int ax;
704 MAT4 eqnmat;
705 FVECT v1;
706 register int i, j;
707
708 if (!(p0i[2]>=0 && p1i[2]>=0 && p2i[2]>=0 && p3i[2]>=0))
709 return(-1);
710 /* find dominant axis */
711 VCOPY(v1, vnlist[p0i[2]]);
712 fvsum(v1, v1, vnlist[p1i[2]], 1.0);
713 fvsum(v1, v1, vnlist[p2i[2]], 1.0);
714 fvsum(v1, v1, vnlist[p3i[2]], 1.0);
715 ax = ABS(v1[0]) > ABS(v1[1]) ? 0 : 1;
716 ax = ABS(v1[ax]) > ABS(v1[2]) ? ax : 2;
717 /* assign equation matrix */
718 eqnmat[0][0] = vlist[p0i[0]][u]*vlist[p0i[0]][v];
719 eqnmat[0][1] = vlist[p0i[0]][u];
720 eqnmat[0][2] = vlist[p0i[0]][v];
721 eqnmat[0][3] = 1.0;
722 eqnmat[1][0] = vlist[p1i[0]][u]*vlist[p1i[0]][v];
723 eqnmat[1][1] = vlist[p1i[0]][u];
724 eqnmat[1][2] = vlist[p1i[0]][v];
725 eqnmat[1][3] = 1.0;
726 eqnmat[2][0] = vlist[p2i[0]][u]*vlist[p2i[0]][v];
727 eqnmat[2][1] = vlist[p2i[0]][u];
728 eqnmat[2][2] = vlist[p2i[0]][v];
729 eqnmat[2][3] = 1.0;
730 eqnmat[3][0] = vlist[p3i[0]][u]*vlist[p3i[0]][v];
731 eqnmat[3][1] = vlist[p3i[0]][u];
732 eqnmat[3][2] = vlist[p3i[0]][v];
733 eqnmat[3][3] = 1.0;
734 /* invert matrix (solve system) */
735 if (!invmat4(eqnmat, eqnmat))
736 return(-1); /* no solution */
737 /* compute result matrix */
738 for (j = 0; j < 4; j++)
739 for (i = 0; i < 3; i++)
740 resmat[j][i] = eqnmat[j][0]*vnlist[p0i[2]][i] +
741 eqnmat[j][1]*vnlist[p1i[2]][i] +
742 eqnmat[j][2]*vnlist[p2i[2]][i] +
743 eqnmat[j][3]*vnlist[p3i[2]][i];
744 return(ax);
745
746 #undef u
747 #undef v
748 }
749
750
751 freeverts() /* free all vertices */
752 {
753 if (nvs) {
754 free((char *)vlist);
755 nvs = 0;
756 }
757 if (nvts) {
758 free((char *)vtlist);
759 nvts = 0;
760 }
761 if (nvns) {
762 free((char *)vnlist);
763 nvns = 0;
764 }
765 }
766
767
768 int
769 newv(x, y, z) /* create a new vertex */
770 double x, y, z;
771 {
772 if (!(nvs%CHUNKSIZ)) { /* allocate next block */
773 if (nvs == 0)
774 vlist = (FVECT *)malloc(CHUNKSIZ*sizeof(FVECT));
775 else
776 vlist = (FVECT *)realloc((char *)vlist,
777 (nvs+CHUNKSIZ)*sizeof(FVECT));
778 if (vlist == NULL) {
779 fprintf(stderr,
780 "Out of memory while allocating vertex %d\n", nvs);
781 exit(1);
782 }
783 }
784 /* assign new vertex */
785 vlist[nvs][0] = x;
786 vlist[nvs][1] = y;
787 vlist[nvs][2] = z;
788 return(++nvs);
789 }
790
791
792 int
793 newvn(x, y, z) /* create a new vertex normal */
794 double x, y, z;
795 {
796 if (!(nvns%CHUNKSIZ)) { /* allocate next block */
797 if (nvns == 0)
798 vnlist = (FVECT *)malloc(CHUNKSIZ*sizeof(FVECT));
799 else
800 vnlist = (FVECT *)realloc((char *)vnlist,
801 (nvns+CHUNKSIZ)*sizeof(FVECT));
802 if (vnlist == NULL) {
803 fprintf(stderr,
804 "Out of memory while allocating normal %d\n", nvns);
805 exit(1);
806 }
807 }
808 /* assign new normal */
809 vnlist[nvns][0] = x;
810 vnlist[nvns][1] = y;
811 vnlist[nvns][2] = z;
812 if (normalize(vnlist[nvns]) == 0.0)
813 return(0);
814 return(++nvns);
815 }
816
817
818 int
819 newvt(x, y) /* create a new texture map vertex */
820 double x, y;
821 {
822 if (!(nvts%CHUNKSIZ)) { /* allocate next block */
823 if (nvts == 0)
824 vtlist = (FLOAT (*)[2])malloc(CHUNKSIZ*2*sizeof(FLOAT));
825 else
826 vtlist = (FLOAT (*)[2])realloc((char *)vtlist,
827 (nvts+CHUNKSIZ)*2*sizeof(FLOAT));
828 if (vtlist == NULL) {
829 fprintf(stderr,
830 "Out of memory while allocating texture vertex %d\n",
831 nvts);
832 exit(1);
833 }
834 }
835 /* assign new vertex */
836 vtlist[nvts][0] = x;
837 vtlist[nvts][1] = y;
838 return(++nvts);
839 }
840
841
842 syntax(fn, ln, er) /* report syntax error and exit */
843 char *fn;
844 int ln;
845 char *er;
846 {
847 fprintf(stderr, "%s: Wavefront syntax error near line %d: %s\n",
848 fn, ln, er);
849 exit(1);
850 }