[ViewVC] Diff of: radiance/ray/src/cv/obj2rad.c

Comparing ray/src/cv/obj2rad.c (file contents):
Revision 2.3 by greg, Wed Apr 13 14:08:55 1994 UTC vs.
Revision 2.26 by greg, Thu Sep 16 03:28:21 2010 UTC

#	Line 1 \| Line 1
1	–	/* Copyright (c) 1994 Regents of the University of California */
2	–
1		#ifndef lint
2	<	static char SCCSid[] = "$SunId$ LBL";
2	>	static const char RCSid[] = "$Id$";
3		#endif
6	–
4		/*
5		* Convert a Wavefront .obj file to Radiance format.
6		*
7	<	* Currently, we support only polygonal geometry, and faces
8	<	* must be either quads or triangles for smoothing to work.
7	>	* Currently, we support only polygonal geometry. Non-planar
8	>	* faces are broken rather haphazardly into triangles.
9		* Also, texture map indices only work for triangles, though
10	<	* I'm not sure they work correctly.
10	>	* I'm not sure they work correctly. (Taken out -- see TEXMAPS defines.)
11		*/
12
13	<	#include "standard.h"
13	>	#include <stdlib.h>
14	>	#include <stdio.h>
15	>	#include <ctype.h>
16
17	+	#include "rtmath.h"
18	+	#include "rtio.h"
19	+	#include "resolu.h"
20		#include "trans.h"
21	+	#include "tmesh.h"
22
20	–	#include <ctype.h>
23
22	–	#define TCALNAME "tmesh.cal" /* triangle interp. file */
23	–	#define QCALNAME "surf.cal" /* quad interp. file */
24		#define PATNAME "M-pat" /* mesh pattern name (reused) */
25		#define TEXNAME "M-nor" /* mesh texture name (reused) */
26		#define DEFOBJ "unnamed" /* default object name */
27		#define DEFMAT "white" /* default material name */
28
29	–	#define ABS(x) ((x)>=0 ? (x) : -(x))
30	–
29		#define pvect(v) printf("%18.12g %18.12g %18.12g\n",(v)[0],(v)[1],(v)[2])
30
31		FVECT vlist; / our vertex list */
32		int nvs; /* number of vertices in our list */
33		FVECT vnlist; / vertex normal list */
34		int nvns;
35	<	FLOAT (vtlist)[2]; / map vertex list */
35	>	RREAL (vtlist)[2]; / map vertex list */
36		int nvts;
37
38	<	typedef FLOAT BARYCCM[3][4]; /* barycentric coordinate system */
38	>	int ndegen = 0; /* count of degenerate faces */
39	>	int n0norm = 0; /* count of zero normals */
40
41		typedef int VNDX[3]; /* vertex index (point,map,normal) */
42
43	<	#define CHUNKSIZ 256 /* vertex allocation chunk size */
43	>	#define CHUNKSIZ 1024 /* vertex allocation chunk size */
44
45	<	#define MAXARG 64 /* maximum # arguments in a statement */
45	>	#define MAXARG 512 /* maximum # arguments in a statement */
46
47		/* qualifiers */
48		#define Q_MTL 0
#	Line 69 \| Line 68 \| *RULEHD ourmapping = NULL;**
68
69		char defmat = DEFMAT; / default (starting) material name */
70		char defobj = DEFOBJ; / default (starting) object name */
72	–	int donames = 0; /* only get qualifier names */
71
72	<	char getmtl(), getonm();
72	>	int flatten = 0; /* discard surface normal information */
73
74		char mapname[128]; /* current picture file */
75		char matname[64]; /* current material name */
76		char group[16][32]; /* current group names */
77		char objname[128]; /* current object name */
78	+	char inpfile; / input file name */
79		int lineno; /* current line number */
80	<	int faceno; /* number of faces read */
80	>	int faceno; /* current face number */
81
82	+	static void getnames(FILE *fp);
83	+	static void convert(FILE *fp);
84	+	static int getstmt(char av[MAXARG], FILE fp);
85	+	static char * getmtl(void);
86	+	static char * getonm(void);
87	+	static int matchrule(RULEHD *rp);
88	+	static int cvtndx(VNDX vi, char *vs);
89	+	static int nonplanar(int ac, char **av);
90	+	static int putface(int ac, char **av);
91	+	static int puttri(char v1, char v2, char *v3);
92	+	static void freeverts(void);
93	+	static int newv(double x, double y, double z);
94	+	static int newvn(double x, double y, double z);
95	+	static int newvt(double x, double y);
96	+	static void syntax(char *er);
97
98	<	main(argc, argv) /* read in .obj file and convert */
99	<	int argc;
100	<	char *argv[];
98	>
99	>	int
100	>	main( /* read in .obj file and convert */
101	>	int argc,
102	>	char *argv[]
103	>	)
104		{
105	<	char *fname;
105	>	int donames = 0;
106		int i;
107
108		for (i = 1; i < argc && argv[i][0] == '-'; i++)
#	Line 99 \| Line 116 \| *char argv[];**
116		case 'm': /* use custom mapfile */
117		ourmapping = getmapping(argv[++i], &qlist);
118		break;
119	+	case 'f': /* flatten surfaces */
120	+	flatten++;
121	+	break;
122		default:
123		goto userr;
124		}
125	<	if (i > argc \| i < argc-1)
125	>	if ((i > argc) \| (i < argc-1))
126		goto userr;
127		if (i == argc)
128	<	fname = "<stdin>";
129	<	else if (freopen(fname=argv[i], "r", stdin) == NULL) {
130	<	fprintf(stderr, "%s: cannot open\n", fname);
128	>	inpfile = "<stdin>";
129	>	else if (freopen(inpfile=argv[i], "r", stdin) == NULL) {
130	>	fprintf(stderr, "%s: cannot open\n", inpfile);
131		exit(1);
132		}
133		if (donames) { /* scan for ids */
134		getnames(stdin);
135	<	printf("filename \"%s\"\n", fname);
135	>	printf("filename \"%s\"\n", inpfile);
136		printf("filetype \"Wavefront\"\n");
137		write_quals(&qlist, qual, stdout);
138		printf("qualifier %s begin\n", qlist.qual[Q_FAC]);
#	Line 121 \| Line 141 \| *char argv[];**
141		} else { /* translate file */
142		printf("# ");
143		printargs(argc, argv, stdout);
144	<	convert(fname, stdin);
144	>	convert(stdin);
145		}
146	+	if (ndegen)
147	+	printf("# %d degenerate faces\n", ndegen);
148	+	if (n0norm)
149	+	printf("# %d invalid (zero) normals\n", n0norm);
150		exit(0);
151		userr:
152	<	fprintf(stderr, "Usage: %s [-o obj][-m mapping][-n] [file.obj]\n",
152	>	fprintf(stderr, "Usage: %s [-o obj][-m mapping][-n][-f] [file.obj]\n",
153		argv[0]);
154		exit(1);
155		}
156
157
158	<	getnames(fp) /* get valid qualifier names */
159	<	FILE *fp;
158	>	void
159	>	getnames( /* get valid qualifier names */
160	>	FILE *fp
161	>	)
162		{
163		char *argv[MAXARG];
164		int argc;
165		ID tmpid;
166		register int i;
167
168	<	while (argc = getstmt(argv, fp))
168	>	while ( (argc = getstmt(argv, fp)) )
169		switch (argv[0][0]) {
170		case 'f': /* face */
171		if (!argv[0][1])
#	Line 180 \| Line 206 \| *FILE fp;**
206		}
207
208
209	<	convert(fname, fp) /* convert a T-mesh */
210	<	char *fname;
211	<	FILE *fp;
209	>	void
210	>	convert( /* convert a T-mesh */
211	>	FILE *fp
212	>	)
213		{
214		char *argv[MAXARG];
215		int argc;
216		int nstats, nunknown;
217		register int i;
218	<	/* start fresh */
192	<	freeverts();
193	<	mapname[0] = '\0';
194	<	strcpy(matname, defmat);
195	<	strcpy(objname, defobj);
196	<	lineno = 0;
218	>
219		nstats = nunknown = 0;
220		/* scan until EOF */
221	<	while (argc = getstmt(argv, fp)) {
221	>	while ( (argc = getstmt(argv, fp)) ) {
222		switch (argv[0][0]) {
223		case 'v': /* vertex */
224		switch (argv[0][1]) {
225		case '\0': /* point */
226		if (badarg(argc-1,argv+1,"fff"))
227	<	syntax(fname, lineno, "Bad vertex");
227	>	syntax("Bad vertex");
228		newv(atof(argv[1]), atof(argv[2]),
229		atof(argv[3]));
230		break;
#	Line 210 \| Line 232 \| *FILE fp;**
232		if (argv[0][2])
233		goto unknown;
234		if (badarg(argc-1,argv+1,"fff"))
235	<	syntax(fname, lineno, "Bad normal");
235	>	syntax("Bad normal");
236		if (!newvn(atof(argv[1]), atof(argv[2]),
237		atof(argv[3])))
238	<	syntax(fname, lineno, "Zero normal");
238	>	syntax("Zero normal");
239		break;
240		case 't': /* texture map */
241		if (argv[0][2])
#	Line 232 \| Line 254 \| *FILE fp;**
254		faceno++;
255		switch (argc-1) {
256		case 0: case 1: case 2:
257	<	syntax(fname, lineno, "Too few vertices");
257	>	syntax("Too few vertices");
258		break;
259		case 3:
260		if (!puttri(argv[1], argv[2], argv[3]))
261	<	syntax(fname, lineno, "Bad triangle");
261	>	syntax("Bad triangle");
262		break;
241	–	case 4:
242	–	if (!putquad(argv[1], argv[2],
243	–	argv[3], argv[4]))
244	–	syntax(fname, lineno, "Bad quad");
245	–	break;
263		default:
264		if (!putface(argc-1, argv+1))
265	<	syntax(fname, lineno, "Bad face");
265	>	syntax("Bad face");
266		break;
267		}
268		break;
#	Line 260 \| Line 277 \| *FILE fp;**
277		if (!strcmp(argv[1], "off"))
278		mapname[0] = '\0';
279		else
280	<	strcpy(mapname, argv[1]);
280	>	sprintf(mapname, "%s.hdr", argv[1]);
281		} else
282		goto unknown;
283		break;
#	Line 279 \| Line 296 \| *FILE fp;**
296		group[i-1][0] = '\0';
297		break;
298		case '#': /* comment */
299	+	printargs(argc, argv, stdout);
300		break;
301		default:; /* something we don't deal with */
302		unknown:
#	Line 287 \| Line 305 \| *FILE fp;**
305		}
306		nstats++;
307		}
308	<	printf("\n# Done processing file: %s\n", fname);
308	>	printf("\n# Done processing file: %s\n", inpfile);
309		printf("# %d lines, %d statements, %d unrecognized\n",
310		lineno, nstats, nunknown);
311		}
312
313
314		int
315	<	getstmt(av, fp) /* read the next statement from fp */
316	<	register char *av[MAXARG];
317	<	FILE *fp;
315	>	getstmt( /* read the next statement from fp */
316	>	register char *av[MAXARG],
317	>	FILE *fp
318	>	)
319		{
320	<	extern char *fgetline();
302	<	static char sbuf[MAXARG*10];
320	>	static char sbuf[MAXARG*16];
321		register char *cp;
322		register int i;
323
#	Line 313 \| Line 331 \| *FILE fp;**
331		lineno++;
332		*cp++ = '\0';
333		}
334	<	if (!*cp \|\| i >= MAXARG-1)
334	>	if (!*cp)
335		break;
336	+	if (i >= MAXARG-1) {
337	+	fprintf(stderr,
338	+	"warning: line %d: too many arguments (limit %d)\n",
339	+	lineno+1, MAXARG-1);
340	+	break;
341	+	}
342		av[i++] = cp;
343		while (++cp && !isspace(cp))
344		;
#	Line 328 \| Line 352 \| *FILE fp;**
352
353
354		char *
355	<	getmtl() /* figure material for this face */
355	>	getmtl(void) /* figure material for this face */
356		{
357		register RULEHD *rp = ourmapping;
358
359	<	if (rp == NULL) /* no rule set */
360	<	return(matname);
359	>	if (rp == NULL) { /* no rule set */
360	>	if (matname[0])
361	>	return(matname);
362	>	if (group[0][0])
363	>	return(group[0]);
364	>	return(defmat);
365	>	}
366		/* check for match */
367		do {
368		if (matchrule(rp)) {
#	Line 349 \| Line 378 \| *getmtl() / figure material for this face /*
378
379
380		char *
381	<	getonm() /* invent a good name for object */
381	>	getonm(void) /* invent a good name for object */
382		{
383		static char name[64];
384		register char cp1, cp2;
385		register int i;
386	<
387	<	if (!group[0][0] \|\| strcmp(objname, DEFOBJ))
388	<	return(objname); /* good enough for us */
389	<
386	>	/* check for preset */
387	>	if (objname[0])
388	>	return(objname);
389	>	if (!group[0][0])
390	>	return(defobj);
391		cp1 = name; /* else make name out of groups */
392		for (i = 0; group[i][0]; i++) {
393		cp2 = group[i];
394		if (cp1 > name)
395		*cp1++ = '.';
396	<	while (cp1 = cp2++)
396	>	while ( (cp1 = cp2++) )
397		if (++cp1 >= name+sizeof(name)-2) {
398		*cp1 = '\0';
399		return(name);
#	Line 373 \| Line 403 \| *getonm() / invent a good name for object /*
403		}
404
405
406	<	matchrule(rp) /* check for a match on this rule */
407	<	register RULEHD *rp;
406	>	int
407	>	matchrule( /* check for a match on this rule */
408	>	register RULEHD *rp
409	>	)
410		{
411		ID tmpid;
412		int gotmatch;
413		register int i;
414
415		if (rp->qflg & FL(Q_MTL)) {
416	+	if (!matname[0])
417	+	return(0);
418		tmpid.number = 0;
419		tmpid.name = matname;
420		if (!matchid(&tmpid, &idm(rp)[Q_MTL]))
421		return(0);
422		}
423		if (rp->qflg & FL(Q_MAP)) {
424	+	if (!mapname[0])
425	+	return(0);
426		tmpid.number = 0;
427		tmpid.name = mapname;
428		if (!matchid(&tmpid, &idm(rp)[Q_MAP]))
#	Line 403 \| Line 439 \| *register RULEHD rp;**
439		return(0);
440		}
441		if (rp->qflg & FL(Q_OBJ)) {
442	+	if (!objname[0])
443	+	return(0);
444		tmpid.number = 0;
445		tmpid.name = objname;
446		if (!matchid(&tmpid, &idm(rp)[Q_OBJ]))
#	Line 418 \| Line 456 \| *register RULEHD rp;**
456		}
457
458
459	<	cvtndx(vi, vs) /* convert vertex string to index */
460	<	register VNDX vi;
461	<	register char *vs;
459	>	int
460	>	cvtndx( /* convert vertex string to index */
461	>	register VNDX vi,
462	>	register char *vs
463	>	)
464		{
465		/* get point */
466		vi[0] = atoi(vs);
#	Line 428 \| Line 468 \| *register char vs;**
468		if (vi[0]-- > nvs)
469		return(0);
470		} else if (vi[0] < 0) {
471	<	vi[0] = nvs + vi[0];
471	>	vi[0] += nvs;
472		if (vi[0] < 0)
473		return(0);
474		} else
#	Line 442 \| Line 482 \| *register char vs;**
482		if (vi[1]-- > nvts)
483		return(0);
484		} else if (vi[1] < 0) {
485	<	vi[1] = nvts + vi[1];
485	>	vi[1] += nvts;
486		if (vi[1] < 0)
487		return(0);
488		} else
#	Line 456 \| Line 496 \| *register char vs;**
496		if (vi[2]-- > nvns)
497		return(0);
498		} else if (vi[2] < 0) {
499	<	vi[2] = nvns + vi[2];
499	>	vi[2] += nvns;
500		if (vi[2] < 0)
501		return(0);
502		} else
503		vi[2] = -1;
504	+	/* zero normal is not normal */
505	+	if (vi[2] >= 0 && DOT(vnlist[vi[2]],vnlist[vi[2]]) <= FTINY)
506	+	vi[2] = -1;
507		return(1);
508		}
509
510
511	<	putface(ac, av) /* put out an N-sided polygon */
512	<	register int ac;
513	<	register char **av;
511	>	int
512	>	nonplanar( /* are vertices non-planar? */
513	>	register int ac,
514	>	register char **av
515	>	)
516		{
517		VNDX vi;
518	<	char *mod;
518	>	RREAL p0, p1;
519	>	FVECT v1, v2, nsum, newn;
520	>	double d;
521	>	register int i;
522
523	<	if ((mod = getmtl()) == NULL)
524	<	return(-1);
525	<	printf("\n%s polygon %s.%d\n", mod, getonm(), faceno);
523	>	if (!cvtndx(vi, av[0]))
524	>	return(0);
525	>	if (!flatten && vi[2] >= 0)
526	>	return(1); /* has interpolated normals */
527	>	if (ac < 4)
528	>	return(0); /* it's a triangle! */
529	>	/* set up */
530	>	p0 = vlist[vi[0]];
531	>	if (!cvtndx(vi, av[1]))
532	>	return(0); /* error gets caught later */
533	>	nsum[0] = nsum[1] = nsum[2] = 0.;
534	>	p1 = vlist[vi[0]];
535	>	fvsum(v2, p1, p0, -1.0);
536	>	for (i = 2; i < ac; i++) {
537	>	VCOPY(v1, v2);
538	>	if (!cvtndx(vi, av[i]))
539	>	return(0);
540	>	p1 = vlist[vi[0]];
541	>	fvsum(v2, p1, p0, -1.0);
542	>	fcross(newn, v1, v2);
543	>	if (normalize(newn) == 0.0) {
544	>	if (i < 3)
545	>	return(1); /* can't deal with this */
546	>	fvsum(nsum, nsum, nsum, 1./(i-2));
547	>	continue;
548	>	}
549	>	d = fdot(newn,nsum);
550	>	if (d >= 0) {
551	>	if (d < (1.0-FTINY)*(i-2))
552	>	return(1);
553	>	fvsum(nsum, nsum, newn, 1.0);
554	>	} else {
555	>	if (d > -(1.0-FTINY)*(i-2))
556	>	return(1);
557	>	fvsum(nsum, nsum, newn, -1.0);
558	>	}
559	>	}
560	>	return(0);
561	>	}
562	>
563	>
564	>	int
565	>	putface( /* put out an N-sided polygon */
566	>	int ac,
567	>	register char **av
568	>	)
569	>	{
570	>	VNDX vi;
571	>	char *cp;
572	>	register int i;
573	>
574	>	if (nonplanar(ac, av)) { /* break into triangles */
575	>	while (ac > 2) {
576	>	if (!puttri(av[0], av[1], av[2]))
577	>	return(0);
578	>	ac--; /* remove vertex & rotate */
579	>	cp = av[0];
580	>	for (i = 0; i < ac-1; i++)
581	>	av[i] = av[i+2];
582	>	av[i] = cp;
583	>	}
584	>	return(1);
585	>	}
586	>	if ((cp = getmtl()) == NULL)
587	>	return(0);
588	>	printf("\n%s polygon %s.%d\n", cp, getonm(), faceno);
589		printf("0\n0\n%d\n", 3*ac);
590	<	while (ac--) {
591	<	if (!cvtndx(vi, *av++))
590	>	for (i = 0; i < ac; i++) {
591	>	if (!cvtndx(vi, av[i]))
592		return(0);
593		pvect(vlist[vi[0]]);
594		}
#	Line 485 \| Line 596 \| register char av;**
596		}
597
598
599	<	puttri(v1, v2, v3) /* put out a triangle */
600	<	char v1, v2, *v3;
599	>	int
600	>	puttri( /* put out a triangle */
601	>	char *v1,
602	>	char *v2,
603	>	char *v3
604	>	)
605		{
606		char *mod;
607		VNDX v1i, v2i, v3i;
608		BARYCCM bvecs;
609	<	int texOK, patOK;
609	>	RREAL bcoor[3][3];
610	>	int texOK = 0, patOK;
611	>	int flatness;
612	>	register int i;
613
614		if ((mod = getmtl()) == NULL)
615	<	return(-1);
615	>	return(0);
616
617		if (!cvtndx(v1i, v1) \|\| !cvtndx(v2i, v2) \|\| !cvtndx(v3i, v3))
618		return(0);
619		/* compute barycentric coordinates */
620	<	texOK = (v1i[2]>=0 && v2i[2]>=0 && v3i[2]>=0);
620	>	if (v1i[2]>=0 && v2i[2]>=0 && v3i[2]>=0)
621	>	flatness = flat_tri(vlist[v1i[0]], vlist[v2i[0]], vlist[v3i[0]],
622	>	vnlist[v1i[2]], vnlist[v2i[2]], vnlist[v3i[2]]);
623	>	else
624	>	flatness = ISFLAT;
625	>
626	>	switch (flatness) {
627	>	case DEGEN: /* zero area */
628	>	ndegen++;
629	>	return(-1);
630	>	case RVFLAT: /* reversed normals, but flat */
631	>	case ISFLAT: /* smoothing unnecessary */
632	>	texOK = 0;
633	>	break;
634	>	case RVBENT: /* reversed normals with smoothing */
635	>	case ISBENT: /* proper smoothing */
636	>	texOK = 1;
637	>	break;
638	>	}
639	>	if (flatten)
640	>	texOK = 0;
641	>	#ifdef TEXMAPS
642		patOK = mapname[0] && (v1i[1]>=0 && v2i[1]>=0 && v3i[1]>=0);
643	+	#else
644	+	patOK = 0;
645	+	#endif
646		if (texOK \| patOK)
647	<	if (comp_baryc(bvecs, vlist[v1i[0]], vlist[v2i[0]],
647	>	if (comp_baryc(&bvecs, vlist[v1i[0]], vlist[v2i[0]],
648		vlist[v3i[0]]) < 0)
649	<	return(-1);
649	>	texOK = patOK = 0;
650		/* put out texture (if any) */
651		if (texOK) {
652		printf("\n%s texfunc %s\n", mod, TEXNAME);
653		mod = TEXNAME;
654		printf("4 dx dy dz %s\n", TCALNAME);
655	<	printf("0\n21\n");
656	<	put_baryc(bvecs);
657	<	printf("\t%14.12g %14.12g %14.12g\n",
658	<	vnlist[v1i[2]][0], vnlist[v2i[2]][0],
659	<	vnlist[v3i[2]][0]);
660	<	printf("\t%14.12g %14.12g %14.12g\n",
661	<	vnlist[v1i[2]][1], vnlist[v2i[2]][1],
520	<	vnlist[v3i[2]][1]);
521	<	printf("\t%14.12g %14.12g %14.12g\n",
522	<	vnlist[v1i[2]][2], vnlist[v2i[2]][2],
523	<	vnlist[v3i[2]][2]);
655	>	printf("0\n");
656	>	for (i = 0; i < 3; i++) {
657	>	bcoor[i][0] = vnlist[v1i[2]][i];
658	>	bcoor[i][1] = vnlist[v2i[2]][i];
659	>	bcoor[i][2] = vnlist[v3i[2]][i];
660	>	}
661	>	put_baryc(&bvecs, bcoor, 3);
662		}
663	+	#ifdef TEXMAPS
664		/* put out pattern (if any) */
665		if (patOK) {
666		printf("\n%s colorpict %s\n", mod, PATNAME);
667		mod = PATNAME;
668		printf("7 noneg noneg noneg %s %s u v\n", mapname, TCALNAME);
669	<	printf("0\n18\n");
670	<	put_baryc(bvecs);
671	<	printf("\t%f %f %f\n", vtlist[v1i[1]][0],
672	<	vtlist[v2i[1]][0], vtlist[v3i[1]][0]);
673	<	printf("\t%f %f %f\n", vtlist[v1i[1]][1],
674	<	vtlist[v2i[1]][1], vtlist[v3i[1]][1]);
669	>	printf("0\n");
670	>	for (i = 0; i < 2; i++) {
671	>	bcoor[i][0] = vtlist[v1i[1]][i];
672	>	bcoor[i][1] = vtlist[v2i[1]][i];
673	>	bcoor[i][2] = vtlist[v3i[1]][i];
674	>	}
675	>	put_baryc(&bvecs, bcoor, 2);
676		}
677	<	/* put out triangle */
677	>	#endif
678	>	/* put out (reversed) triangle */
679		printf("\n%s polygon %s.%d\n", mod, getonm(), faceno);
680		printf("0\n0\n9\n");
681	<	pvect(vlist[v1i[0]]);
682	<	pvect(vlist[v2i[0]]);
683	<	pvect(vlist[v3i[0]]);
684	<
685	<	return(1);
686	<	}
687	<
688	<
548	<	int
549	<	comp_baryc(bcm, v1, v2, v3) /* compute barycentric vectors */
550	<	register BARYCCM bcm;
551	<	FLOAT v1, v2, *v3;
552	<	{
553	<	FLOAT *vt;
554	<	FVECT va, vab, vcb;
555	<	double d;
556	<	register int i, j;
557	<
558	<	for (j = 0; j < 3; j++) {
559	<	for (i = 0; i < 3; i++) {
560	<	vab[i] = v1[i] - v2[i];
561	<	vcb[i] = v3[i] - v2[i];
562	<	}
563	<	d = DOT(vcb,vcb);
564	<	if (d <= FTINY)
565	<	return(-1);
566	<	d = DOT(vcb,vab)/d;
567	<	for (i = 0; i < 3; i++)
568	<	va[i] = vab[i] - vcb[i]*d;
569	<	d = DOT(va,va);
570	<	if (d <= FTINY)
571	<	return(-1);
572	<	for (i = 0; i < 3; i++) {
573	<	va[i] /= d;
574	<	bcm[j][i] = va[i];
575	<	}
576	<	bcm[j][3] = -DOT(v2,va);
577	<	/* rotate vertices */
578	<	vt = v1;
579	<	v1 = v2;
580	<	v2 = v3;
581	<	v3 = vt;
681	>	if (flatness == RVFLAT \|\| flatness == RVBENT) {
682	>	pvect(vlist[v3i[0]]);
683	>	pvect(vlist[v2i[0]]);
684	>	pvect(vlist[v1i[0]]);
685	>	} else {
686	>	pvect(vlist[v1i[0]]);
687	>	pvect(vlist[v2i[0]]);
688	>	pvect(vlist[v3i[0]]);
689		}
583	–	return(0);
584	–	}
585	–
586	–
587	–	put_baryc(bcm) /* put barycentric coord. vectors */
588	–	register BARYCCM bcm;
589	–	{
590	–	register int i;
591	–
592	–	for (i = 0; i < 3; i++)
593	–	printf("%14.8f %14.8f %14.8f %14.8f\n",
594	–	bcm[i][0], bcm[i][1], bcm[i][2], bcm[i][3]);
595	–	}
596	–
597	–
598	–	putquad(p0, p1, p2, p3) /* put out a quadrilateral */
599	–	char p0, p1, p2, p3;
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	–	}
690		return(1);
691		}
692
693
694	<	int
695	<	norminterp(resmat, p0i, p1i, p2i, p3i) /* compute normal interpolation */
697	<	register FVECT resmat[4];
698	<	register VNDX p0i, p1i, p2i, p3i;
694	>	void
695	>	freeverts(void) /* free all vertices */
696		{
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	–
751	–	freeverts() /* free all vertices */
752	–	{
697		if (nvs) {
698	<	free((char *)vlist);
698	>	free((void *)vlist);
699		nvs = 0;
700		}
701		if (nvts) {
702	<	free((char *)vtlist);
702	>	free((void *)vtlist);
703		nvts = 0;
704		}
705		if (nvns) {
706	<	free((char *)vnlist);
706	>	free((void *)vnlist);
707		nvns = 0;
708		}
709		}
710
711
712		int
713	<	newv(x, y, z) /* create a new vertex */
714	<	double x, y, z;
713	>	newv( /* create a new vertex */
714	>	double x,
715	>	double y,
716	>	double z
717	>	)
718		{
719		if (!(nvs%CHUNKSIZ)) { /* allocate next block */
720		if (nvs == 0)
721		vlist = (FVECT )malloc(CHUNKSIZsizeof(FVECT));
722		else
723	<	vlist = (FVECT )realloc((char )vlist,
723	>	vlist = (FVECT )realloc((void )vlist,
724		(nvs+CHUNKSIZ)*sizeof(FVECT));
725		if (vlist == NULL) {
726		fprintf(stderr,
#	Line 790 \| Line 737 \| double x, y, z;
737
738
739		int
740	<	newvn(x, y, z) /* create a new vertex normal */
741	<	double x, y, z;
740	>	newvn( /* create a new vertex normal */
741	>	double x,
742	>	double y,
743	>	double z
744	>	)
745		{
746		if (!(nvns%CHUNKSIZ)) { /* allocate next block */
747		if (nvns == 0)
748		vnlist = (FVECT )malloc(CHUNKSIZsizeof(FVECT));
749		else
750	<	vnlist = (FVECT )realloc((char )vnlist,
750	>	vnlist = (FVECT )realloc((void )vnlist,
751		(nvns+CHUNKSIZ)*sizeof(FVECT));
752		if (vnlist == NULL) {
753		fprintf(stderr,
#	Line 809 \| Line 759 \| double x, y, z;
759		vnlist[nvns][0] = x;
760		vnlist[nvns][1] = y;
761		vnlist[nvns][2] = z;
762	<	if (normalize(vnlist[nvns]) == 0.0)
813	<	return(0);
762	>	n0norm += (normalize(vnlist[nvns]) == 0.0);
763		return(++nvns);
764		}
765
766
767		int
768	<	newvt(x, y) /* create a new texture map vertex */
769	<	double x, y;
768	>	newvt( /* create a new texture map vertex */
769	>	double x,
770	>	double y
771	>	)
772		{
773		if (!(nvts%CHUNKSIZ)) { /* allocate next block */
774		if (nvts == 0)
775	<	vtlist = (FLOAT ()[2])malloc(CHUNKSIZ2*sizeof(FLOAT));
775	>	vtlist = (RREAL ()[2])malloc(CHUNKSIZ2*sizeof(RREAL));
776		else
777	<	vtlist = (FLOAT ()[2])realloc((char )vtlist,
778	<	(nvts+CHUNKSIZ)2sizeof(FLOAT));
777	>	vtlist = (RREAL ()[2])realloc((void )vtlist,
778	>	(nvts+CHUNKSIZ)2sizeof(RREAL));
779		if (vtlist == NULL) {
780		fprintf(stderr,
781		"Out of memory while allocating texture vertex %d\n",
#	Line 839 \| Line 790 \| double x, y;
790		}
791
792
793	<	syntax(fn, ln, er) /* report syntax error and exit */
794	<	char *fn;
795	<	int ln;
796	<	char *er;
793	>	void
794	>	syntax( /* report syntax error and exit */
795	>	char *er
796	>	)
797		{
798		fprintf(stderr, "%s: Wavefront syntax error near line %d: %s\n",
799	<	fn, ln, er);
799	>	inpfile, lineno, er);
800		exit(1);
801		}

Diff Legend

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

Comparing ray/src/cv/obj2rad.c (file contents): Revision 2.3 by greg, Wed Apr 13 14:08:55 1994 UTC vs. Revision 2.26 by greg, Thu Sep 16 03:28:21 2010 UTC

Diff Legend

Comparing ray/src/cv/obj2rad.c (file contents):
Revision 2.3 by greg, Wed Apr 13 14:08:55 1994 UTC vs.
Revision 2.26 by greg, Thu Sep 16 03:28:21 2010 UTC