src/ot/wfconv.c

#ifndef lint
static const char RCSid[] = "$Id: wfconv.c,v 2.13 2014/06/10 23:19:00 greg Exp $";
#endif
/*
 *  Load Wavefront .OBJ file and convert to triangles with mesh info.
 *  Code borrowed largely from obj2rad.c
 */

#include "copyright.h"
#include "standard.h"
#include "cvmesh.h"
#include "triangulate.h"
#include <ctype.h>

typedef int     VNDX[3];        /* vertex index (point,map,normal) */

#define CHUNKSIZ        1024    /* vertex allocation chunk size */

#define MAXARG          512     /* maximum # arguments in a statement */

static FVECT    *vlist;         /* our vertex list */
static int      nvs;            /* number of vertices in our list */
static FVECT    *vnlist;        /* vertex normal list */
static int      nvns;
static RREAL    (*vtlist)[2];   /* map vertex list */
static int      nvts;

static char     *inpfile;       /* input file name */
static int      havemats;       /* materials available? */
static char     material[256];  /* current material name */
static char     group[256];     /* current group name */
static int      lineno;         /* current line number */
static int      faceno;         /* current face number */

static int getstmt(char *av[MAXARG], FILE *fp);
static int cvtndx(VNDX vi, char *vs);
static int putface(int ac, char **av);
static OBJECT getmod(void);
static int puttri(char  *v1, char *v2, char *v3);
static void freeverts(void);
static int newv(double  x, double y, double z);
static int newvn(double x, double y, double z);
static int newvt(double x, double y);
static void syntax(char *er);


void
wfreadobj(              /* read in .OBJ file and convert */
        char    *objfn
)
{
        FILE    *fp;
        char    *argv[MAXARG];
        int     argc;
        int     nstats, nunknown;

        if (objfn == NULL) {
                inpfile = "<stdin>";
                fp = stdin;
        } else if ((fp = fopen(inpfile=objfn, "r")) == NULL) {
                sprintf(errmsg, "cannot open \"%s\"", inpfile);
                error(USER, errmsg);
        }
        havemats = (nobjects > 0);
        nstats = nunknown = 0;
        material[0] = '\0';
        group[0] = '\0';
        lineno = 0; faceno = 0;
                                        /* scan until EOF */
        while ( (argc = getstmt(argv, fp)) ) {
                switch (argv[0][0]) {
                case 'v':               /* vertex */
                        switch (argv[0][1]) {
                        case '\0':                      /* point */
                                if (badarg(argc-1,argv+1,"fff"))
                                        syntax("bad vertex");
                                newv(atof(argv[1]), atof(argv[2]),
                                                atof(argv[3]));
                                break;
                        case 'n':                       /* normal */
                                if (argv[0][2])
                                        goto unknown;
                                if (badarg(argc-1,argv+1,"fff"))
                                        syntax("bad normal");
                                if (!newvn(atof(argv[1]), atof(argv[2]),
                                                atof(argv[3])))
                                        syntax("zero normal");
                                break;
                        case 't':                       /* coordinate */
                                if (argv[0][2])
                                        goto unknown;
                                if (badarg(argc-1,argv+1,"ff"))
                                        goto unknown;
                                newvt(atof(argv[1]), atof(argv[2]));
                                break;
                        default:
                                goto unknown;
                        }
                        break;
                case 'f':                               /* face */
                        if (argv[0][1])
                                goto unknown;
                        faceno++;
                        switch (argc-1) {
                        case 0: case 1: case 2:
                                syntax("too few vertices");
                                break;
                        case 3:
                                if (!puttri(argv[1], argv[2], argv[3]))
                                        syntax("bad triangle");
                                break;
                        default:
                                if (!putface(argc-1, argv+1))
                                        syntax("bad face");
                                break;
                        }
                        break;
                case 'u':                               /* usemtl/usemap */
                        if (!strcmp(argv[0], "usemap"))
                                break;
                        if (strcmp(argv[0], "usemtl"))
                                goto unknown;
                        if (argc > 1)
                                strcpy(material, argv[1]);
                        else
                                material[0] = '\0';
                        break;
                case 'o':               /* object name */
                        if (argv[0][1])
                                goto unknown;
                        break;
                case 'g':               /* group name */
                        if (argv[0][1])
                                goto unknown;
                        if (argc > 1)
                                strcpy(group, argv[1]);
                        else
                                group[0] = '\0';
                        break;
                case '#':               /* comment */
                        break;
                default:;               /* something we don't deal with */
                unknown:
                        nunknown++;
                        break;
                }
                nstats++;
        }
                                /* clean up */
        freeverts();
        fclose(fp);
        if (nunknown > 0) {
                sprintf(errmsg, "%d of %d statements unrecognized",
                                nunknown, nstats);
                error(WARNING, errmsg);
        }
}


static int
getstmt(                                /* read the next statement from fp */
        char    *av[MAXARG],
        FILE    *fp
)
{
        static char     sbuf[MAXARG*16];
        char    *cp;
        int     i;

        do {
                if (fgetline(cp=sbuf, sizeof(sbuf), fp) == NULL)
                        return(0);
                i = 0;
                for ( ; ; ) {
                        while (isspace(*cp) || *cp == '\\') {
                                if (*cp == '\n')
                                        lineno++;
                                *cp++ = '\0';
                        }
                        if (!*cp)
                                break;
                        if (i >= MAXARG-1) {
                                sprintf(errmsg,
                        "%s: too many arguments near line %d (limit %d)\n",
                                        inpfile, lineno+1, MAXARG-1);
                                break;
                        }
                        av[i++] = cp;
                        while (*++cp && !isspace(*cp))
                                ;
                }
                av[i] = NULL;
                lineno++;
        } while (!i);

        return(i);
}


static int
cvtndx(                         /* convert vertex string to index */
        VNDX    vi,
        char    *vs
)
{
                                        /* get point */
        vi[0] = atoi(vs);
        if (vi[0] > 0) {
                if (vi[0]-- > nvs)
                        return(0);
        } else if (vi[0] < 0) {
                vi[0] += nvs;
                if (vi[0] < 0)
                        return(0);
        } else
                return(0);
                                        /* get map coord. */
        while (*vs)
                if (*vs++ == '/')
                        break;
        vi[1] = atoi(vs);
        if (vi[1] > 0) {
                if (vi[1]-- > nvts)
                        return(0);
        } else if (vi[1] < 0) {
                vi[1] += nvts;
                if (vi[1] < 0)
                        return(0);
        } else
                vi[1] = -1;
                                        /* get normal */
        while (*vs)
                if (*vs++ == '/')
                        break;
        vi[2] = atoi(vs);
        if (vi[2] > 0) {
                if (vi[2]-- > nvns)
                        return(0);
        } else if (vi[2] < 0) {
                vi[2] += nvns;
                if (vi[2] < 0)
                        return(0);
        } else
                vi[2] = -1;
        return(1);
}

/* determine dominant axis for triangle */
static int
dominant_axis(char *v1, char *v2, char *v3)
{
        VNDX    v1i, v2i, v3i;
        FVECT   e1, e2, vn;
        int     i, imax;

        if (!cvtndx(v1i, v1) || !cvtndx(v2i, v2) || !cvtndx(v3i, v3))
                return(-1);
        VSUB(e1, vlist[v2i[0]], vlist[v1i[0]]);
        VSUB(e2, vlist[v3i[0]], vlist[v2i[0]]);
        VCROSS(vn, e1, e2);
        for (i = imax = 2; i--; )
                if (vn[i]*vn[i] > vn[imax]*vn[imax])
                        imax = i;
        return(vn[imax]*vn[imax] > FTINY*FTINY ? imax : -1);
}

/* callback for triangle output from polygon */
static int
tri_out(const Vert2_list *tp, int a, int b, int c)
{
        return( puttri( ((char **)tp->p)[a],
                        ((char **)tp->p)[b],
                        ((char **)tp->p)[c] ) );
}

static int
putface(                                /* put out an N-sided polygon */
        int     ac,
        char    **av
)
{
        Vert2_list      *poly = polyAlloc(ac);
        int             i, ax, ay;

        if (poly == NULL)
                return(0);
        poly->p = (void *)av;
        for (i = ac-3; i >= 0; i--)     /* identify dominant axis */
                if ((ax = dominant_axis(av[i], av[i+1], av[i+2])) >= 0)
                        break;
        if (ax < 0)
                return(1);              /* ignore degenerate face */
        if (++ax >= 3) ax = 0;
        ay = ax;
        if (++ay >= 3) ay = 0;
        for (i = 0; i < ac; i++) {      /* convert to 2-D polygon */
                VNDX    vi;
                if (!cvtndx(vi, av[i])) {
                        error(WARNING, "bad vertex reference");
                        polyFree(poly);
                        return(0);
                }
                poly->v[i].mX = vlist[vi[0]][ax];
                poly->v[i].mY = vlist[vi[0]][ay];
        }
                                        /* break into triangles & output */
        if (!polyTriangulate(poly, &tri_out)) {
                sprintf(errmsg, "self-intersecting face with %d vertices", ac);
                error(WARNING, errmsg);
        }
        polyFree(poly);
        return(1);
}


static OBJECT
getmod(void)                            /* get current modifier ID */
{
        char    *mnam;
        OBJECT  mod;

        if (!havemats)
                return(OVOID);
        if (!strcmp(material, VOIDID))
                return(OVOID);
        if (material[0])                /* prefer usemtl statements */
                mnam = material;
        else if (group[0])              /* else use group name */
                mnam = group;
        else
                return(OVOID);
        mod = modifier(mnam);
        if (mod == OVOID) {
                sprintf(errmsg, "%s: undefined modifier \"%s\"",
                                inpfile, mnam);
                error(USER, errmsg);
        }
        return(mod);
}


static int
puttri(                 /* convert a triangle */
        char    *v1,
        char    *v2,
        char    *v3
)
{
        VNDX    v1i, v2i, v3i;
        RREAL   *v1c, *v2c, *v3c;
        RREAL   *v1n, *v2n, *v3n;
        
        if (!cvtndx(v1i, v1) || !cvtndx(v2i, v2) || !cvtndx(v3i, v3)) {
                error(WARNING, "bad vertex reference");
                return(0);
        }
        if (v1i[1]>=0 && v2i[1]>=0 && v3i[1]>=0) {
                v1c = vtlist[v1i[1]];
                v2c = vtlist[v2i[1]];
                v3c = vtlist[v3i[1]];
        } else
                v1c = v2c = v3c = NULL;

        if (v1i[2]>=0 && v2i[2]>=0 && v3i[2]>=0) {
                v1n = vnlist[v1i[2]];
                v2n = vnlist[v2i[2]];
                v3n = vnlist[v3i[2]];
        } else
                v1n = v2n = v3n = NULL;
        
        return(cvtri(getmod(), vlist[v1i[0]], vlist[v2i[0]], vlist[v3i[0]],
                        v1n, v2n, v3n, v1c, v2c, v3c) >= 0);
}


static void
freeverts(void)                 /* free all vertices */
{
        if (nvs) {
                free((void *)vlist);
                nvs = 0;
        }
        if (nvts) {
                free((void *)vtlist);
                nvts = 0;
        }
        if (nvns) {
                free((void *)vnlist);
                nvns = 0;
        }
}


static int
newv(                   /* create a new vertex */
        double  x,
        double  y,
        double  z
)
{
        if (!(nvs%CHUNKSIZ)) {          /* allocate next block */
                if (nvs == 0)
                        vlist = (FVECT *)malloc(CHUNKSIZ*sizeof(FVECT));
                else
                        vlist = (FVECT *)realloc((void *)vlist,
                                        (nvs+CHUNKSIZ)*sizeof(FVECT));
                if (vlist == NULL)
                        error(SYSTEM, "out of memory in newv");
        }
                                        /* assign new vertex */
        vlist[nvs][0] = x;
        vlist[nvs][1] = y;
        vlist[nvs][2] = z;
        return(++nvs);
}


static int
newvn(                  /* create a new vertex normal */
        double  x,
        double  y,
        double  z
)
{
        if (!(nvns%CHUNKSIZ)) {         /* allocate next block */
                if (nvns == 0)
                        vnlist = (FVECT *)malloc(CHUNKSIZ*sizeof(FVECT));
                else
                        vnlist = (FVECT *)realloc((void *)vnlist,
                                        (nvns+CHUNKSIZ)*sizeof(FVECT));
                if (vnlist == NULL)
                        error(SYSTEM, "out of memory in newvn");
        }
                                        /* assign new normal */
        vnlist[nvns][0] = x;
        vnlist[nvns][1] = y;
        vnlist[nvns][2] = z;
        if (normalize(vnlist[nvns]) == 0.0)
                return(0);
        return(++nvns);
}


static int
newvt(                  /* create a new texture map vertex */
        double  x,
        double  y
)
{
        if (!(nvts%CHUNKSIZ)) {         /* allocate next block */
                if (nvts == 0)
                        vtlist = (RREAL (*)[2])malloc(CHUNKSIZ*2*sizeof(RREAL));
                else
                        vtlist = (RREAL (*)[2])realloc((void *)vtlist,
                                        (nvts+CHUNKSIZ)*2*sizeof(RREAL));
                if (vtlist == NULL)
                        error(SYSTEM, "out of memory in newvt");
        }
                                        /* assign new vertex */
        vtlist[nvts][0] = x;
        vtlist[nvts][1] = y;
        return(++nvts);
}


static void
syntax(                 /* report syntax error and exit */
        char    *er
)
{
        sprintf(errmsg, "%s: Wavefront syntax error near line %d: %s\n",
                        inpfile, lineno, er);
        error(USER, errmsg);
}
Revision:	2.14
Committed:	Wed Jun 11 00:08:30 2014 UTC (9 years, 10 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad5R2, rad4R2P2, rad5R0, rad5R1, rad4R2, rad4R2P1
Changes since 2.13:	+2 -2 lines
Log Message:	Fixed bug in small polygon triangulation
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.14	static const char RCSid[] = "$Id: wfconv.c,v 2.13 2014/06/10 23:19:00 greg Exp $";
3	greg	2.1	#endif
4			/*
5			* Load Wavefront .OBJ file and convert to triangles with mesh info.
6			* Code borrowed largely from obj2rad.c
7			*/
8
9			#include "copyright.h"
10			#include "standard.h"
11			#include "cvmesh.h"
12	greg	2.11	#include "triangulate.h"
13	greg	2.1	#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	greg	2.9	#define MAXARG 512 /* maximum # arguments in a statement */
20	greg	2.1
21	greg	2.3	static FVECT vlist; / our vertex list */
22			static int nvs; /* number of vertices in our list */
23			static FVECT vnlist; / vertex normal list */
24			static int nvns;
25	schorsch	2.5	static RREAL (vtlist)[2]; / map vertex list */
26	greg	2.3	static int nvts;
27
28			static char inpfile; / input file name */
29			static int havemats; /* materials available? */
30	greg	2.10	static char material[256]; /* current material name */
31			static char group[256]; /* current group name */
32	greg	2.3	static int lineno; /* current line number */
33			static int faceno; /* current face number */
34
35	greg	2.13	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	schorsch	2.8	static OBJECT getmod(void);
39	greg	2.13	static int puttri(char v1, char v2, char *v3);
40	schorsch	2.8	static void freeverts(void);
41	greg	2.13	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	schorsch	2.8	static void syntax(char *er);
45	greg	2.1
46
47	greg	2.3	void
48	schorsch	2.8	wfreadobj( /* read in .OBJ file and convert */
49			char *objfn
50			)
51	greg	2.1	{
52			FILE *fp;
53			char *argv[MAXARG];
54			int argc;
55			int nstats, nunknown;
56
57			if (objfn == NULL) {
58			inpfile = "<stdin>";
59			fp = stdin;
60			} else if ((fp = fopen(inpfile=objfn, "r")) == NULL) {
61			sprintf(errmsg, "cannot open \"%s\"", inpfile);
62			error(USER, errmsg);
63			}
64	greg	2.3	havemats = (nobjects > 0);
65	greg	2.1	nstats = nunknown = 0;
66	greg	2.3	material[0] = '\0';
67			group[0] = '\0';
68	greg	2.1	lineno = 0; faceno = 0;
69			/* scan until EOF */
70	schorsch	2.6	while ( (argc = getstmt(argv, fp)) ) {
71	greg	2.1	switch (argv[0][0]) {
72			case 'v': /* vertex */
73			switch (argv[0][1]) {
74			case '\0': /* point */
75			if (badarg(argc-1,argv+1,"fff"))
76	greg	2.2	syntax("bad vertex");
77	greg	2.1	newv(atof(argv[1]), atof(argv[2]),
78			atof(argv[3]));
79			break;
80			case 'n': /* normal */
81			if (argv[0][2])
82			goto unknown;
83			if (badarg(argc-1,argv+1,"fff"))
84	greg	2.2	syntax("bad normal");
85	greg	2.1	if (!newvn(atof(argv[1]), atof(argv[2]),
86			atof(argv[3])))
87	greg	2.2	syntax("zero normal");
88	greg	2.1	break;
89	greg	2.2	case 't': /* coordinate */
90	greg	2.1	if (argv[0][2])
91			goto unknown;
92			if (badarg(argc-1,argv+1,"ff"))
93			goto unknown;
94			newvt(atof(argv[1]), atof(argv[2]));
95			break;
96			default:
97			goto unknown;
98			}
99			break;
100			case 'f': /* face */
101			if (argv[0][1])
102			goto unknown;
103			faceno++;
104			switch (argc-1) {
105			case 0: case 1: case 2:
106	greg	2.2	syntax("too few vertices");
107	greg	2.1	break;
108			case 3:
109			if (!puttri(argv[1], argv[2], argv[3]))
110	greg	2.2	syntax("bad triangle");
111	greg	2.1	break;
112			default:
113			if (!putface(argc-1, argv+1))
114	greg	2.2	syntax("bad face");
115	greg	2.1	break;
116			}
117			break;
118	greg	2.3	case 'u': /* usemtl/usemap */
119			if (!strcmp(argv[0], "usemap"))
120			break;
121			if (strcmp(argv[0], "usemtl"))
122	greg	2.1	goto unknown;
123	greg	2.3	if (argc > 1)
124			strcpy(material, argv[1]);
125			else
126			material[0] = '\0';
127	greg	2.1	break;
128			case 'o': /* object name */
129			if (argv[0][1])
130			goto unknown;
131			break;
132	greg	2.3	case 'g': /* group name */
133	greg	2.1	if (argv[0][1])
134			goto unknown;
135	greg	2.3	if (argc > 1)
136			strcpy(group, argv[1]);
137			else
138			group[0] = '\0';
139	greg	2.1	break;
140			case '#': /* comment */
141			break;
142			default:; /* something we don't deal with */
143			unknown:
144			nunknown++;
145			break;
146			}
147			nstats++;
148			}
149			/* clean up */
150			freeverts();
151			fclose(fp);
152			if (nunknown > 0) {
153			sprintf(errmsg, "%d of %d statements unrecognized",
154			nunknown, nstats);
155			error(WARNING, errmsg);
156			}
157			}
158
159
160	greg	2.3	static int
161	schorsch	2.8	getstmt( /* read the next statement from fp */
162	greg	2.10	char *av[MAXARG],
163	schorsch	2.8	FILE *fp
164			)
165	greg	2.1	{
166	greg	2.3	static char sbuf[MAXARG*16];
167	greg	2.10	char *cp;
168			int i;
169	greg	2.1
170			do {
171			if (fgetline(cp=sbuf, sizeof(sbuf), fp) == NULL)
172			return(0);
173			i = 0;
174			for ( ; ; ) {
175			while (isspace(cp) \|\| cp == '\\') {
176			if (*cp == '\n')
177			lineno++;
178			*cp++ = '\0';
179			}
180	greg	2.9	if (!*cp)
181	greg	2.1	break;
182	greg	2.9	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	greg	2.1	av[i++] = cp;
189			while (++cp && !isspace(cp))
190			;
191			}
192			av[i] = NULL;
193			lineno++;
194			} while (!i);
195
196			return(i);
197			}
198
199
200	greg	2.3	static int
201	schorsch	2.8	cvtndx( /* convert vertex string to index */
202	greg	2.10	VNDX vi,
203			char *vs
204	schorsch	2.8	)
205	greg	2.1	{
206			/* get point */
207			vi[0] = atoi(vs);
208			if (vi[0] > 0) {
209			if (vi[0]-- > nvs)
210			return(0);
211			} else if (vi[0] < 0) {
212			vi[0] += nvs;
213			if (vi[0] < 0)
214			return(0);
215			} else
216			return(0);
217			/* get map coord. */
218			while (*vs)
219			if (*vs++ == '/')
220			break;
221			vi[1] = atoi(vs);
222			if (vi[1] > 0) {
223			if (vi[1]-- > nvts)
224			return(0);
225			} else if (vi[1] < 0) {
226			vi[1] += nvts;
227			if (vi[1] < 0)
228			return(0);
229			} else
230			vi[1] = -1;
231			/* get normal */
232			while (*vs)
233			if (*vs++ == '/')
234			break;
235			vi[2] = atoi(vs);
236			if (vi[2] > 0) {
237			if (vi[2]-- > nvns)
238			return(0);
239			} else if (vi[2] < 0) {
240			vi[2] += nvns;
241			if (vi[2] < 0)
242			return(0);
243			} else
244			vi[2] = -1;
245			return(1);
246			}
247
248	greg	2.11	/* determine dominant axis for triangle */
249			static int
250			dominant_axis(char v1, char v2, char *v3)
251			{
252	greg	2.12	VNDX v1i, v2i, v3i;
253	greg	2.11	FVECT e1, e2, vn;
254			int i, imax;
255
256	greg	2.12	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	greg	2.11	VCROSS(vn, e1, e2);
261			for (i = imax = 2; i--; )
262			if (vn[i]vn[i] > vn[imax]vn[imax])
263			imax = i;
264	greg	2.14	return(vn[imax]vn[imax] > FTINYFTINY ? imax : -1);
265	greg	2.11	}
266
267			/* callback for triangle output from polygon */
268			static int
269			tri_out(const Vert2_list *tp, int a, int b, int c)
270			{
271			return( puttri( ((char **)tp->p)[a],
272			((char **)tp->p)[b],
273			((char **)tp->p)[c] ) );
274			}
275	greg	2.1
276	greg	2.3	static int
277	schorsch	2.8	putface( /* put out an N-sided polygon */
278			int ac,
279	greg	2.10	char **av
280	schorsch	2.8	)
281	greg	2.1	{
282	greg	2.11	Vert2_list *poly = polyAlloc(ac);
283			int i, ax, ay;
284	greg	2.1
285	greg	2.11	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	greg	2.12	return(1); /* ignore degenerate face */
293	greg	2.11	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	greg	2.1	return(0);
302	greg	2.11	}
303			poly->v[i].mX = vlist[vi[0]][ax];
304			poly->v[i].mY = vlist[vi[0]][ay];
305	greg	2.1	}
306	greg	2.11	/* break into triangles & output */
307	greg	2.13	if (!polyTriangulate(poly, &tri_out)) {
308			sprintf(errmsg, "self-intersecting face with %d vertices", ac);
309			error(WARNING, errmsg);
310			}
311	greg	2.11	polyFree(poly);
312			return(1);
313	greg	2.1	}
314
315
316	greg	2.3	static OBJECT
317	schorsch	2.8	getmod(void) /* get current modifier ID */
318	greg	2.3	{
319			char *mnam;
320			OBJECT mod;
321
322			if (!havemats)
323			return(OVOID);
324			if (!strcmp(material, VOIDID))
325			return(OVOID);
326			if (material[0]) /* prefer usemtl statements */
327			mnam = material;
328			else if (group[0]) /* else use group name */
329			mnam = group;
330			else
331			return(OVOID);
332			mod = modifier(mnam);
333			if (mod == OVOID) {
334			sprintf(errmsg, "%s: undefined modifier \"%s\"",
335			inpfile, mnam);
336			error(USER, errmsg);
337			}
338			return(mod);
339			}
340
341
342			static int
343	schorsch	2.8	puttri( /* convert a triangle */
344			char *v1,
345			char *v2,
346			char *v3
347			)
348	greg	2.1	{
349			VNDX v1i, v2i, v3i;
350	schorsch	2.5	RREAL v1c, v2c, *v3c;
351			RREAL v1n, v2n, *v3n;
352	greg	2.2
353	greg	2.7	if (!cvtndx(v1i, v1) \|\| !cvtndx(v2i, v2) \|\| !cvtndx(v3i, v3)) {
354			error(WARNING, "bad vertex reference");
355	greg	2.1	return(0);
356	greg	2.7	}
357	greg	2.1	if (v1i[1]>=0 && v2i[1]>=0 && v3i[1]>=0) {
358			v1c = vtlist[v1i[1]];
359			v2c = vtlist[v2i[1]];
360			v3c = vtlist[v3i[1]];
361			} else
362			v1c = v2c = v3c = NULL;
363
364			if (v1i[2]>=0 && v2i[2]>=0 && v3i[2]>=0) {
365			v1n = vnlist[v1i[2]];
366			v2n = vnlist[v2i[2]];
367			v3n = vnlist[v3i[2]];
368			} else
369			v1n = v2n = v3n = NULL;
370
371	greg	2.3	return(cvtri(getmod(), vlist[v1i[0]], vlist[v2i[0]], vlist[v3i[0]],
372	greg	2.1	v1n, v2n, v3n, v1c, v2c, v3c) >= 0);
373			}
374
375
376	greg	2.3	static void
377	schorsch	2.8	freeverts(void) /* free all vertices */
378	greg	2.1	{
379			if (nvs) {
380			free((void *)vlist);
381			nvs = 0;
382			}
383			if (nvts) {
384			free((void *)vtlist);
385			nvts = 0;
386			}
387			if (nvns) {
388			free((void *)vnlist);
389			nvns = 0;
390			}
391			}
392
393
394	greg	2.3	static int
395	schorsch	2.8	newv( /* create a new vertex */
396			double x,
397			double y,
398			double z
399			)
400	greg	2.1	{
401			if (!(nvs%CHUNKSIZ)) { /* allocate next block */
402			if (nvs == 0)
403			vlist = (FVECT )malloc(CHUNKSIZsizeof(FVECT));
404			else
405	greg	2.4	vlist = (FVECT )realloc((void )vlist,
406	greg	2.1	(nvs+CHUNKSIZ)*sizeof(FVECT));
407	greg	2.2	if (vlist == NULL)
408			error(SYSTEM, "out of memory in newv");
409	greg	2.1	}
410			/* assign new vertex */
411			vlist[nvs][0] = x;
412			vlist[nvs][1] = y;
413			vlist[nvs][2] = z;
414			return(++nvs);
415			}
416
417
418	greg	2.3	static int
419	schorsch	2.8	newvn( /* create a new vertex normal */
420			double x,
421			double y,
422			double z
423			)
424	greg	2.1	{
425			if (!(nvns%CHUNKSIZ)) { /* allocate next block */
426			if (nvns == 0)
427			vnlist = (FVECT )malloc(CHUNKSIZsizeof(FVECT));
428			else
429	greg	2.4	vnlist = (FVECT )realloc((void )vnlist,
430	greg	2.1	(nvns+CHUNKSIZ)*sizeof(FVECT));
431	greg	2.2	if (vnlist == NULL)
432			error(SYSTEM, "out of memory in newvn");
433	greg	2.1	}
434			/* assign new normal */
435			vnlist[nvns][0] = x;
436			vnlist[nvns][1] = y;
437			vnlist[nvns][2] = z;
438			if (normalize(vnlist[nvns]) == 0.0)
439			return(0);
440			return(++nvns);
441			}
442
443
444	greg	2.3	static int
445	schorsch	2.8	newvt( /* create a new texture map vertex */
446			double x,
447			double y
448			)
449	greg	2.1	{
450			if (!(nvts%CHUNKSIZ)) { /* allocate next block */
451			if (nvts == 0)
452	schorsch	2.5	vtlist = (RREAL ()[2])malloc(CHUNKSIZ2*sizeof(RREAL));
453	greg	2.1	else
454	schorsch	2.5	vtlist = (RREAL ()[2])realloc((void )vtlist,
455			(nvts+CHUNKSIZ)2sizeof(RREAL));
456	greg	2.2	if (vtlist == NULL)
457			error(SYSTEM, "out of memory in newvt");
458	greg	2.1	}
459			/* assign new vertex */
460			vtlist[nvts][0] = x;
461			vtlist[nvts][1] = y;
462			return(++nvts);
463			}
464
465
466	greg	2.3	static void
467	schorsch	2.8	syntax( /* report syntax error and exit */
468			char *er
469			)
470	greg	2.1	{
471	greg	2.2	sprintf(errmsg, "%s: Wavefront syntax error near line %d: %s\n",
472	greg	2.1	inpfile, lineno, er);
473	greg	2.2	error(USER, errmsg);
474	greg	2.1	}