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.4 by greg, Wed Apr 13 15:16:49 1994 UTC vs.
Revision 2.6 by greg, Thu Apr 14 04:29:10 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.
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.
14   */
# Line 69 | Line 69 | 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 */
72  
73   char    *getmtl(), *getonm();
74  
# Line 77 | Line 76 | char   mapname[128];           /* current picture file */
76   char    matname[64];            /* current material name */
77   char    group[16][32];          /* current group names */
78   char    objname[128];           /* current object name */
79 + char    *inpfile;               /* input file name */
80   int     lineno;                 /* current line number */
81 < int     faceno;                 /* number of faces read */
81 > int     faceno;                 /* current face number */
82  
83  
84   main(argc, argv)                /* read in .obj file and convert */
85   int     argc;
86   char    *argv[];
87   {
88 <        char    *fname;
88 >        int     donames = 0;
89          int     i;
90  
91          for (i = 1; i < argc && argv[i][0] == '-'; i++)
# Line 105 | Line 105 | char   *argv[];
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);
108 >                inpfile = "<stdin>";
109 >        else if (freopen(inpfile=argv[i], "r", stdin) == NULL) {
110 >                fprintf(stderr, "%s: cannot open\n", inpfile);
111                  exit(1);
112          }
113          if (donames) {                          /* scan for ids */
114                  getnames(stdin);
115 <                printf("filename \"%s\"\n", fname);
115 >                printf("filename \"%s\"\n", inpfile);
116                  printf("filetype \"Wavefront\"\n");
117                  write_quals(&qlist, qual, stdout);
118                  printf("qualifier %s begin\n", qlist.qual[Q_FAC]);
# Line 121 | Line 121 | char   *argv[];
121          } else {                                /* translate file */
122                  printf("# ");
123                  printargs(argc, argv, stdout);
124 <                convert(fname, stdin);
124 >                convert(stdin);
125          }
126          exit(0);
127   userr:
# Line 180 | Line 180 | FILE   *fp;
180   }
181  
182  
183 < convert(fname, fp)              /* convert a T-mesh */
184 < char    *fname;
183 > convert(fp)                     /* convert a T-mesh */
184   FILE    *fp;
185   {
186          char    *argv[MAXARG];
187          int     argc;
188          int     nstats, nunknown;
189          register int    i;
190 <                                        /* start fresh */
192 <        freeverts();
193 <        mapname[0] = '\0';
194 <        strcpy(matname, defmat);
195 <        strcpy(objname, defobj);
196 <        lineno = 0;
190 >
191          nstats = nunknown = 0;
192                                          /* scan until EOF */
193          while (argc = getstmt(argv, fp)) {
# Line 202 | Line 196 | FILE   *fp;
196                          switch (argv[0][1]) {
197                          case '\0':                      /* point */
198                                  if (badarg(argc-1,argv+1,"fff"))
199 <                                        syntax(fname, lineno, "Bad vertex");
199 >                                        syntax("Bad vertex");
200                                  newv(atof(argv[1]), atof(argv[2]),
201                                                  atof(argv[3]));
202                                  break;
# Line 210 | Line 204 | FILE   *fp;
204                                  if (argv[0][2])
205                                          goto unknown;
206                                  if (badarg(argc-1,argv+1,"fff"))
207 <                                        syntax(fname, lineno, "Bad normal");
207 >                                        syntax("Bad normal");
208                                  if (!newvn(atof(argv[1]), atof(argv[2]),
209                                                  atof(argv[3])))
210 <                                        syntax(fname, lineno, "Zero normal");
210 >                                        syntax("Zero normal");
211                                  break;
212                          case 't':                       /* texture map */
213                                  if (argv[0][2])
# Line 232 | Line 226 | FILE   *fp;
226                          faceno++;
227                          switch (argc-1) {
228                          case 0: case 1: case 2:
229 <                                syntax(fname, lineno, "Too few vertices");
229 >                                syntax("Too few vertices");
230                                  break;
231                          case 3:
232                                  if (!puttri(argv[1], argv[2], argv[3]))
233 <                                        syntax(fname, lineno, "Bad triangle");
233 >                                        syntax("Bad triangle");
234                                  break;
235                          case 4:
236                                  if (!putquad(argv[1], argv[2],
237                                                  argv[3], argv[4]))
238 <                                        syntax(fname, lineno, "Bad quad");
238 >                                        syntax("Bad quad");
239                                  break;
240                          default:
241                                  if (!putface(argc-1, argv+1))
242 <                                        syntax(fname, lineno, "Bad face");
242 >                                        syntax("Bad face");
243                                  break;
244                          }
245                          break;
# Line 287 | Line 281 | FILE   *fp;
281                  }
282                  nstats++;
283          }
284 <        printf("\n# Done processing file: %s\n", fname);
284 >        printf("\n# Done processing file: %s\n", inpfile);
285          printf("# %d lines, %d statements, %d unrecognized\n",
286                          lineno, nstats, nunknown);
287   }
# Line 332 | Line 326 | getmtl()                               /* figure material for this face */
326   {
327          register RULEHD *rp = ourmapping;
328  
329 <        if (rp == NULL)                 /* no rule set */
330 <                return(matname);
329 >        if (rp == NULL) {               /* no rule set */
330 >                if (matname[0])
331 >                        return(matname);
332 >                if (group[0][0])
333 >                        return(group[0]);
334 >                return(defmat);
335 >        }
336                                          /* check for match */
337          do {
338                  if (matchrule(rp)) {
# Line 354 | Line 353 | getonm()                               /* invent a good name for object */
353          static char     name[64];
354          register char   *cp1, *cp2;
355          register int    i;
356 <
357 <        if (!group[0][0] || strcmp(objname, DEFOBJ))
358 <                return(objname);        /* good enough for us */
359 <
356 >                                        /* check for preset */
357 >        if (objname[0])
358 >                return(objname);
359 >        if (!group[0][0])
360 >                return(defobj);
361          cp1 = name;                     /* else make name out of groups */
362          for (i = 0; group[i][0]; i++) {
363                  cp2 = group[i];
# Line 381 | Line 381 | register RULEHD        *rp;
381          register int    i;
382  
383          if (rp->qflg & FL(Q_MTL)) {
384 +                if (!matname[0])
385 +                        return(0);
386                  tmpid.number = 0;
387                  tmpid.name = matname;
388                  if (!matchid(&tmpid, &idm(rp)[Q_MTL]))
389                          return(0);
390          }
391          if (rp->qflg & FL(Q_MAP)) {
392 +                if (!mapname[0])
393 +                        return(0);
394                  tmpid.number = 0;
395                  tmpid.name = mapname;
396                  if (!matchid(&tmpid, &idm(rp)[Q_MAP]))
# Line 403 | Line 407 | register RULEHD        *rp;
407                          return(0);
408          }
409          if (rp->qflg & FL(Q_OBJ)) {
410 +                if (!objname[0])
411 +                        return(0);
412                  tmpid.number = 0;
413                  tmpid.name = objname;
414                  if (!matchid(&tmpid, &idm(rp)[Q_OBJ]))
# Line 465 | Line 471 | register char  *vs;
471   }
472  
473  
474 < putface(ac, av)                         /* put out an N-sided polygon */
474 > nonplanar(ac, av)                       /* are vertices are non-planar? */
475   register int    ac;
476   register char   **av;
477   {
478          VNDX    vi;
479 +        FLOAT   *p0, *p1;
480 +        FVECT   v1, v2, nsum, newn;
481 +        double  d;
482 +        register int    i;
483 +
484 +        if (!cvtndx(vi, av[0]))
485 +                return(0);
486 +        if (vi[2] >= 0)
487 +                return(1);              /* has interpolated normals */
488 +        if (ac < 4)
489 +                return(0);              /* it's a triangle! */
490 +                                        /* set up */
491 +        p0 = vlist[vi[0]];
492 +        if (!cvtndx(vi, av[1]))
493 +                return(0);              /* error gets caught later */
494 +        nsum[0] = nsum[1] = nsum[2] = 0.;
495 +        p1 = vlist[vi[0]];
496 +        fvsum(v2, p1, p0, -1.0);
497 +        for (i = 2; i < ac; i++) {
498 +                VCOPY(v1, v2);
499 +                if (!cvtndx(vi, av[i]))
500 +                        return(0);
501 +                p1 = vlist[vi[0]];
502 +                fvsum(v2, p1, p0, -1.0);
503 +                fcross(newn, v1, v2);
504 +                if (normalize(newn) == 0.0) {
505 +                        if (i < 3)
506 +                                return(1);      /* can't deal with this */
507 +                        fvsum(nsum, nsum, nsum, 1./(i-2));
508 +                        continue;
509 +                }
510 +                d = fdot(newn,nsum);
511 +                if (d >= 0) {
512 +                        if (d < (1.0-FTINY)*(i-2))
513 +                                return(1);
514 +                        fvsum(nsum, nsum, newn, 1.0);
515 +                } else {
516 +                        if (d > -(1.0-FTINY)*(i-2))
517 +                                return(1);
518 +                        fvsum(nsum, nsum, newn, -1.0);
519 +                }
520 +        }
521 +        return(0);
522 + }
523 +
524 +
525 + putface(ac, av)                         /* put out an N-sided polygon */
526 + int     ac;
527 + register char   **av;
528 + {
529 +        VNDX    vi;
530          char    *mod;
531 +        register int    i;
532  
533 +        if (nonplanar(ac, av)) {        /* break into quads and triangles */
534 +                while (ac > 3) {
535 +                        if (!putquad(av[0], av[1], av[2], av[3]))
536 +                                return(0);
537 +                                        /* remove two vertices & rotate */
538 +                        av[ac -= 2] = av[0];
539 +                        for (i = 0; i <= ac; i++)
540 +                                av[i] = av[i+2];
541 +                }
542 +                if (ac == 3 && !puttri(av[0], av[1], av[2]))
543 +                        return(0);
544 +                return(1);
545 +        }
546          if ((mod = getmtl()) == NULL)
547                  return(-1);
548          printf("\n%s polygon %s.%d\n", mod, getonm(), faceno);
549          printf("0\n0\n%d\n", 3*ac);
550 <        while (ac--) {
551 <                if (!cvtndx(vi, *av++))
550 >        for (i = 0; i < ac; i++) {
551 >                if (!cvtndx(vi, av[i]))
552                          return(0);
553                  pvect(vlist[vi[0]]);
554          }
# Line 627 | Line 698 | char  *p0, *p1, *p3, *p2;              /* names correspond to bina
698          axis = norminterp(norm, p0i, p1i, p2i, p3i);
699  
700                                          /* put out quadrilateral? */
701 <        if (ok1 & ok2 && fdot(vc1,vc2) >= 1.0-FTINY*FTINY) {
701 >        if (ok1 & ok2 && fabs(fdot(vc1,vc2)) >= 1.0-FTINY) {
702                  printf("\n%s ", mod);
703                  if (axis != -1) {
704                          printf("texfunc %s\n", TEXNAME);
# Line 839 | Line 910 | double x, y;
910   }
911  
912  
913 < syntax(fn, ln, er)                      /* report syntax error and exit */
843 < char    *fn;
844 < int     ln;
913 > syntax(er)                      /* report syntax error and exit */
914   char    *er;
915   {
916          fprintf(stderr, "%s: Wavefront syntax error near line %d: %s\n",
917 <                        fn, ln, er);
917 >                        inpfile, lineno, er);
918          exit(1);
919   }

Diff Legend

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