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

Comparing ray/src/ot/wfconv.c (file contents):
Revision 2.1 by greg, Tue Mar 11 17:08:55 2003 UTC vs.
Revision 2.7 by greg, Thu Jan 29 22:21:34 2004 UTC

# Line 11 | Line 11 | static const char RCSid[] = "$Id$";
11   #include "cvmesh.h"
12   #include <ctype.h>
13  
14 – FVECT   *vlist;                 /* our vertex list */
15 – int     nvs;                    /* number of vertices in our list */
16 – FVECT   *vnlist;                /* vertex normal list */
17 – int     nvns;
18 – FLOAT   (*vtlist)[2];           /* map vertex list */
19 – int     nvts;
20 –
14   typedef int     VNDX[3];        /* vertex index (point,map,normal) */
15  
16   #define CHUNKSIZ        1024    /* vertex allocation chunk size */
17  
18   #define MAXARG          64      /* maximum # arguments in a statement */
19  
20 < char    *inpfile;               /* input file name */
21 < int     lineno;                 /* current line number */
22 < int     faceno;                 /* current face number */
20 > static FVECT    *vlist;         /* our vertex list */
21 > static int      nvs;            /* number of vertices in our list */
22 > static FVECT    *vnlist;        /* vertex normal list */
23 > static int      nvns;
24 > static RREAL    (*vtlist)[2];   /* map vertex list */
25 > static int      nvts;
26  
27 + static char     *inpfile;       /* input file name */
28 + static int      havemats;       /* materials available? */
29 + static char     material[64];   /* current material name */
30 + static char     group[64];      /* current group name */
31 + static int      lineno;         /* current line number */
32 + static int      faceno;         /* current face number */
33  
34 + static int      getstmt();
35 + static int      cvtndx();
36 + static OBJECT   getmod();
37 + static int      putface();
38 + static int      puttri();
39 + static void     freeverts();
40 + static int      newv();
41 + static int      newvn();
42 + static int      newvt();
43 + static void     syntax();
44 +
45 +
46 + void
47   wfreadobj(objfn)                /* read in .OBJ file and convert */
48   char    *objfn;
49   {
# Line 45 | Line 60 | char   *objfn;
60                  sprintf(errmsg, "cannot open \"%s\"", inpfile);
61                  error(USER, errmsg);
62          }
63 +        havemats = (nobjects > 0);
64          nstats = nunknown = 0;
65 +        material[0] = '\0';
66 +        group[0] = '\0';
67          lineno = 0; faceno = 0;
68                                          /* scan until EOF */
69 <        while (argc = getstmt(argv, fp)) {
69 >        while ( (argc = getstmt(argv, fp)) ) {
70                  switch (argv[0][0]) {
71                  case 'v':               /* vertex */
72                          switch (argv[0][1]) {
73                          case '\0':                      /* point */
74                                  if (badarg(argc-1,argv+1,"fff"))
75 <                                        syntax("Bad vertex");
75 >                                        syntax("bad vertex");
76                                  newv(atof(argv[1]), atof(argv[2]),
77                                                  atof(argv[3]));
78                                  break;
# Line 62 | Line 80 | char   *objfn;
80                                  if (argv[0][2])
81                                          goto unknown;
82                                  if (badarg(argc-1,argv+1,"fff"))
83 <                                        syntax("Bad normal");
83 >                                        syntax("bad normal");
84                                  if (!newvn(atof(argv[1]), atof(argv[2]),
85                                                  atof(argv[3])))
86 <                                        syntax("Zero normal");
86 >                                        syntax("zero normal");
87                                  break;
88 <                        case 't':                       /* texture map */
88 >                        case 't':                       /* coordinate */
89                                  if (argv[0][2])
90                                          goto unknown;
91                                  if (badarg(argc-1,argv+1,"ff"))
# Line 84 | Line 102 | char   *objfn;
102                          faceno++;
103                          switch (argc-1) {
104                          case 0: case 1: case 2:
105 <                                syntax("Too few vertices");
105 >                                syntax("too few vertices");
106                                  break;
107                          case 3:
108                                  if (!puttri(argv[1], argv[2], argv[3]))
109 <                                        syntax("Bad triangle");
109 >                                        syntax("bad triangle");
110                                  break;
111                          default:
112                                  if (!putface(argc-1, argv+1))
113 <                                        syntax("Bad face");
113 >                                        syntax("bad face");
114                                  break;
115                          }
116                          break;
117 <                case 'u':
118 <                        if (strcmp(argv[0], "usemtl") &&
119 <                                        strcmp(argv[0], "usemap"))
117 >                case 'u':                               /* usemtl/usemap */
118 >                        if (!strcmp(argv[0], "usemap"))
119 >                                break;
120 >                        if (strcmp(argv[0], "usemtl"))
121                                  goto unknown;
122 +                        if (argc > 1)
123 +                                strcpy(material, argv[1]);
124 +                        else
125 +                                material[0] = '\0';
126                          break;
127                  case 'o':               /* object name */
128                          if (argv[0][1])
129                                  goto unknown;
130                          break;
131 <                case 'g':               /* group name(s) */
131 >                case 'g':               /* group name */
132                          if (argv[0][1])
133                                  goto unknown;
134 +                        if (argc > 1)
135 +                                strcpy(group, argv[1]);
136 +                        else
137 +                                group[0] = '\0';
138                          break;
139                  case '#':               /* comment */
140                          break;
# Line 129 | Line 156 | char   *objfn;
156   }
157  
158  
159 < int
159 > static int
160   getstmt(av, fp)                         /* read the next statement from fp */
161   register char   *av[MAXARG];
162   FILE    *fp;
163   {
164 <        static char     sbuf[MAXARG*10];
164 >        static char     sbuf[MAXARG*16];
165          register char   *cp;
166          register int    i;
167  
# Line 162 | Line 189 | FILE   *fp;
189   }
190  
191  
192 + static int
193   cvtndx(vi, vs)                          /* convert vertex string to index */
194   register VNDX   vi;
195   register char   *vs;
# Line 209 | Line 237 | register char  *vs;
237   }
238  
239  
240 + static int
241   putface(ac, av)                         /* put out an N-sided polygon */
242   int     ac;
243   register char   **av;
244   {
216 –        VNDX            vi;
245          char            *cp;
246          register int    i;
247  
248          while (ac > 3) {                /* break into triangles */
249                  if (!puttri(av[0], av[1], av[2]))
222 –                        {
223 –                        fprintf(stderr, "f %s %s %s\n", av[0], av[1], av[2]);
250                          return(0);
225 –                        }
251                  ac--;                   /* remove vertex & rotate */
252                  cp = av[0];
253                  for (i = 0; i < ac-1; i++)
# Line 233 | Line 258 | register char  **av;
258   }
259  
260  
261 + static OBJECT
262 + getmod()                                /* get current modifier ID */
263 + {
264 +        char    *mnam;
265 +        OBJECT  mod;
266 +
267 +        if (!havemats)
268 +                return(OVOID);
269 +        if (!strcmp(material, VOIDID))
270 +                return(OVOID);
271 +        if (material[0])                /* prefer usemtl statements */
272 +                mnam = material;
273 +        else if (group[0])              /* else use group name */
274 +                mnam = group;
275 +        else
276 +                return(OVOID);
277 +        mod = modifier(mnam);
278 +        if (mod == OVOID) {
279 +                sprintf(errmsg, "%s: undefined modifier \"%s\"",
280 +                                inpfile, mnam);
281 +                error(USER, errmsg);
282 +        }
283 +        return(mod);
284 + }
285 +
286 +
287 + static int
288   puttri(v1, v2, v3)                      /* convert a triangle */
289   char    *v1, *v2, *v3;
290   {
291          VNDX    v1i, v2i, v3i;
292 <        FLOAT   *v1c, *v2c, *v3c;
293 <        FLOAT   *v1n, *v2n, *v3n;
294 <
295 <        if (!cvtndx(v1i, v1) || !cvtndx(v2i, v2) || !cvtndx(v3i, v3))
292 >        RREAL   *v1c, *v2c, *v3c;
293 >        RREAL   *v1n, *v2n, *v3n;
294 >        
295 >        if (!cvtndx(v1i, v1) || !cvtndx(v2i, v2) || !cvtndx(v3i, v3)) {
296 >                error(WARNING, "bad vertex reference");
297                  return(0);
298 <
298 >        }
299          if (v1i[1]>=0 && v2i[1]>=0 && v3i[1]>=0) {
300                  v1c = vtlist[v1i[1]];
301                  v2c = vtlist[v2i[1]];
# Line 257 | Line 310 | char   *v1, *v2, *v3;
310          } else
311                  v1n = v2n = v3n = NULL;
312          
313 <        return(cvtri(vlist[v1i[0]], vlist[v2i[0]], vlist[v3i[0]],
313 >        return(cvtri(getmod(), vlist[v1i[0]], vlist[v2i[0]], vlist[v3i[0]],
314                          v1n, v2n, v3n, v1c, v2c, v3c) >= 0);
315   }
316  
317  
318 + static void
319   freeverts()                     /* free all vertices */
320   {
321          if (nvs) {
# Line 279 | Line 333 | freeverts()                    /* free all vertices */
333   }
334  
335  
336 < int
336 > static int
337   newv(x, y, z)                   /* create a new vertex */
338   double  x, y, z;
339   {
# Line 287 | Line 341 | double x, y, z;
341                  if (nvs == 0)
342                          vlist = (FVECT *)malloc(CHUNKSIZ*sizeof(FVECT));
343                  else
344 <                        vlist = (FVECT *)realloc((char *)vlist,
344 >                        vlist = (FVECT *)realloc((void *)vlist,
345                                          (nvs+CHUNKSIZ)*sizeof(FVECT));
346 <                if (vlist == NULL) {
347 <                        fprintf(stderr,
294 <                        "Out of memory while allocating vertex %d\n", nvs);
295 <                        exit(1);
296 <                }
346 >                if (vlist == NULL)
347 >                        error(SYSTEM, "out of memory in newv");
348          }
349                                          /* assign new vertex */
350          vlist[nvs][0] = x;
# Line 303 | Line 354 | double x, y, z;
354   }
355  
356  
357 < int
357 > static int
358   newvn(x, y, z)                  /* create a new vertex normal */
359   double  x, y, z;
360   {
# Line 311 | Line 362 | double x, y, z;
362                  if (nvns == 0)
363                          vnlist = (FVECT *)malloc(CHUNKSIZ*sizeof(FVECT));
364                  else
365 <                        vnlist = (FVECT *)realloc((char *)vnlist,
365 >                        vnlist = (FVECT *)realloc((void *)vnlist,
366                                          (nvns+CHUNKSIZ)*sizeof(FVECT));
367 <                if (vnlist == NULL) {
368 <                        fprintf(stderr,
318 <                        "Out of memory while allocating normal %d\n", nvns);
319 <                        exit(1);
320 <                }
367 >                if (vnlist == NULL)
368 >                        error(SYSTEM, "out of memory in newvn");
369          }
370                                          /* assign new normal */
371          vnlist[nvns][0] = x;
# Line 329 | Line 377 | double x, y, z;
377   }
378  
379  
380 < int
380 > static int
381   newvt(x, y)                     /* create a new texture map vertex */
382   double  x, y;
383   {
384          if (!(nvts%CHUNKSIZ)) {         /* allocate next block */
385                  if (nvts == 0)
386 <                        vtlist = (FLOAT (*)[2])malloc(CHUNKSIZ*2*sizeof(FLOAT));
386 >                        vtlist = (RREAL (*)[2])malloc(CHUNKSIZ*2*sizeof(RREAL));
387                  else
388 <                        vtlist = (FLOAT (*)[2])realloc((char *)vtlist,
389 <                                        (nvts+CHUNKSIZ)*2*sizeof(FLOAT));
390 <                if (vtlist == NULL) {
391 <                        fprintf(stderr,
344 <                        "Out of memory while allocating texture vertex %d\n",
345 <                                        nvts);
346 <                        exit(1);
347 <                }
388 >                        vtlist = (RREAL (*)[2])realloc((void *)vtlist,
389 >                                        (nvts+CHUNKSIZ)*2*sizeof(RREAL));
390 >                if (vtlist == NULL)
391 >                        error(SYSTEM, "out of memory in newvt");
392          }
393                                          /* assign new vertex */
394          vtlist[nvts][0] = x;
# Line 353 | Line 397 | double x, y;
397   }
398  
399  
400 + static void
401   syntax(er)                      /* report syntax error and exit */
402   char    *er;
403   {
404 <        fprintf(stderr, "%s: Wavefront syntax error near line %d: %s\n",
404 >        sprintf(errmsg, "%s: Wavefront syntax error near line %d: %s\n",
405                          inpfile, lineno, er);
406 <        exit(1);
406 >        error(USER, errmsg);
407   }

Diff Legend

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