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

# User Rev Content
1 greg 2.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 greg 2.3 * Also, texture map indices only work for triangles, though
13 greg 2.1 * I'm not sure they work correctly.
14     */
15    
16     #include "standard.h"
17    
18 greg 2.3 #include "trans.h"
19    
20 greg 2.1 #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 greg 2.3 #define DEFOBJ "unnamed" /* default object name */
27     #define DEFMAT "white" /* default material name */
28 greg 2.1
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 greg 2.3 FLOAT (*vtlist)[2]; /* map vertex list */
38 greg 2.1 int nvts;
39    
40     typedef FLOAT BARYCCM[3][4]; /* barycentric coordinate system */
41    
42 greg 2.3 typedef int VNDX[3]; /* vertex index (point,map,normal) */
43 greg 2.1
44 greg 2.3 #define CHUNKSIZ 256 /* vertex allocation chunk size */
45 greg 2.1
46     #define MAXARG 64 /* maximum # arguments in a statement */
47    
48 greg 2.3 /* 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 greg 2.1
56 greg 2.3 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 greg 2.1 char matname[64]; /* current material name */
78 greg 2.3 char group[16][32]; /* current group names */
79 greg 2.1 char objname[128]; /* current object name */
80     int lineno; /* current line number */
81 greg 2.3 int faceno; /* number of faces read */
82 greg 2.1
83    
84 greg 2.3 main(argc, argv) /* read in .obj file and convert */
85 greg 2.1 int argc;
86     char *argv[];
87     {
88 greg 2.3 char *fname;
89 greg 2.1 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 greg 2.3 case 'n': /* just produce name list */
97     donames++;
98 greg 2.1 break;
99 greg 2.3 case 'm': /* use custom mapfile */
100     ourmapping = getmapping(argv[++i], &qlist);
101 greg 2.1 break;
102     default:
103 greg 2.3 goto userr;
104 greg 2.1 }
105 greg 2.3 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 greg 2.1 }
162 greg 2.3 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 greg 2.1 }
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 greg 2.3 mapname[0] = '\0';
194 greg 2.1 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 greg 2.3 case 't': /* texture map */
219 greg 2.1 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 greg 2.3 faceno++;
233 greg 2.1 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 greg 2.3 mapname[0] = '\0';
262 greg 2.1 else
263 greg 2.3 strcpy(mapname, argv[1]);
264 greg 2.1 } 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 greg 2.3 strcpy(group[i-1], argv[i]);
279     group[i-1][0] = '\0';
280 greg 2.1 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 greg 2.2 printf("\n# Done processing file: %s\n", fname);
291 greg 2.1 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 greg 2.3
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 greg 2.1 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 greg 2.3 /* get map */
437 greg 2.1 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 greg 2.3 char *mod;
474 greg 2.1
475 greg 2.3 if ((mod = getmtl()) == NULL)
476     return(-1);
477     printf("\n%s polygon %s.%d\n", mod, getonm(), faceno);
478 greg 2.1 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 greg 2.3 char *mod;
492 greg 2.1 VNDX v1i, v2i, v3i;
493     BARYCCM bvecs;
494 greg 2.2 int texOK, patOK;
495 greg 2.1
496 greg 2.3 if ((mod = getmtl()) == NULL)
497     return(-1);
498    
499 greg 2.1 if (!cvtndx(v1i, v1) || !cvtndx(v2i, v2) || !cvtndx(v3i, v3))
500     return(0);
501     /* compute barycentric coordinates */
502 greg 2.2 texOK = (v1i[2]>=0 && v2i[2]>=0 && v3i[2]>=0);
503 greg 2.3 patOK = mapname[0] && (v1i[1]>=0 && v2i[1]>=0 && v3i[1]>=0);
504 greg 2.2 if (texOK | patOK)
505 greg 2.1 if (comp_baryc(bvecs, vlist[v1i[0]], vlist[v2i[0]],
506     vlist[v3i[0]]) < 0)
507 greg 2.2 return(-1);
508 greg 2.1 /* put out texture (if any) */
509 greg 2.2 if (texOK) {
510 greg 2.1 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 greg 2.2 if (patOK) {
527 greg 2.1 printf("\n%s colorpict %s\n", mod, PATNAME);
528     mod = PATNAME;
529 greg 2.3 printf("7 noneg noneg noneg %s %s u v\n", mapname, TCALNAME);
530 greg 2.1 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 greg 2.3 printf("\n%s polygon %s.%d\n", mod, getonm(), faceno);
539 greg 2.1 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 greg 2.3 char *mod, *name;
604 greg 2.1 int axis;
605     FVECT v1, v2, vc1, vc2;
606     int ok1, ok2;
607 greg 2.3
608     if ((mod = getmtl()) == NULL)
609     return(-1);
610     name = getonm();
611 greg 2.1 /* 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 greg 2.2 return(-1);
626 greg 2.1 /* 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 greg 2.3 printf("\n%s ", mod);
632 greg 2.1 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 greg 2.3 printf("polygon %s.%d\n", name, faceno);
645 greg 2.1 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 greg 2.3 printf("\n%s ", mod);
655 greg 2.1 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 greg 2.3 printf("polygon %s.%da\n", name, faceno);
667 greg 2.1 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 greg 2.3 printf("\n%s ", mod);
674 greg 2.1 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 greg 2.3 printf("polygon %s.%db\n", name, faceno);
686 greg 2.1 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 greg 2.3 newvt(x, y) /* create a new texture map vertex */
820 greg 2.1 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 greg 2.3 /* assign new vertex */
836 greg 2.1 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     }