src/ot/wfconv.c

#ifndef lint
static const char RCSid[] = "$Id: wfconv.c,v 2.10 2013/11/08 16:49:04 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)
{
        int     v1i = atoi(v1), v2i = atoi(v2), v3i = atoi(v3);
        FVECT   e1, e2, vn;
        int     i, imax;

        VSUB(e1, vlist[v2i], vlist[v1i]);
        VSUB(e2, vlist[v3i], vlist[v2i]);
        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 ? 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(0);
        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))
                return(0);
        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.11
Committed:	Fri Jan 24 01:26:44 2014 UTC (10 years, 3 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.10:	+53 -11 lines
Log Message:	Hopeful fix to triangulation code for obj2mesh with N-sided polygons
#	User	Rev	Content
1	greg	2.1	#ifndef lint
2	greg	2.11	static const char RCSid[] = "$Id: wfconv.c,v 2.10 2013/11/08 16:49:04 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	schorsch	2.8	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	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			int v1i = atoi(v1), v2i = atoi(v2), v3i = atoi(v3);
253			FVECT e1, e2, vn;
254			int i, imax;
255
256			VSUB(e1, vlist[v2i], vlist[v1i]);
257			VSUB(e2, vlist[v3i], vlist[v2i]);
258			VCROSS(vn, e1, e2);
259			for (i = imax = 2; i--; )
260			if (vn[i]vn[i] > vn[imax]vn[imax])
261			imax = i;
262			return(vn[imax]*vn[imax] > FTINY ? imax : -1);
263			}
264
265			/* callback for triangle output from polygon */
266			static int
267			tri_out(const Vert2_list *tp, int a, int b, int c)
268			{
269			return( puttri( ((char **)tp->p)[a],
270			((char **)tp->p)[b],
271			((char **)tp->p)[c] ) );
272			}
273	greg	2.1
274	greg	2.3	static int
275	schorsch	2.8	putface( /* put out an N-sided polygon */
276			int ac,
277	greg	2.10	char **av
278	schorsch	2.8	)
279	greg	2.1	{
280	greg	2.11	Vert2_list *poly = polyAlloc(ac);
281			int i, ax, ay;
282	greg	2.1
283	greg	2.11	if (poly == NULL)
284			return(0);
285			poly->p = (void *)av;
286			for (i = ac-3; i >= 0; i--) /* identify dominant axis */
287			if ((ax = dominant_axis(av[i], av[i+1], av[i+2])) >= 0)
288			break;
289			if (ax < 0)
290			return(0);
291			if (++ax >= 3) ax = 0;
292			ay = ax;
293			if (++ay >= 3) ay = 0;
294			for (i = 0; i < ac; i++) { /* convert to 2-D polygon */
295			VNDX vi;
296			if (!cvtndx(vi, av[i])) {
297			error(WARNING, "bad vertex reference");
298			polyFree(poly);
299	greg	2.1	return(0);
300	greg	2.11	}
301			poly->v[i].mX = vlist[vi[0]][ax];
302			poly->v[i].mY = vlist[vi[0]][ay];
303	greg	2.1	}
304	greg	2.11	/* break into triangles & output */
305			if (!polyTriangulate(poly, &tri_out))
306			return(0);
307			polyFree(poly);
308			return(1);
309	greg	2.1	}
310
311
312	greg	2.3	static OBJECT
313	schorsch	2.8	getmod(void) /* get current modifier ID */
314	greg	2.3	{
315			char *mnam;
316			OBJECT mod;
317
318			if (!havemats)
319			return(OVOID);
320			if (!strcmp(material, VOIDID))
321			return(OVOID);
322			if (material[0]) /* prefer usemtl statements */
323			mnam = material;
324			else if (group[0]) /* else use group name */
325			mnam = group;
326			else
327			return(OVOID);
328			mod = modifier(mnam);
329			if (mod == OVOID) {
330			sprintf(errmsg, "%s: undefined modifier \"%s\"",
331			inpfile, mnam);
332			error(USER, errmsg);
333			}
334			return(mod);
335			}
336
337
338			static int
339	schorsch	2.8	puttri( /* convert a triangle */
340			char *v1,
341			char *v2,
342			char *v3
343			)
344	greg	2.1	{
345			VNDX v1i, v2i, v3i;
346	schorsch	2.5	RREAL v1c, v2c, *v3c;
347			RREAL v1n, v2n, *v3n;
348	greg	2.2
349	greg	2.7	if (!cvtndx(v1i, v1) \|\| !cvtndx(v2i, v2) \|\| !cvtndx(v3i, v3)) {
350			error(WARNING, "bad vertex reference");
351	greg	2.1	return(0);
352	greg	2.7	}
353	greg	2.1	if (v1i[1]>=0 && v2i[1]>=0 && v3i[1]>=0) {
354			v1c = vtlist[v1i[1]];
355			v2c = vtlist[v2i[1]];
356			v3c = vtlist[v3i[1]];
357			} else
358			v1c = v2c = v3c = NULL;
359
360			if (v1i[2]>=0 && v2i[2]>=0 && v3i[2]>=0) {
361			v1n = vnlist[v1i[2]];
362			v2n = vnlist[v2i[2]];
363			v3n = vnlist[v3i[2]];
364			} else
365			v1n = v2n = v3n = NULL;
366
367	greg	2.3	return(cvtri(getmod(), vlist[v1i[0]], vlist[v2i[0]], vlist[v3i[0]],
368	greg	2.1	v1n, v2n, v3n, v1c, v2c, v3c) >= 0);
369			}
370
371
372	greg	2.3	static void
373	schorsch	2.8	freeverts(void) /* free all vertices */
374	greg	2.1	{
375			if (nvs) {
376			free((void *)vlist);
377			nvs = 0;
378			}
379			if (nvts) {
380			free((void *)vtlist);
381			nvts = 0;
382			}
383			if (nvns) {
384			free((void *)vnlist);
385			nvns = 0;
386			}
387			}
388
389
390	greg	2.3	static int
391	schorsch	2.8	newv( /* create a new vertex */
392			double x,
393			double y,
394			double z
395			)
396	greg	2.1	{
397			if (!(nvs%CHUNKSIZ)) { /* allocate next block */
398			if (nvs == 0)
399			vlist = (FVECT )malloc(CHUNKSIZsizeof(FVECT));
400			else
401	greg	2.4	vlist = (FVECT )realloc((void )vlist,
402	greg	2.1	(nvs+CHUNKSIZ)*sizeof(FVECT));
403	greg	2.2	if (vlist == NULL)
404			error(SYSTEM, "out of memory in newv");
405	greg	2.1	}
406			/* assign new vertex */
407			vlist[nvs][0] = x;
408			vlist[nvs][1] = y;
409			vlist[nvs][2] = z;
410			return(++nvs);
411			}
412
413
414	greg	2.3	static int
415	schorsch	2.8	newvn( /* create a new vertex normal */
416			double x,
417			double y,
418			double z
419			)
420	greg	2.1	{
421			if (!(nvns%CHUNKSIZ)) { /* allocate next block */
422			if (nvns == 0)
423			vnlist = (FVECT )malloc(CHUNKSIZsizeof(FVECT));
424			else
425	greg	2.4	vnlist = (FVECT )realloc((void )vnlist,
426	greg	2.1	(nvns+CHUNKSIZ)*sizeof(FVECT));
427	greg	2.2	if (vnlist == NULL)
428			error(SYSTEM, "out of memory in newvn");
429	greg	2.1	}
430			/* assign new normal */
431			vnlist[nvns][0] = x;
432			vnlist[nvns][1] = y;
433			vnlist[nvns][2] = z;
434			if (normalize(vnlist[nvns]) == 0.0)
435			return(0);
436			return(++nvns);
437			}
438
439
440	greg	2.3	static int
441	schorsch	2.8	newvt( /* create a new texture map vertex */
442			double x,
443			double y
444			)
445	greg	2.1	{
446			if (!(nvts%CHUNKSIZ)) { /* allocate next block */
447			if (nvts == 0)
448	schorsch	2.5	vtlist = (RREAL ()[2])malloc(CHUNKSIZ2*sizeof(RREAL));
449	greg	2.1	else
450	schorsch	2.5	vtlist = (RREAL ()[2])realloc((void )vtlist,
451			(nvts+CHUNKSIZ)2sizeof(RREAL));
452	greg	2.2	if (vtlist == NULL)
453			error(SYSTEM, "out of memory in newvt");
454	greg	2.1	}
455			/* assign new vertex */
456			vtlist[nvts][0] = x;
457			vtlist[nvts][1] = y;
458			return(++nvts);
459			}
460
461
462	greg	2.3	static void
463	schorsch	2.8	syntax( /* report syntax error and exit */
464			char *er
465			)
466	greg	2.1	{
467	greg	2.2	sprintf(errmsg, "%s: Wavefront syntax error near line %d: %s\n",
468	greg	2.1	inpfile, lineno, er);
469	greg	2.2	error(USER, errmsg);
470	greg	2.1	}