ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/cv/obj2rad.c
(Generate patch)

Comparing ray/src/cv/obj2rad.c (file contents):
Revision 2.1 by greg, Tue Apr 12 17:12:42 1994 UTC vs.
Revision 2.9 by greg, Wed Jun 15 09:51:31 1994 UTC

# Line 7 | Line 7 | static char SCCSid[] = "$SunId$ LBL";
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 indices only work for triangles, though
13 < * I'm not sure they work correctly.
10 > * Currently, we support only polygonal geometry.  Non-planar
11 > * faces are broken rather haphazardly into triangles.
12 > * Also, texture map indices only work for triangles, though
13 > * I'm not sure they work correctly.  (Taken out -- see TEXMAPS defines.)
14   */
15  
16   #include "standard.h"
17  
18 + #include "trans.h"
19 +
20   #include <ctype.h>
21  
20 – #define VOIDID          "void"          /* this is defined in object.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  
# Line 32 | Line 34 | 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];           /* texture vertex list */
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,texture,normal) */
42 > typedef int     VNDX[3];        /* vertex index (point,map,normal) */
43  
44 < #define CHUNKSIZ        128     /* vertex allocation chunk size */
44 > #define CHUNKSIZ        256     /* vertex allocation chunk size */
45  
46   #define MAXARG          64      /* maximum # arguments in a statement */
47  
48 < char    *defmat = VOIDID;       /* default (starting) material name */
49 < char    *defpat = "";           /* default (starting) picture name */
50 < char    *defobj = "F";          /* default (starting) object name */
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    picfile[128];           /* current picture file */
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 >
73 > int     flatten = 0;            /* discard surface normal information */
74 >
75 > char    *getmtl(), *getonm();
76 >
77 > char    mapname[128];           /* current picture file */
78   char    matname[64];            /* current material name */
79 + char    group[16][32];          /* current group names */
80   char    objname[128];           /* current object name */
81 + char    *inpfile;               /* input file name */
82   int     lineno;                 /* current line number */
83 + int     faceno;                 /* current face number */
84  
55 – int     nfaces;                 /* total number of faces output */
85  
86 <
58 < main(argc, argv)                /* read in T-mesh files and convert */
86 > main(argc, argv)                /* read in .obj file and convert */
87   int     argc;
88   char    *argv[];
89   {
90 <        FILE    *fp;
90 >        int     donames = 0;
91          int     i;
92  
93          for (i = 1; i < argc && argv[i][0] == '-'; i++)
# Line 67 | Line 95 | char   *argv[];
95                  case 'o':               /* object name */
96                          defobj = argv[++i];
97                          break;
98 <                case 'm':               /* default material */
99 <                        defmat = argv[++i];
98 >                case 'n':               /* just produce name list */
99 >                        donames++;
100                          break;
101 <                case 'p':               /* default picture */
102 <                        defpat = argv[++i];
101 >                case 'm':               /* use custom mapfile */
102 >                        ourmapping = getmapping(argv[++i], &qlist);
103                          break;
104 +                case 'f':               /* flatten surfaces */
105 +                        flatten++;
106 +                        break;
107                  default:
108 <                        fprintf(stderr,
78 <                        "Usage: %s [-o obj][-m mat][-p pic] [file ..]\n",
79 <                                        argv[0]);
80 <                        exit(1);
108 >                        goto userr;
109                  }
110 <        if (i >= argc)
111 <                convert("<stdin>", stdin);
112 <        else
113 <                for ( ; i < argc; i++) {
114 <                        if ((fp = fopen(argv[i], "r")) == NULL) {
115 <                                perror(argv[i]);
116 <                                exit(1);
110 >        if (i > argc | i < argc-1)
111 >                goto userr;
112 >        if (i == argc)
113 >                inpfile = "<stdin>";
114 >        else if (freopen(inpfile=argv[i], "r", stdin) == NULL) {
115 >                fprintf(stderr, "%s: cannot open\n", inpfile);
116 >                exit(1);
117 >        }
118 >        if (donames) {                          /* scan for ids */
119 >                getnames(stdin);
120 >                printf("filename \"%s\"\n", inpfile);
121 >                printf("filetype \"Wavefront\"\n");
122 >                write_quals(&qlist, qual, stdout);
123 >                printf("qualifier %s begin\n", qlist.qual[Q_FAC]);
124 >                printf("[%d:%d]\n", 1, faceno);
125 >                printf("end\n");
126 >        } else {                                /* translate file */
127 >                printf("# ");
128 >                printargs(argc, argv, stdout);
129 >                convert(stdin);
130 >        }
131 >        exit(0);
132 > userr:
133 >        fprintf(stderr, "Usage: %s [-o obj][-m mapping][-n][-f] [file.obj]\n",
134 >                        argv[0]);
135 >        exit(1);
136 > }
137 >
138 >
139 > getnames(fp)                    /* get valid qualifier names */
140 > FILE    *fp;
141 > {
142 >        char    *argv[MAXARG];
143 >        int     argc;
144 >        ID      tmpid;
145 >        register int    i;
146 >
147 >        while (argc = getstmt(argv, fp))
148 >                switch (argv[0][0]) {
149 >                case 'f':                               /* face */
150 >                        if (!argv[0][1])
151 >                                faceno++;
152 >                        break;
153 >                case 'u':
154 >                        if (!strcmp(argv[0], "usemtl")) {       /* material */
155 >                                if (argc < 2)
156 >                                        break;          /* not fatal */
157 >                                tmpid.number = 0;
158 >                                tmpid.name = argv[1];
159 >                                findid(&qual[Q_MTL], &tmpid, 1);
160 >                        } else if (!strcmp(argv[0], "usemap")) {/* map */
161 >                                if (argc < 2 || !strcmp(argv[1], "off"))
162 >                                        break;          /* not fatal */
163 >                                tmpid.number = 0;
164 >                                tmpid.name = argv[1];
165 >                                findid(&qual[Q_MAP], &tmpid, 1);
166                          }
167 <                        convert(argv[i], fp);
168 <                        fclose(fp);
167 >                        break;
168 >                case 'o':               /* object name */
169 >                        if (argv[0][1] || argc < 2)
170 >                                break;
171 >                        tmpid.number = 0;
172 >                        tmpid.name = argv[1];
173 >                        findid(&qual[Q_OBJ], &tmpid, 1);
174 >                        break;
175 >                case 'g':               /* group name(s) */
176 >                        if (argv[0][1])
177 >                                break;
178 >                        tmpid.number = 0;
179 >                        for (i = 1; i < argc; i++) {
180 >                                tmpid.name = argv[i];
181 >                                findid(&qual[Q_GRP], &tmpid, 1);
182 >                        }
183 >                        break;
184                  }
93 –        exit(0);
185   }
186  
187  
188 < convert(fname, fp)              /* convert a T-mesh */
98 < char    *fname;
188 > convert(fp)                     /* convert a T-mesh */
189   FILE    *fp;
190   {
191          char    *argv[MAXARG];
192          int     argc;
193          int     nstats, nunknown;
194          register int    i;
105 –                                        /* start fresh */
106 –        freeverts();
107 –        strcpy(picfile, defpat);
108 –        strcpy(matname, defmat);
109 –        strcpy(objname, defobj);
110 –        lineno = 0;
111 –        nstats = nunknown = 0;
195  
196 <        printf("\n# Wavefront file read from: %s\n", fname);
196 >        nstats = nunknown = 0;
197                                          /* scan until EOF */
198          while (argc = getstmt(argv, fp)) {
199                  switch (argv[0][0]) {
# Line 118 | Line 201 | FILE   *fp;
201                          switch (argv[0][1]) {
202                          case '\0':                      /* point */
203                                  if (badarg(argc-1,argv+1,"fff"))
204 <                                        syntax(fname, lineno, "Bad vertex");
204 >                                        syntax("Bad vertex");
205                                  newv(atof(argv[1]), atof(argv[2]),
206                                                  atof(argv[3]));
207                                  break;
# Line 126 | Line 209 | FILE   *fp;
209                                  if (argv[0][2])
210                                          goto unknown;
211                                  if (badarg(argc-1,argv+1,"fff"))
212 <                                        syntax(fname, lineno, "Bad normal");
212 >                                        syntax("Bad normal");
213                                  if (!newvn(atof(argv[1]), atof(argv[2]),
214                                                  atof(argv[3])))
215 <                                        syntax(fname, lineno, "Zero normal");
215 >                                        syntax("Zero normal");
216                                  break;
217 <                        case 't':                       /* texture */
217 >                        case 't':                       /* texture map */
218                                  if (argv[0][2])
219                                          goto unknown;
220                                  if (badarg(argc-1,argv+1,"ff"))
# Line 145 | Line 228 | FILE   *fp;
228                  case 'f':                               /* face */
229                          if (argv[0][1])
230                                  goto unknown;
231 +                        faceno++;
232                          switch (argc-1) {
233                          case 0: case 1: case 2:
234 <                                syntax(fname, lineno, "Too few vertices");
234 >                                syntax("Too few vertices");
235                                  break;
236                          case 3:
237                                  if (!puttri(argv[1], argv[2], argv[3]))
238 <                                        syntax(fname, lineno, "Bad triangle");
238 >                                        syntax("Bad triangle");
239                                  break;
240                          case 4:
241                                  if (!putquad(argv[1], argv[2],
242                                                  argv[3], argv[4]))
243 <                                        syntax(fname, lineno, "Bad quad");
243 >                                        syntax("Bad quad");
244                                  break;
245                          default:
246                                  if (!putface(argc-1, argv+1))
247 <                                        syntax(fname, lineno, "Bad face");
247 >                                        syntax("Bad face");
248                                  break;
249                          }
250                          break;
# Line 173 | Line 257 | FILE   *fp;
257                                  if (argc < 2)
258                                          break;          /* not fatal */
259                                  if (!strcmp(argv[1], "off"))
260 <                                        picfile[0] = '\0';
260 >                                        mapname[0] = '\0';
261                                  else
262 <                                        strcpy(picfile, argv[1]);
262 >                                        sprintf(mapname, "%s.pic", argv[1]);
263                          } else
264                                  goto unknown;
265                          break;
# Line 189 | Line 273 | FILE   *fp;
273                  case 'g':               /* group name(s) */
274                          if (argv[0][1])
275                                  goto unknown;
192 –                        if (argc < 2)
193 –                                break;          /* not fatal */
194 –                        objname[0] = '\0';
276                          for (i = 1; i < argc; i++)
277 <                                if (objname[0])
278 <                                        sprintf(objname+strlen(objname),
198 <                                                ".%s", argv[i]);
199 <                                else
200 <                                        strcpy(objname, argv[i]);
277 >                                strcpy(group[i-1], argv[i]);
278 >                        group[i-1][0] = '\0';
279                          break;
280                  case '#':               /* comment */
281 +                        printargs(argc, argv, stdout);
282                          break;
283                  default:;               /* something we don't deal with */
284                  unknown:
# Line 208 | Line 287 | FILE   *fp;
287                  }
288                  nstats++;
289          }
290 <        printf("# Done processing file: %s\n", fname);
290 >        printf("\n# Done processing file: %s\n", inpfile);
291          printf("# %d lines, %d statements, %d unrecognized\n",
292                          lineno, nstats, nunknown);
293   }
# Line 246 | Line 325 | FILE   *fp;
325  
326          return(i);
327   }
249 –                
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 +                if (matname[0])
337 +                        return(matname);
338 +                if (group[0][0])
339 +                        return(group[0]);
340 +                return(defmat);
341 +        }
342 +                                        /* check for match */
343 +        do {
344 +                if (matchrule(rp)) {
345 +                        if (!strcmp(rp->mnam, VOIDID))
346 +                                return(NULL);   /* match is null */
347 +                        return(rp->mnam);
348 +                }
349 +                rp = rp->next;
350 +        } while (rp != NULL);
351 +                                        /* no match found */
352 +        return(NULL);
353 + }
354 +
355 +
356 + char *
357 + getonm()                                /* invent a good name for object */
358 + {
359 +        static char     name[64];
360 +        register char   *cp1, *cp2;
361 +        register int    i;
362 +                                        /* check for preset */
363 +        if (objname[0])
364 +                return(objname);
365 +        if (!group[0][0])
366 +                return(defobj);
367 +        cp1 = name;                     /* else make name out of groups */
368 +        for (i = 0; group[i][0]; i++) {
369 +                cp2 = group[i];
370 +                if (cp1 > name)
371 +                        *cp1++ = '.';
372 +                while (*cp1 = *cp2++)
373 +                        if (++cp1 >= name+sizeof(name)-2) {
374 +                                *cp1 = '\0';
375 +                                return(name);
376 +                        }
377 +        }
378 +        return(name);
379 + }
380 +
381 +
382 + matchrule(rp)                           /* check for a match on this rule */
383 + register RULEHD *rp;
384 + {
385 +        ID      tmpid;
386 +        int     gotmatch;
387 +        register int    i;
388 +
389 +        if (rp->qflg & FL(Q_MTL)) {
390 +                if (!matname[0])
391 +                        return(0);
392 +                tmpid.number = 0;
393 +                tmpid.name = matname;
394 +                if (!matchid(&tmpid, &idm(rp)[Q_MTL]))
395 +                        return(0);
396 +        }
397 +        if (rp->qflg & FL(Q_MAP)) {
398 +                if (!mapname[0])
399 +                        return(0);
400 +                tmpid.number = 0;
401 +                tmpid.name = mapname;
402 +                if (!matchid(&tmpid, &idm(rp)[Q_MAP]))
403 +                        return(0);
404 +        }
405 +        if (rp->qflg & FL(Q_GRP)) {
406 +                tmpid.number = 0;
407 +                gotmatch = 0;
408 +                for (i = 0; group[i][0]; i++) {
409 +                        tmpid.name = group[i];
410 +                        gotmatch |= matchid(&tmpid, &idm(rp)[Q_GRP]);
411 +                }
412 +                if (!gotmatch)
413 +                        return(0);
414 +        }
415 +        if (rp->qflg & FL(Q_OBJ)) {
416 +                if (!objname[0])
417 +                        return(0);
418 +                tmpid.number = 0;
419 +                tmpid.name = objname;
420 +                if (!matchid(&tmpid, &idm(rp)[Q_OBJ]))
421 +                        return(0);
422 +        }
423 +        if (rp->qflg & FL(Q_FAC)) {
424 +                tmpid.name = NULL;
425 +                tmpid.number = faceno;
426 +                if (!matchid(&tmpid, &idm(rp)[Q_FAC]))
427 +                        return(0);
428 +        }
429 +        return(1);
430 + }
431 +
432 +
433   cvtndx(vi, vs)                          /* convert vertex string to index */
434   register VNDX   vi;
435   register char   *vs;
# Line 258 | Line 440 | register char  *vs;
440                  if (vi[0]-- > nvs)
441                          return(0);
442          } else if (vi[0] < 0) {
443 <                vi[0] = nvs + vi[0];
443 >                vi[0] += nvs;
444                  if (vi[0] < 0)
445                          return(0);
446          } else
447                  return(0);
448 <                                        /* get texture */
448 >                                        /* get map */
449          while (*vs)
450                  if (*vs++ == '/')
451                          break;
# Line 272 | Line 454 | register char  *vs;
454                  if (vi[1]-- > nvts)
455                          return(0);
456          } else if (vi[1] < 0) {
457 <                vi[1] = nvts + vi[1];
457 >                vi[1] += nvts;
458                  if (vi[1] < 0)
459                          return(0);
460          } else
# Line 286 | Line 468 | register char  *vs;
468                  if (vi[2]-- > nvns)
469                          return(0);
470          } else if (vi[2] < 0) {
471 <                vi[2] = nvns + vi[2];
471 >                vi[2] += nvns;
472                  if (vi[2] < 0)
473                          return(0);
474          } else
# Line 295 | Line 477 | register char  *vs;
477   }
478  
479  
480 < putface(ac, av)                         /* put out an N-sided polygon */
480 > nonplanar(ac, av)                       /* are vertices non-planar? */
481   register int    ac;
482   register char   **av;
483   {
484          VNDX    vi;
485 +        FLOAT   *p0, *p1;
486 +        FVECT   v1, v2, nsum, newn;
487 +        double  d;
488 +        register int    i;
489  
490 <        printf("\n%s polygon %s.%d\n", matname, objname, ++nfaces);
490 >        if (!cvtndx(vi, av[0]))
491 >                return(0);
492 >        if (vi[2] >= 0)
493 >                return(1);              /* has interpolated normals */
494 >        if (ac < 4)
495 >                return(0);              /* it's a triangle! */
496 >                                        /* set up */
497 >        p0 = vlist[vi[0]];
498 >        if (!cvtndx(vi, av[1]))
499 >                return(0);              /* error gets caught later */
500 >        nsum[0] = nsum[1] = nsum[2] = 0.;
501 >        p1 = vlist[vi[0]];
502 >        fvsum(v2, p1, p0, -1.0);
503 >        for (i = 2; i < ac; i++) {
504 >                VCOPY(v1, v2);
505 >                if (!cvtndx(vi, av[i]))
506 >                        return(0);
507 >                p1 = vlist[vi[0]];
508 >                fvsum(v2, p1, p0, -1.0);
509 >                fcross(newn, v1, v2);
510 >                if (normalize(newn) == 0.0) {
511 >                        if (i < 3)
512 >                                return(1);      /* can't deal with this */
513 >                        fvsum(nsum, nsum, nsum, 1./(i-2));
514 >                        continue;
515 >                }
516 >                d = fdot(newn,nsum);
517 >                if (d >= 0) {
518 >                        if (d < (1.0-FTINY)*(i-2))
519 >                                return(1);
520 >                        fvsum(nsum, nsum, newn, 1.0);
521 >                } else {
522 >                        if (d > -(1.0-FTINY)*(i-2))
523 >                                return(1);
524 >                        fvsum(nsum, nsum, newn, -1.0);
525 >                }
526 >        }
527 >        return(0);
528 > }
529 >
530 >
531 > putface(ac, av)                         /* put out an N-sided polygon */
532 > int     ac;
533 > register char   **av;
534 > {
535 >        VNDX    vi;
536 >        char    *cp;
537 >        register int    i;
538 >
539 >        if (nonplanar(ac, av)) {        /* break into quads and triangles */
540 >                while (ac > 3) {
541 >                        if (!putquad(av[0], av[1], av[2], av[3]))
542 >                                return(0);
543 >                        ac -= 2;        /* remove two vertices & rotate */
544 >                        cp = av[0];
545 >                        for (i = 0; i < ac-1; i++)
546 >                                av[i] = av[i+3];
547 >                        av[i] = cp;
548 >                }
549 >                if (ac == 3 && !puttri(av[0], av[1], av[2]))
550 >                        return(0);
551 >                return(1);
552 >        }
553 >        if ((cp = getmtl()) == NULL)
554 >                return(-1);
555 >        printf("\n%s polygon %s.%d\n", cp, getonm(), faceno);
556          printf("0\n0\n%d\n", 3*ac);
557 <        while (ac--) {
558 <                if (!cvtndx(vi, *av++))
557 >        for (i = 0; i < ac; i++) {
558 >                if (!cvtndx(vi, av[i]))
559                          return(0);
560                  pvect(vlist[vi[0]]);
561          }
# Line 315 | Line 566 | register char  **av;
566   puttri(v1, v2, v3)                      /* put out a triangle */
567   char    *v1, *v2, *v3;
568   {
569 <        char    *mod = matname;
569 >        char    *mod;
570          VNDX    v1i, v2i, v3i;
571          BARYCCM bvecs;
572 +        int     texOK, patOK;
573  
574 +        if ((mod = getmtl()) == NULL)
575 +                return(-1);
576 +
577          if (!cvtndx(v1i, v1) || !cvtndx(v2i, v2) || !cvtndx(v3i, v3))
578                  return(0);
579                                          /* compute barycentric coordinates */
580 <        if ((v1i[2]>=0&&v2i[2]>=0&&v3i[2]>=0) ||
581 <                        (v1i[1]>=0&&v2i[1]>=0&&v3i[1]>=0))
580 >        texOK = !flatten && (v1i[2]>=0 && v2i[2]>=0 && v3i[2]>=0);
581 > #ifdef TEXMAPS
582 >        patOK = mapname[0] && (v1i[1]>=0 && v2i[1]>=0 && v3i[1]>=0);
583 > #else
584 >        patOK = 0;
585 > #endif
586 >        if (texOK | patOK)
587                  if (comp_baryc(bvecs, vlist[v1i[0]], vlist[v2i[0]],
588                                  vlist[v3i[0]]) < 0)
589 <                        return(0);
589 >                        return(-1);
590                                          /* put out texture (if any) */
591 <        if (v1i[2]>=0 && v2i[2]>=0 && v3i[2]>=0) {
591 >        if (texOK) {
592                  printf("\n%s texfunc %s\n", mod, TEXNAME);
593                  mod = TEXNAME;
594                  printf("4 dx dy dz %s\n", TCALNAME);
# Line 344 | Line 604 | char   *v1, *v2, *v3;
604                                  vnlist[v1i[2]][2], vnlist[v2i[2]][2],
605                                  vnlist[v3i[2]][2]);
606          }
607 + #ifdef TEXMAPS
608                                          /* put out pattern (if any) */
609 <        if (picfile[0] && v1i[1]>=0 && v2i[1]>=0 && v3i[1]>=0) {
609 >        if (patOK) {
610                  printf("\n%s colorpict %s\n", mod, PATNAME);
611                  mod = PATNAME;
612 <                printf("7 noneg noneg noneg %s %s u v\n", picfile, TCALNAME);
612 >                printf("7 noneg noneg noneg %s %s u v\n", mapname, TCALNAME);
613                  printf("0\n18\n");
614                  put_baryc(bvecs);
615                  printf("\t%f %f %f\n", vtlist[v1i[1]][0],
# Line 356 | Line 617 | char   *v1, *v2, *v3;
617                  printf("\t%f %f %f\n", vtlist[v1i[1]][1],
618                                  vtlist[v2i[1]][1], vtlist[v3i[1]][1]);
619          }
620 + #endif
621                                          /* put out triangle */
622 <        printf("\n%s polygon %s.%d\n", matname, objname, ++nfaces);
622 >        printf("\n%s polygon %s.%d\n", mod, getonm(), faceno);
623          printf("0\n0\n9\n");
624          pvect(vlist[v1i[0]]);
625          pvect(vlist[v2i[0]]);
# Line 417 | Line 679 | register BARYCCM       bcm;
679   }
680  
681  
682 < putquad(p0, p1, p2, p3)                 /* put out a quadrilateral */
683 < char  *p0, *p1, *p2, *p3;
682 > putquad(p0, p1, p3, p2)                 /* put out a quadrilateral */
683 > char  *p0, *p1, *p3, *p2;               /* names correspond to binary pos. */
684   {
685          VNDX  p0i, p1i, p2i, p3i;
686          FVECT  norm[4];
687 +        char  *mod, *name;
688          int  axis;
689          FVECT  v1, v2, vc1, vc2;
690          int  ok1, ok2;
691 +
692 + #ifdef TEXMAPS
693 +        /* also should output texture index coordinates,
694 +         * which will require new .cal file
695 +         */
696 + #endif
697 +        if ((mod = getmtl()) == NULL)
698 +                return(-1);
699 +        name = getonm();
700                                          /* get actual indices */
701          if (!cvtndx(p0i,p0) || !cvtndx(p1i,p1) ||
702                          !cvtndx(p2i,p2) || !cvtndx(p3i,p3))
# Line 439 | Line 711 | char  *p0, *p1, *p2, *p3;
711          fcross(vc2, v1, v2);
712          ok2 = normalize(vc2) != 0.0;
713          if (!(ok1 | ok2))
714 <                return(0);
714 >                return(-1);
715                                          /* compute normal interpolation */
716          axis = norminterp(norm, p0i, p1i, p2i, p3i);
717  
718                                          /* put out quadrilateral? */
719 <        if (ok1 & ok2 && fdot(vc1,vc2) >= 1.0-FTINY*FTINY) {
720 <                printf("\n%s ", matname);
719 >        if (ok1 & ok2 && fabs(fdot(vc1,vc2)) >= 1.0-FTINY) {
720 >                printf("\n%s ", mod);
721                  if (axis != -1) {
722                          printf("texfunc %s\n", TEXNAME);
723                          printf("4 surf_dx surf_dy surf_dz %s\n", QCALNAME);
# Line 458 | Line 730 | char  *p0, *p1, *p2, *p3;
730                          pvect(v1);
731                          printf("\n%s ", TEXNAME);
732                  }
733 <                printf("polygon %s.%d\n", objname, ++nfaces);
733 >                printf("polygon %s.%d\n", name, faceno);
734                  printf("0\n0\n12\n");
735                  pvect(vlist[p0i[0]]);
736                  pvect(vlist[p1i[0]]);
# Line 468 | Line 740 | char  *p0, *p1, *p2, *p3;
740          }
741                                          /* put out triangles? */
742          if (ok1) {
743 <                printf("\n%s ", matname);
743 >                printf("\n%s ", mod);
744                  if (axis != -1) {
745                          printf("texfunc %s\n", TEXNAME);
746                          printf("4 surf_dx surf_dy surf_dz %s\n", QCALNAME);
# Line 480 | Line 752 | char  *p0, *p1, *p2, *p3;
752                          pvect(v1);
753                          printf("\n%s ", TEXNAME);
754                  }
755 <                printf("polygon %s.%d\n", objname, ++nfaces);
755 >                printf("polygon %s.%da\n", name, faceno);
756                  printf("0\n0\n9\n");
757                  pvect(vlist[p0i[0]]);
758                  pvect(vlist[p1i[0]]);
759                  pvect(vlist[p2i[0]]);
760          }
761          if (ok2) {
762 <                printf("\n%s ", matname);
762 >                printf("\n%s ", mod);
763                  if (axis != -1) {
764                          printf("texfunc %s\n", TEXNAME);
765                          printf("4 surf_dx surf_dy surf_dz %s\n", QCALNAME);
# Line 499 | Line 771 | char  *p0, *p1, *p2, *p3;
771                          pvect(v2);
772                          printf("\n%s ", TEXNAME);
773                  }
774 <                printf("polygon %s.%d\n", objname, ++nfaces);
774 >                printf("polygon %s.%db\n", name, faceno);
775                  printf("0\n0\n9\n");
776                  pvect(vlist[p2i[0]]);
777                  pvect(vlist[p1i[0]]);
# Line 522 | Line 794 | register VNDX  p0i, p1i, p2i, p3i;
794          FVECT  v1;
795          register int  i, j;
796  
797 <        if (!(p0i[2]>=0 && p1i[2]>=0 && p2i[2]>=0 && p3i[2]>=0))
797 > #ifdef TEXMAPS
798 >        /* also check for texture indices */
799 > #endif
800 >        if (flatten || !(p0i[2]>=0 && p1i[2]>=0 && p2i[2]>=0 && p3i[2]>=0))
801                  return(-1);
802                                          /* find dominant axis */
803          VCOPY(v1, vnlist[p0i[2]]);
# Line 558 | Line 833 | register VNDX  p0i, p1i, p2i, p3i;
833                                          eqnmat[j][1]*vnlist[p1i[2]][i] +
834                                          eqnmat[j][2]*vnlist[p2i[2]][i] +
835                                          eqnmat[j][3]*vnlist[p3i[2]][i];
836 + #ifdef TEXMAPS
837 +        /* compute result matrix for texture indices */
838 + #endif
839          return(ax);
840  
841   #undef u
# Line 633 | Line 911 | double x, y, z;
911  
912  
913   int
914 < newvt(x, y)                     /* create a new texture vertex */
914 > newvt(x, y)                     /* create a new texture map vertex */
915   double  x, y;
916   {
917          if (!(nvts%CHUNKSIZ)) {         /* allocate next block */
# Line 649 | Line 927 | double x, y;
927                          exit(1);
928                  }
929          }
930 <                                        /* assign new texture vertex */
930 >                                        /* assign new vertex */
931          vtlist[nvts][0] = x;
932          vtlist[nvts][1] = y;
933          return(++nvts);
934   }
935  
936  
937 < syntax(fn, ln, er)                      /* report syntax error and exit */
660 < char    *fn;
661 < int     ln;
937 > syntax(er)                      /* report syntax error and exit */
938   char    *er;
939   {
940          fprintf(stderr, "%s: Wavefront syntax error near line %d: %s\n",
941 <                        fn, ln, er);
941 >                        inpfile, lineno, er);
942          exit(1);
943   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines