ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/cv/obj2rad.c

Comparing ray/src/cv/obj2rad.c (file contents):
Revision 2.4 by greg, Wed Apr 13 15:16:49 1994 UTC vs.
Revision 2.12 by greg, Wed Jun 15 12:52:19 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.
13	>	* I'm not sure they work correctly.  (Taken out -- see TEXMAPS defines.)
14		*/
15
16		#include "standard.h"
#	Line 20 | Line 20 | static char SCCSid[] = "$SunId$ LBL";
20		#include <ctype.h>
21
22		#define TCALNAME        "tmesh.cal"     /* triangle interp. file */
23	–	#define QCALNAME        "surf.cal"      /* quad interp. file */
23		#define PATNAME         "M-pat"         /* mesh pattern name (reused) */
24		#define TEXNAME         "M-nor"         /* mesh texture name (reused) */
25		#define DEFOBJ          "unnamed"       /* default object name */
#	Line 37 | Line 36 | int    nvns;
36		FLOAT   (*vtlist)[2];           /* map vertex list */
37		int     nvts;
38
39	<	typedef FLOAT   BARYCCM[3][4];  /* barycentric coordinate system */
39	>	typedef struct {
40	>	int     ax;             /* major axis */
41	>	FLOAT   tm[2][3];       /* transformation */
42	>	} BARYCCM;
43
44		typedef int     VNDX[3];        /* vertex index (point,map,normal) */
45
#	Line 69 | Line 71 | RULEHD *ourmapping = NULL;
71
72		char    *defmat = DEFMAT;       /* default (starting) material name */
73		char    *defobj = DEFOBJ;       /* default (starting) object name */
72	–	int     donames = 0;            /* only get qualifier names */
74
75	+	int     flatten = 0;            /* discard surface normal information */
76	+
77		char    *getmtl(), *getonm();
78
79		char    mapname[128];           /* current picture file */
80		char    matname[64];            /* current material name */
81		char    group[16][32];          /* current group names */
82		char    objname[128];           /* current object name */
83	+	char    *inpfile;               /* input file name */
84		int     lineno;                 /* current line number */
85	<	int     faceno;                 /* number of faces read */
85	>	int     faceno;                 /* current face number */
86
87
88		main(argc, argv)                /* read in .obj file and convert */
89		int     argc;
90		char    *argv[];
91		{
92	<	char    *fname;
92	>	int     donames = 0;
93		int     i;
94
95		for (i = 1; i < argc && argv[i][0] == '-'; i++)
#	Line 99 | Line 103 | char   *argv[];
103		case 'm':               /* use custom mapfile */
104		ourmapping = getmapping(argv[++i], &qlist);
105		break;
106	+	case 'f':               /* flatten surfaces */
107	+	flatten++;
108	+	break;
109		default:
110		goto userr;
111		}
112		if (i > argc | i < argc-1)
113		goto userr;
114		if (i == argc)
115	<	fname = "<stdin>";
116	<	else if (freopen(fname=argv[i], "r", stdin) == NULL) {
117	<	fprintf(stderr, "%s: cannot open\n", fname);
115	>	inpfile = "<stdin>";
116	>	else if (freopen(inpfile=argv[i], "r", stdin) == NULL) {
117	>	fprintf(stderr, "%s: cannot open\n", inpfile);
118		exit(1);
119		}
120		if (donames) {                          /* scan for ids */
121		getnames(stdin);
122	<	printf("filename \"%s\"\n", fname);
122	>	printf("filename \"%s\"\n", inpfile);
123		printf("filetype \"Wavefront\"\n");
124		write_quals(&qlist, qual, stdout);
125		printf("qualifier %s begin\n", qlist.qual[Q_FAC]);
#	Line 121 | Line 128 | char   *argv[];
128		} else {                                /* translate file */
129		printf("# ");
130		printargs(argc, argv, stdout);
131	<	convert(fname, stdin);
131	>	convert(stdin);
132		}
133		exit(0);
134		userr:
135	<	fprintf(stderr, "Usage: %s [-o obj][-m mapping][-n] [file.obj]\n",
135	>	fprintf(stderr, "Usage: %s [-o obj][-m mapping][-n][-f] [file.obj]\n",
136		argv[0]);
137		exit(1);
138		}
#	Line 180 | Line 187 | FILE   *fp;
187		}
188
189
190	<	convert(fname, fp)              /* convert a T-mesh */
184	<	char    *fname;
190	>	convert(fp)                     /* convert a T-mesh */
191		FILE    *fp;
192		{
193		char    *argv[MAXARG];
194		int     argc;
195		int     nstats, nunknown;
196		register int    i;
197	<	/* start fresh */
192	<	freeverts();
193	<	mapname[0] = '\0';
194	<	strcpy(matname, defmat);
195	<	strcpy(objname, defobj);
196	<	lineno = 0;
197	>
198		nstats = nunknown = 0;
199		/* scan until EOF */
200		while (argc = getstmt(argv, fp)) {
#	Line 202 | Line 203 | FILE   *fp;
203		switch (argv[0][1]) {
204		case '\0':                      /* point */
205		if (badarg(argc-1,argv+1,"fff"))
206	<	syntax(fname, lineno, "Bad vertex");
206	>	syntax("Bad vertex");
207		newv(atof(argv[1]), atof(argv[2]),
208		atof(argv[3]));
209		break;
#	Line 210 | Line 211 | FILE   *fp;
211		if (argv[0][2])
212		goto unknown;
213		if (badarg(argc-1,argv+1,"fff"))
214	<	syntax(fname, lineno, "Bad normal");
214	>	syntax("Bad normal");
215		if (!newvn(atof(argv[1]), atof(argv[2]),
216		atof(argv[3])))
217	<	syntax(fname, lineno, "Zero normal");
217	>	syntax("Zero normal");
218		break;
219		case 't':                       /* texture map */
220		if (argv[0][2])
#	Line 232 | Line 233 | FILE   *fp;
233		faceno++;
234		switch (argc-1) {
235		case 0: case 1: case 2:
236	<	syntax(fname, lineno, "Too few vertices");
236	>	syntax("Too few vertices");
237		break;
238		case 3:
239		if (!puttri(argv[1], argv[2], argv[3]))
240	<	syntax(fname, lineno, "Bad triangle");
240	>	syntax("Bad triangle");
241		break;
241	–	case 4:
242	–	if (!putquad(argv[1], argv[2],
243	–	argv[3], argv[4]))
244	–	syntax(fname, lineno, "Bad quad");
245	–	break;
242		default:
243		if (!putface(argc-1, argv+1))
244	<	syntax(fname, lineno, "Bad face");
244	>	syntax("Bad face");
245		break;
246		}
247		break;
#	Line 260 | Line 256 | FILE   *fp;
256		if (!strcmp(argv[1], "off"))
257		mapname[0] = '\0';
258		else
259	<	strcpy(mapname, argv[1]);
259	>	sprintf(mapname, "%s.pic", argv[1]);
260		} else
261		goto unknown;
262		break;
#	Line 279 | Line 275 | FILE   *fp;
275		group[i-1][0] = '\0';
276		break;
277		case '#':               /* comment */
278	+	printargs(argc, argv, stdout);
279		break;
280		default:;               /* something we don't deal with */
281		unknown:
#	Line 287 | Line 284 | FILE   *fp;
284		}
285		nstats++;
286		}
287	<	printf("\n# Done processing file: %s\n", fname);
287	>	printf("\n# Done processing file: %s\n", inpfile);
288		printf("# %d lines, %d statements, %d unrecognized\n",
289		lineno, nstats, nunknown);
290		}
#	Line 332 | Line 329 | getmtl()                               /* figure material for this face */
329		{
330		register RULEHD *rp = ourmapping;
331
332	<	if (rp == NULL)                 /* no rule set */
333	<	return(matname);
332	>	if (rp == NULL) {               /* no rule set */
333	>	if (matname[0])
334	>	return(matname);
335	>	if (group[0][0])
336	>	return(group[0]);
337	>	return(defmat);
338	>	}
339		/* check for match */
340		do {
341		if (matchrule(rp)) {
#	Line 354 | Line 356 | getonm()                               /* invent a good name for object */
356		static char     name[64];
357		register char   *cp1, *cp2;
358		register int    i;
359	<
360	<	if (!group[0][0] || strcmp(objname, DEFOBJ))
361	<	return(objname);        /* good enough for us */
362	<
359	>	/* check for preset */
360	>	if (objname[0])
361	>	return(objname);
362	>	if (!group[0][0])
363	>	return(defobj);
364		cp1 = name;                     /* else make name out of groups */
365		for (i = 0; group[i][0]; i++) {
366		cp2 = group[i];
#	Line 381 | Line 384 | register RULEHD        *rp;
384		register int    i;
385
386		if (rp->qflg & FL(Q_MTL)) {
387	+	if (!matname[0])
388	+	return(0);
389		tmpid.number = 0;
390		tmpid.name = matname;
391		if (!matchid(&tmpid, &idm(rp)[Q_MTL]))
392		return(0);
393		}
394		if (rp->qflg & FL(Q_MAP)) {
395	+	if (!mapname[0])
396	+	return(0);
397		tmpid.number = 0;
398		tmpid.name = mapname;
399		if (!matchid(&tmpid, &idm(rp)[Q_MAP]))
#	Line 403 | Line 410 | register RULEHD        *rp;
410		return(0);
411		}
412		if (rp->qflg & FL(Q_OBJ)) {
413	+	if (!objname[0])
414	+	return(0);
415		tmpid.number = 0;
416		tmpid.name = objname;
417		if (!matchid(&tmpid, &idm(rp)[Q_OBJ]))
#	Line 428 | Line 437 | register char  *vs;
437		if (vi[0]-- > nvs)
438		return(0);
439		} else if (vi[0] < 0) {
440	<	vi[0] = nvs + vi[0];
440	>	vi[0] += nvs;
441		if (vi[0] < 0)
442		return(0);
443		} else
#	Line 442 | Line 451 | register char  *vs;
451		if (vi[1]-- > nvts)
452		return(0);
453		} else if (vi[1] < 0) {
454	<	vi[1] = nvts + vi[1];
454	>	vi[1] += nvts;
455		if (vi[1] < 0)
456		return(0);
457		} else
#	Line 456 | Line 465 | register char  *vs;
465		if (vi[2]-- > nvns)
466		return(0);
467		} else if (vi[2] < 0) {
468	<	vi[2] = nvns + vi[2];
468	>	vi[2] += nvns;
469		if (vi[2] < 0)
470		return(0);
471		} else
#	Line 465 | Line 474 | register char  *vs;
474		}
475
476
477	<	putface(ac, av)                         /* put out an N-sided polygon */
477	>	nonplanar(ac, av)                       /* are vertices non-planar? */
478		register int    ac;
479		register char   **av;
480		{
481		VNDX    vi;
482	<	char    *mod;
482	>	FLOAT   *p0, *p1;
483	>	FVECT   v1, v2, nsum, newn;
484	>	double  d;
485	>	register int    i;
486
487	<	if ((mod = getmtl()) == NULL)
487	>	if (!cvtndx(vi, av[0]))
488	>	return(0);
489	>	if (!flatten && vi[2] >= 0)
490	>	return(1);              /* has interpolated normals */
491	>	if (ac < 4)
492	>	return(0);              /* it's a triangle! */
493	>	/* set up */
494	>	p0 = vlist[vi[0]];
495	>	if (!cvtndx(vi, av[1]))
496	>	return(0);              /* error gets caught later */
497	>	nsum[0] = nsum[1] = nsum[2] = 0.;
498	>	p1 = vlist[vi[0]];
499	>	fvsum(v2, p1, p0, -1.0);
500	>	for (i = 2; i < ac; i++) {
501	>	VCOPY(v1, v2);
502	>	if (!cvtndx(vi, av[i]))
503	>	return(0);
504	>	p1 = vlist[vi[0]];
505	>	fvsum(v2, p1, p0, -1.0);
506	>	fcross(newn, v1, v2);
507	>	if (normalize(newn) == 0.0) {
508	>	if (i < 3)
509	>	return(1);      /* can't deal with this */
510	>	fvsum(nsum, nsum, nsum, 1./(i-2));
511	>	continue;
512	>	}
513	>	d = fdot(newn,nsum);
514	>	if (d >= 0) {
515	>	if (d < (1.0-FTINY)*(i-2))
516	>	return(1);
517	>	fvsum(nsum, nsum, newn, 1.0);
518	>	} else {
519	>	if (d > -(1.0-FTINY)*(i-2))
520	>	return(1);
521	>	fvsum(nsum, nsum, newn, -1.0);
522	>	}
523	>	}
524	>	return(0);
525	>	}
526	>
527	>
528	>	putface(ac, av)                         /* put out an N-sided polygon */
529	>	int     ac;
530	>	register char   **av;
531	>	{
532	>	VNDX    vi;
533	>	char    *cp;
534	>	register int    i;
535	>
536	>	if (nonplanar(ac, av)) {        /* break into triangles */
537	>	while (ac > 2) {
538	>	if (!puttri(av[0], av[1], av[2]))
539	>	return(0);
540	>	ac--;           /* remove vertex & rotate */
541	>	cp = av[0];
542	>	for (i = 0; i < ac-1; i++)
543	>	av[i] = av[i+2];
544	>	av[i] = cp;
545	>	}
546	>	return(1);
547	>	}
548	>	if ((cp = getmtl()) == NULL)
549		return(-1);
550	<	printf("\n%s polygon %s.%d\n", mod, getonm(), faceno);
550	>	printf("\n%s polygon %s.%d\n", cp, getonm(), faceno);
551		printf("0\n0\n%d\n", 3*ac);
552	<	while (ac--) {
553	<	if (!cvtndx(vi, *av++))
552	>	for (i = 0; i < ac; i++) {
553	>	if (!cvtndx(vi, av[i]))
554		return(0);
555		pvect(vlist[vi[0]]);
556		}
#	Line 499 | Line 572 | char   *v1, *v2, *v3;
572		if (!cvtndx(v1i, v1) || !cvtndx(v2i, v2) || !cvtndx(v3i, v3))
573		return(0);
574		/* compute barycentric coordinates */
575	<	texOK = (v1i[2]>=0 && v2i[2]>=0 && v3i[2]>=0);
575	>	texOK = !flatten && (v1i[2]>=0 && v2i[2]>=0 && v3i[2]>=0);
576	>	#ifdef TEXMAPS
577		patOK = mapname[0] && (v1i[1]>=0 && v2i[1]>=0 && v3i[1]>=0);
578	+	#else
579	+	patOK = 0;
580	+	#endif
581		if (texOK | patOK)
582	<	if (comp_baryc(bvecs, vlist[v1i[0]], vlist[v2i[0]],
582	>	if (comp_baryc(&bvecs, vlist[v1i[0]], vlist[v2i[0]],
583		vlist[v3i[0]]) < 0)
584		return(-1);
585		/* put out texture (if any) */
#	Line 510 | Line 587 | char   *v1, *v2, *v3;
587		printf("\n%s texfunc %s\n", mod, TEXNAME);
588		mod = TEXNAME;
589		printf("4 dx dy dz %s\n", TCALNAME);
590	<	printf("0\n21\n");
591	<	put_baryc(bvecs);
590	>	printf("0\n16 ");
591	>	put_baryc(&bvecs);
592		printf("\t%14.12g %14.12g %14.12g\n",
593		vnlist[v1i[2]][0], vnlist[v2i[2]][0],
594		vnlist[v3i[2]][0]);
#	Line 522 | Line 599 | char   *v1, *v2, *v3;
599		vnlist[v1i[2]][2], vnlist[v2i[2]][2],
600		vnlist[v3i[2]][2]);
601		}
602	+	#ifdef TEXMAPS
603		/* put out pattern (if any) */
604		if (patOK) {
605		printf("\n%s colorpict %s\n", mod, PATNAME);
606		mod = PATNAME;
607		printf("7 noneg noneg noneg %s %s u v\n", mapname, TCALNAME);
608	<	printf("0\n18\n");
609	<	put_baryc(bvecs);
608	>	printf("0\n13 ");
609	>	put_baryc(&bvecs);
610		printf("\t%f %f %f\n", vtlist[v1i[1]][0],
611		vtlist[v2i[1]][0], vtlist[v3i[1]][0]);
612		printf("\t%f %f %f\n", vtlist[v1i[1]][1],
613		vtlist[v2i[1]][1], vtlist[v3i[1]][1]);
614		}
615	+	#endif
616		/* put out triangle */
617		printf("\n%s polygon %s.%d\n", mod, getonm(), faceno);
618		printf("0\n0\n9\n");
#	Line 547 | Line 626 | char   *v1, *v2, *v3;
626
627		int
628		comp_baryc(bcm, v1, v2, v3)             /* compute barycentric vectors */
629	<	register BARYCCM        bcm;
629	>	register BARYCCM        *bcm;
630		FLOAT   *v1, *v2, *v3;
631		{
632		FLOAT   *vt;
633		FVECT   va, vab, vcb;
634		double  d;
635	+	int     ax0, ax1;
636		register int    i, j;
637	<
638	<	for (j = 0; j < 3; j++) {
639	<	for (i = 0; i < 3; i++) {
640	<	vab[i] = v1[i] - v2[i];
641	<	vcb[i] = v3[i] - v2[i];
642	<	}
643	<	d = DOT(vcb,vcb);
637	>	/* compute major axis */
638	>	for (i = 0; i < 3; i++) {
639	>	vab[i] = v1[i] - v2[i];
640	>	vcb[i] = v3[i] - v2[i];
641	>	}
642	>	fcross(va, vab, vcb);
643	>	bcm->ax = ABS(va[0]) > ABS(va[1]) ? 0 : 1;
644	>	bcm->ax = ABS(va[bcm->ax]) > ABS(va[2]) ? bcm->ax : 2;
645	>	ax0 = (bcm->ax + 1) % 3;
646	>	ax1 = (bcm->ax + 2) % 3;
647	>	for (j = 0; j < 2; j++) {
648	>	vab[0] = v1[ax0] - v2[ax0];
649	>	vcb[0] = v3[ax0] - v2[ax0];
650	>	vab[1] = v1[ax1] - v2[ax1];
651	>	vcb[1] = v3[ax1] - v2[ax1];
652	>	d = vcb[0]*vcb[0] + vcb[1]*vcb[1];
653		if (d <= FTINY)
654		return(-1);
655	<	d = DOT(vcb,vab)/d;
656	<	for (i = 0; i < 3; i++)
657	<	va[i] = vab[i] - vcb[i]*d;
658	<	d = DOT(va,va);
655	>	d = (vcb[0]*vab[0]+vcb[1]*vab[1])/d;
656	>	va[0] = vab[0] - vcb[0]*d;
657	>	va[1] = vab[1] - vcb[1]*d;
658	>	d = va[0]*va[0] + va[1]*va[1];
659		if (d <= FTINY)
660		return(-1);
661	<	for (i = 0; i < 3; i++) {
662	<	va[i] /= d;
663	<	bcm[j][i] = va[i];
575	<	}
576	<	bcm[j][3] = -DOT(v2,va);
661	>	bcm->tm[j][0] = va[0] /= d;
662	>	bcm->tm[j][1] = va[1] /= d;
663	>	bcm->tm[j][2] = -(v2[ax0]*va[0]+v2[ax1]*va[1]);
664		/* rotate vertices */
665		vt = v1;
666		v1 = v2;
#	Line 585 | Line 672 | FLOAT  *v1, *v2, *v3;
672
673
674		put_baryc(bcm)                          /* put barycentric coord. vectors */
675	<	register BARYCCM        bcm;
675	>	register BARYCCM        *bcm;
676		{
677	<	register int    i;
678	<
679	<	for (i = 0; i < 3; i++)
680	<	printf("%14.8f %14.8f %14.8f %14.8f\n",
681	<	bcm[i][0], bcm[i][1], bcm[i][2], bcm[i][3]);
677	>	printf("\t%d\n", bcm->ax);
678	>	printf("%14.8f %14.8f %14.8f\n",
679	>	bcm->tm[0][0], bcm->tm[0][1], bcm->tm[0][2]);
680	>	printf("%14.8f %14.8f %14.8f\n",
681	>	bcm->tm[1][0], bcm->tm[1][1], bcm->tm[1][2]);
682		}
683
684
598	–	putquad(p0, p1, p3, p2)                 /* put out a quadrilateral */
599	–	char  *p0, *p1, *p3, *p2;               /* names correspond to binary pos. */
600	–	{
601	–	VNDX  p0i, p1i, p2i, p3i;
602	–	FVECT  norm[4];
603	–	char  *mod, *name;
604	–	int  axis;
605	–	FVECT  v1, v2, vc1, vc2;
606	–	int  ok1, ok2;
607	–
608	–	if ((mod = getmtl()) == NULL)
609	–	return(-1);
610	–	name = getonm();
611	–	/* get actual indices */
612	–	if (!cvtndx(p0i,p0) || !cvtndx(p1i,p1) ||
613	–	!cvtndx(p2i,p2) || !cvtndx(p3i,p3))
614	–	return(0);
615	–	/* compute exact normals */
616	–	fvsum(v1, vlist[p1i[0]], vlist[p0i[0]], -1.0);
617	–	fvsum(v2, vlist[p2i[0]], vlist[p0i[0]], -1.0);
618	–	fcross(vc1, v1, v2);
619	–	ok1 = normalize(vc1) != 0.0;
620	–	fvsum(v1, vlist[p2i[0]], vlist[p3i[0]], -1.0);
621	–	fvsum(v2, vlist[p1i[0]], vlist[p3i[0]], -1.0);
622	–	fcross(vc2, v1, v2);
623	–	ok2 = normalize(vc2) != 0.0;
624	–	if (!(ok1 | ok2))
625	–	return(-1);
626	–	/* compute normal interpolation */
627	–	axis = norminterp(norm, p0i, p1i, p2i, p3i);
628	–
629	–	/* put out quadrilateral? */
630	–	if (ok1 & ok2 && fdot(vc1,vc2) >= 1.0-FTINY*FTINY) {
631	–	printf("\n%s ", mod);
632	–	if (axis != -1) {
633	–	printf("texfunc %s\n", TEXNAME);
634	–	printf("4 surf_dx surf_dy surf_dz %s\n", QCALNAME);
635	–	printf("0\n13\t%d\n", axis);
636	–	pvect(norm[0]);
637	–	pvect(norm[1]);
638	–	pvect(norm[2]);
639	–	fvsum(v1, norm[3], vc1, -0.5);
640	–	fvsum(v1, v1, vc2, -0.5);
641	–	pvect(v1);
642	–	printf("\n%s ", TEXNAME);
643	–	}
644	–	printf("polygon %s.%d\n", name, faceno);
645	–	printf("0\n0\n12\n");
646	–	pvect(vlist[p0i[0]]);
647	–	pvect(vlist[p1i[0]]);
648	–	pvect(vlist[p3i[0]]);
649	–	pvect(vlist[p2i[0]]);
650	–	return(1);
651	–	}
652	–	/* put out triangles? */
653	–	if (ok1) {
654	–	printf("\n%s ", mod);
655	–	if (axis != -1) {
656	–	printf("texfunc %s\n", TEXNAME);
657	–	printf("4 surf_dx surf_dy surf_dz %s\n", QCALNAME);
658	–	printf("0\n13\t%d\n", axis);
659	–	pvect(norm[0]);
660	–	pvect(norm[1]);
661	–	pvect(norm[2]);
662	–	fvsum(v1, norm[3], vc1, -1.0);
663	–	pvect(v1);
664	–	printf("\n%s ", TEXNAME);
665	–	}
666	–	printf("polygon %s.%da\n", name, faceno);
667	–	printf("0\n0\n9\n");
668	–	pvect(vlist[p0i[0]]);
669	–	pvect(vlist[p1i[0]]);
670	–	pvect(vlist[p2i[0]]);
671	–	}
672	–	if (ok2) {
673	–	printf("\n%s ", mod);
674	–	if (axis != -1) {
675	–	printf("texfunc %s\n", TEXNAME);
676	–	printf("4 surf_dx surf_dy surf_dz %s\n", QCALNAME);
677	–	printf("0\n13\t%d\n", axis);
678	–	pvect(norm[0]);
679	–	pvect(norm[1]);
680	–	pvect(norm[2]);
681	–	fvsum(v2, norm[3], vc2, -1.0);
682	–	pvect(v2);
683	–	printf("\n%s ", TEXNAME);
684	–	}
685	–	printf("polygon %s.%db\n", name, faceno);
686	–	printf("0\n0\n9\n");
687	–	pvect(vlist[p2i[0]]);
688	–	pvect(vlist[p1i[0]]);
689	–	pvect(vlist[p3i[0]]);
690	–	}
691	–	return(1);
692	–	}
693	–
694	–
695	–	int
696	–	norminterp(resmat, p0i, p1i, p2i, p3i)  /* compute normal interpolation */
697	–	register FVECT  resmat[4];
698	–	register VNDX  p0i, p1i, p2i, p3i;
699	–	{
700	–	#define u  ((ax+1)%3)
701	–	#define v  ((ax+2)%3)
702	–
703	–	register int  ax;
704	–	MAT4  eqnmat;
705	–	FVECT  v1;
706	–	register int  i, j;
707	–
708	–	if (!(p0i[2]>=0 && p1i[2]>=0 && p2i[2]>=0 && p3i[2]>=0))
709	–	return(-1);
710	–	/* find dominant axis */
711	–	VCOPY(v1, vnlist[p0i[2]]);
712	–	fvsum(v1, v1, vnlist[p1i[2]], 1.0);
713	–	fvsum(v1, v1, vnlist[p2i[2]], 1.0);
714	–	fvsum(v1, v1, vnlist[p3i[2]], 1.0);
715	–	ax = ABS(v1[0]) > ABS(v1[1]) ? 0 : 1;
716	–	ax = ABS(v1[ax]) > ABS(v1[2]) ? ax : 2;
717	–	/* assign equation matrix */
718	–	eqnmat[0][0] = vlist[p0i[0]][u]*vlist[p0i[0]][v];
719	–	eqnmat[0][1] = vlist[p0i[0]][u];
720	–	eqnmat[0][2] = vlist[p0i[0]][v];
721	–	eqnmat[0][3] = 1.0;
722	–	eqnmat[1][0] = vlist[p1i[0]][u]*vlist[p1i[0]][v];
723	–	eqnmat[1][1] = vlist[p1i[0]][u];
724	–	eqnmat[1][2] = vlist[p1i[0]][v];
725	–	eqnmat[1][3] = 1.0;
726	–	eqnmat[2][0] = vlist[p2i[0]][u]*vlist[p2i[0]][v];
727	–	eqnmat[2][1] = vlist[p2i[0]][u];
728	–	eqnmat[2][2] = vlist[p2i[0]][v];
729	–	eqnmat[2][3] = 1.0;
730	–	eqnmat[3][0] = vlist[p3i[0]][u]*vlist[p3i[0]][v];
731	–	eqnmat[3][1] = vlist[p3i[0]][u];
732	–	eqnmat[3][2] = vlist[p3i[0]][v];
733	–	eqnmat[3][3] = 1.0;
734	–	/* invert matrix (solve system) */
735	–	if (!invmat4(eqnmat, eqnmat))
736	–	return(-1);                     /* no solution */
737	–	/* compute result matrix */
738	–	for (j = 0; j < 4; j++)
739	–	for (i = 0; i < 3; i++)
740	–	resmat[j][i] =  eqnmat[j][0]*vnlist[p0i[2]][i] +
741	–	eqnmat[j][1]*vnlist[p1i[2]][i] +
742	–	eqnmat[j][2]*vnlist[p2i[2]][i] +
743	–	eqnmat[j][3]*vnlist[p3i[2]][i];
744	–	return(ax);
745	–
746	–	#undef u
747	–	#undef v
748	–	}
749	–
750	–
685		freeverts()                     /* free all vertices */
686		{
687		if (nvs) {
#	Line 839 | Line 773 | double x, y;
773		}
774
775
776	<	syntax(fn, ln, er)                      /* report syntax error and exit */
843	<	char    *fn;
844	<	int     ln;
776	>	syntax(er)                      /* report syntax error and exit */
777		char    *er;
778		{
779		fprintf(stderr, "%s: Wavefront syntax error near line %d: %s\n",
780	<	fn, ln, er);
780	>	inpfile, lineno, er);
781		exit(1);
782		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)