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.6 by schorsch, Sun Jul 27 22:12:03 2003 UTC vs.
Revision 2.16 by greg, Sun Jun 14 04:18:09 2020 UTC

# Line 9 | Line 9 | static const char RCSid[] = "$Id$";
9   #include "copyright.h"
10   #include "standard.h"
11   #include "cvmesh.h"
12 + #include "triangulate.h"
13   #include <ctype.h>
14  
15   typedef int     VNDX[3];        /* vertex index (point,map,normal) */
16  
17   #define CHUNKSIZ        1024    /* vertex allocation chunk size */
18  
19 < #define MAXARG          64      /* maximum # arguments in a statement */
19 > #define MAXARG          512     /* maximum # arguments in a statement */
20  
21   static FVECT    *vlist;         /* our vertex list */
22   static int      nvs;            /* number of vertices in our list */
# Line 26 | Line 27 | static int     nvts;
27  
28   static char     *inpfile;       /* input file name */
29   static int      havemats;       /* materials available? */
30 < static char     material[64];   /* current material name */
31 < static char     group[64];      /* current group name */
30 > static char     material[256];  /* current material name */
31 > static char     group[256];     /* current group name */
32   static int      lineno;         /* current line number */
33   static int      faceno;         /* current face number */
34  
35 < static int      getstmt();
36 < static int      cvtndx();
37 < static OBJECT   getmod();
38 < static int      putface();
39 < static int      puttri();
40 < static void     freeverts();
41 < static int      newv();
42 < static int      newvn();
43 < static int      newvt();
44 < static void     syntax();
35 > static int getstmt(char *av[MAXARG], FILE *fp);
36 > static int cvtndx(VNDX vi, char *vs);
37 > static int putface(int ac, char **av);
38 > static OBJECT getmod(void);
39 > static int puttri(char  *v1, char *v2, char *v3);
40 > static void freeverts(void);
41 > static int newv(double  x, double y, double z);
42 > static int newvn(double x, double y, double z);
43 > static int newvt(double x, double y);
44 > static void syntax(char *er);
45  
46  
47   void
48 < wfreadobj(objfn)                /* read in .OBJ file and convert */
49 < char    *objfn;
48 > wfreadobj(              /* read in .OBJ file and convert */
49 >        char    *objfn
50 > )
51   {
52          FILE    *fp;
53          char    *argv[MAXARG];
54          int     argc;
55          int     nstats, nunknown;
54 –        int     i;
56  
57          if (objfn == NULL) {
58                  inpfile = "<stdin>";
# Line 157 | Line 158 | char   *objfn;
158  
159  
160   static int
161 < getstmt(av, fp)                         /* read the next statement from fp */
162 < register char   *av[MAXARG];
163 < FILE    *fp;
161 > getstmt(                                /* read the next statement from fp */
162 >        char    *av[MAXARG],
163 >        FILE    *fp
164 > )
165   {
166          static char     sbuf[MAXARG*16];
167 <        register char   *cp;
168 <        register int    i;
167 >        char    *cp;
168 >        int     i;
169  
170          do {
171                  if (fgetline(cp=sbuf, sizeof(sbuf), fp) == NULL)
# Line 175 | Line 177 | FILE   *fp;
177                                          lineno++;
178                                  *cp++ = '\0';
179                          }
180 <                        if (!*cp || i >= MAXARG-1)
180 >                        if (!*cp)
181                                  break;
182 +                        if (i >= MAXARG-1) {
183 +                                sprintf(errmsg,
184 +                        "%s: too many arguments near line %d (limit %d)\n",
185 +                                        inpfile, lineno+1, MAXARG-1);
186 +                                break;
187 +                        }
188                          av[i++] = cp;
189                          while (*++cp && !isspace(*cp))
190                                  ;
# Line 190 | Line 198 | FILE   *fp;
198  
199  
200   static int
201 < cvtndx(vi, vs)                          /* convert vertex string to index */
202 < register VNDX   vi;
203 < register char   *vs;
201 > cvtndx(                         /* convert vertex string to index */
202 >        VNDX    vi,
203 >        char    *vs
204 > )
205   {
206                                          /* get point */
207          vi[0] = atoi(vs);
# Line 236 | Line 245 | register char  *vs;
245          return(1);
246   }
247  
248 + /* determine dominant axis for triangle */
249 + static int
250 + dominant_axis(char *v1, char *v2, char *v3)
251 + {
252 +        VNDX    v1i, v2i, v3i;
253 +        FVECT   e1, e2, vn;
254 +        int     i, imax;
255  
256 +        if (!cvtndx(v1i, v1) || !cvtndx(v2i, v2) || !cvtndx(v3i, v3))
257 +                return(-1);
258 +        VSUB(e1, vlist[v2i[0]], vlist[v1i[0]]);
259 +        VSUB(e2, vlist[v3i[0]], vlist[v2i[0]]);
260 +        VCROSS(vn, e1, e2);
261 +        for (i = imax = 2; i--; )
262 +                if (vn[i]*vn[i] > vn[imax]*vn[imax])
263 +                        imax = i;
264 +        return(vn[imax]*vn[imax] > FTINY*FTINY*FTINY*FTINY ? imax : -1);
265 + }
266 +
267 + /* callback for triangle output from polygon */
268   static int
269 < putface(ac, av)                         /* put out an N-sided polygon */
242 < int     ac;
243 < register char   **av;
269 > tri_out(const Vert2_list *tp, int a, int b, int c)
270   {
271 <        char            *cp;
272 <        register int    i;
271 >        return( puttri( ((char **)tp->p)[a],
272 >                        ((char **)tp->p)[b],
273 >                        ((char **)tp->p)[c] ) );
274 > }
275  
276 <        while (ac > 3) {                /* break into triangles */
277 <                if (!puttri(av[0], av[1], av[2]))
276 > static int
277 > putface(                                /* put out an N-sided polygon */
278 >        int     ac,
279 >        char    **av
280 > )
281 > {
282 >        Vert2_list      *poly = polyAlloc(ac);
283 >        int             i, ax, ay;
284 >
285 >        if (poly == NULL)
286 >                return(0);
287 >        poly->p = (void *)av;
288 >        for (i = ac-3; i >= 0; i--)     /* identify dominant axis */
289 >                if ((ax = dominant_axis(av[i], av[i+1], av[i+2])) >= 0)
290 >                        break;
291 >        if (ax < 0)
292 >                return(1);              /* ignore degenerate face */
293 >        if (++ax >= 3) ax = 0;
294 >        ay = ax;
295 >        if (++ay >= 3) ay = 0;
296 >        for (i = 0; i < ac; i++) {      /* convert to 2-D polygon */
297 >                VNDX    vi;
298 >                if (!cvtndx(vi, av[i])) {
299 >                        error(WARNING, "bad vertex reference");
300 >                        polyFree(poly);
301                          return(0);
302 <                ac--;                   /* remove vertex & rotate */
303 <                cp = av[0];
304 <                for (i = 0; i < ac-1; i++)
254 <                        av[i] = av[i+2];
255 <                av[i] = cp;
302 >                }
303 >                poly->v[i].mX = vlist[vi[0]][ax];
304 >                poly->v[i].mY = vlist[vi[0]][ay];
305          }
306 <        return(puttri(av[0], av[1], av[2]));
306 >                                        /* break into triangles & output */
307 >        if (!polyTriangulate(poly, &tri_out)) {
308 >                sprintf(errmsg, "self-intersecting face with %d vertices", ac);
309 >                error(WARNING, errmsg);
310 >        }
311 >        polyFree(poly);
312 >        return(1);
313   }
314  
315  
316   static OBJECT
317 < getmod()                                /* get current modifier ID */
317 > getmod(void)                            /* get current modifier ID */
318   {
319          char    *mnam;
320          OBJECT  mod;
# Line 285 | Line 340 | getmod()                               /* get current modifier ID */
340  
341  
342   static int
343 < puttri(v1, v2, v3)                      /* convert a triangle */
344 < char    *v1, *v2, *v3;
343 > puttri(                 /* convert a triangle */
344 >        char    *v1,
345 >        char    *v2,
346 >        char    *v3
347 > )
348   {
349          VNDX    v1i, v2i, v3i;
350          RREAL   *v1c, *v2c, *v3c;
351          RREAL   *v1n, *v2n, *v3n;
352          
353 <        if (!cvtndx(v1i, v1) || !cvtndx(v2i, v2) || !cvtndx(v3i, v3))
353 >        if (!cvtndx(v1i, v1) || !cvtndx(v2i, v2) || !cvtndx(v3i, v3)) {
354 >                error(WARNING, "bad vertex reference");
355                  return(0);
356 <
356 >        }
357          if (v1i[1]>=0 && v2i[1]>=0 && v3i[1]>=0) {
358                  v1c = vtlist[v1i[1]];
359                  v2c = vtlist[v2i[1]];
# Line 315 | Line 374 | char   *v1, *v2, *v3;
374  
375  
376   static void
377 < freeverts()                     /* free all vertices */
377 > freeverts(void)                 /* free all vertices */
378   {
379          if (nvs) {
380                  free((void *)vlist);
# Line 333 | Line 392 | freeverts()                    /* free all vertices */
392  
393  
394   static int
395 < newv(x, y, z)                   /* create a new vertex */
396 < double  x, y, z;
395 > newv(                   /* create a new vertex */
396 >        double  x,
397 >        double  y,
398 >        double  z
399 > )
400   {
401          if (!(nvs%CHUNKSIZ)) {          /* allocate next block */
402                  if (nvs == 0)
# Line 354 | Line 416 | double x, y, z;
416  
417  
418   static int
419 < newvn(x, y, z)                  /* create a new vertex normal */
420 < double  x, y, z;
419 > newvn(                  /* create a new vertex normal */
420 >        double  x,
421 >        double  y,
422 >        double  z
423 > )
424   {
425          if (!(nvns%CHUNKSIZ)) {         /* allocate next block */
426                  if (nvns == 0)
# Line 377 | Line 442 | double x, y, z;
442  
443  
444   static int
445 < newvt(x, y)                     /* create a new texture map vertex */
446 < double  x, y;
445 > newvt(                  /* create a new texture map vertex */
446 >        double  x,
447 >        double  y
448 > )
449   {
450          if (!(nvts%CHUNKSIZ)) {         /* allocate next block */
451                  if (nvts == 0)
# Line 397 | Line 464 | double x, y;
464  
465  
466   static void
467 < syntax(er)                      /* report syntax error and exit */
468 < char    *er;
467 > syntax(                 /* report syntax error and exit */
468 >        char    *er
469 > )
470   {
471 <        sprintf(errmsg, "%s: Wavefront syntax error near line %d: %s\n",
471 >        sprintf(errmsg, "%s: Wavefront syntax error near line %d: %s",
472                          inpfile, lineno, er);
473          error(USER, errmsg);
474   }

Diff Legend

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