ViewVC Help

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

root/Development/ray/src/cv/mgflib/parser.c

Comparing ray/src/cv/mgflib/parser.c (file contents):
Revision 1.1 by greg, Tue Jun 21 14:45:46 1994 UTC vs.
Revision 1.9 by greg, Sat Jun 25 16:33:09 1994 UTC

#	Line 56 | Line 56 | int    mg_nqcdivs = MG_NQCD;   /* number of divisions per q
56		/* alternate handler routines */
57
58		static int      e_any_toss(),           /* discard unneeded entity */
59	<	e_ies();                /* IES luminaire file */
59	>	e_ies(),                /* IES luminaire file */
60		e_include(),            /* include file */
61		e_sph(),                /* sphere */
62	+	e_cmix(),               /* color mixtures */
63	+	e_cspec(),              /* color spectra */
64		e_cyl(),                /* cylinder */
65		e_cone(),               /* cone */
66	+	e_prism(),              /* prism */
67		e_ring(),               /* ring */
68		e_torus();              /* torus */
69
#	Line 103 | Line 106 | mg_init()                      /* initialize alternate entity handlers */
106		ineed |= 1<<MG_E_POINT|1<<MG_E_NORMAL|1<<MG_E_VERTEX;
107		} else
108		uneed |= 1<<MG_E_POINT|1<<MG_E_NORMAL|1<<MG_E_VERTEX|1<<MG_E_XF;
109	+	if (mg_ehand[MG_E_PRISM] == NULL) {
110	+	mg_ehand[MG_E_PRISM] = e_prism;
111	+	ineed |= 1<<MG_E_POINT|1<<MG_E_VERTEX;
112	+	} else
113	+	uneed |= 1<<MG_E_POINT|1<<MG_E_VERTEX|1<<MG_E_XF;
114		if (mg_ehand[MG_E_TORUS] == NULL) {
115		mg_ehand[MG_E_TORUS] = e_torus;
116		ineed |= 1<<MG_E_POINT|1<<MG_E_NORMAL|1<<MG_E_VERTEX;
117		} else
118		uneed |= 1<<MG_E_POINT|1<<MG_E_NORMAL|1<<MG_E_VERTEX|1<<MG_E_XF;
119	+	if (mg_ehand[MG_E_COLOR] != NULL) {
120	+	if (mg_ehand[MG_E_CMIX] == NULL) {
121	+	mg_ehand[MG_E_CMIX] = e_cmix;
122	+	ineed |= 1<<MG_E_COLOR|1<<MG_E_CXY|1<<MG_E_CSPEC|1<<MG_E_CMIX;
123	+	}
124	+	if (mg_ehand[MG_E_CSPEC] == NULL) {
125	+	mg_ehand[MG_E_CSPEC] = e_cspec;
126	+	ineed |= 1<<MG_E_COLOR|1<<MG_E_CXY|1<<MG_E_CSPEC|1<<MG_E_CMIX;
127	+	}
128	+	}
129		/* check for consistency */
130		if (mg_ehand[MG_E_FACE] != NULL)
131		uneed |= 1<<MG_E_POINT|1<<MG_E_VERTEX|1<<MG_E_XF;
132	<	if (mg_ehand[MG_E_CXY] != NULL)
132	>	if (mg_ehand[MG_E_CXY] != NULL || mg_ehand[MG_E_CSPEC] != NULL ||
133	>	mg_ehand[MG_E_CMIX] != NULL)
134		uneed |= 1<<MG_E_COLOR;
135		if (mg_ehand[MG_E_RD] != NULL || mg_ehand[MG_E_TD] != NULL ||
136		mg_ehand[MG_E_ED] != NULL ||
#	Line 131 | Line 150 | mg_init()                      /* initialize alternate entity handlers */
150		e_supp[MG_E_POINT] = c_hvertex;
151		if (ineed & 1<<MG_E_NORMAL && mg_ehand[MG_E_NORMAL] != c_hvertex)
152		e_supp[MG_E_NORMAL] = c_hvertex;
153	+	if (ineed & 1<<MG_E_COLOR && mg_ehand[MG_E_COLOR] != c_hcolor)
154	+	e_supp[MG_E_COLOR] = c_hcolor;
155	+	if (ineed & 1<<MG_E_CXY && mg_ehand[MG_E_CXY] != c_hcolor)
156	+	e_supp[MG_E_CXY] = c_hcolor;
157	+	if (ineed & 1<<MG_E_CSPEC && mg_ehand[MG_E_CSPEC] != c_hcolor)
158	+	e_supp[MG_E_CSPEC] = c_hcolor;
159	+	if (ineed & 1<<MG_E_CMIX && mg_ehand[MG_E_CMIX] != c_hcolor)
160	+	e_supp[MG_E_CMIX] = c_hcolor;
161		/* discard remaining entities */
162		for (i = 0; i < MG_NENTITIES; i++)
163		if (mg_ehand[i] == NULL)
#	Line 143 | Line 170 | int
170		mg_entity(name)                 /* get entity number from its name */
171		char    *name;
172		{
173	<	static LUTAB    ent_tab;        /* entity lookup table */
173	>	static LUTAB    ent_tab = LU_SINIT(NULL,NULL);  /* lookup table */
174		register char   *cp;
175
176		if (!ent_tab.tsiz) {            /* initialize hash table */
#	Line 188 | Line 215 | char   *fn;
215
216		ctx->lineno = 0;
217		if (fn == NULL) {
218	<	ctx->fname = "<stdin>";
218	>	strcpy(ctx->fname, "<stdin>");
219		ctx->fp = stdin;
220		ctx->prev = mg_file;
221		mg_file = ctx;
#	Line 200 | Line 227 | char   *fn;
227		olen = cp - mg_file->fname + 1;
228		else
229		olen = 0;
203	–	ctx->fname = (char *)malloc(olen+strlen(fn)+1);
204	–	if (ctx->fname == NULL)
205	–	return(MG_EMEM);
230		if (olen)
231		strcpy(ctx->fname, mg_file->fname);
232		strcpy(ctx->fname+olen, fn);
233		ctx->fp = fopen(ctx->fname, "r");
234	<	if (ctx->fp == NULL) {
211	<	free((MEM_PTR)ctx->fname);
234	>	if (ctx->fp == NULL)
235		return(MG_ENOFILE);
213	–	}
236		ctx->prev = mg_file;            /* establish new context */
237		mg_file = ctx;
238		return(MG_OK);
#	Line 226 | Line 248 | mg_close()                     /* close input file */
248		if (ctx->fp == stdin)
249		return;                 /* don't close standard input */
250		fclose(ctx->fp);
229	–	free((MEM_PTR)ctx->fname);
251		}
252
253
#	Line 300 | Line 321 | char   *fn;
321		int     rval;
322
323		if ((rval = mg_open(&cntxt, fn)) != MG_OK) {
324	<	fprintf("%s: %s\n", fn, mg_err[rval]);
324	>	fprintf(stderr, "%s: %s\n", fn, mg_err[rval]);
325		return(rval);
326		}
327		while (mg_read())               /* parse each line */
#	Line 349 | Line 370 | int    (*f)();
370		if (i+1 >= ac || !isint(av[i+1]))
371		return(MG_ETYPE);
372		niter = atoi(av[i+1]);
373	<	argv[0] = "-i";
373	>	argv[0] = mg_ename[MG_E_OBJECT];
374		argv[1] = cntbuf;
375		for (j = 2; j+i < ac; j++)
376		argv[j] = av[j+i];
377		argv[j] = NULL;
378		for (j = 0; j < niter; j++) {
379		sprintf(cntbuf, "%d", j);
380	+	if ((rval = handle_it(MG_E_OBJECT, 2, argv)) != MG_OK)
381	+	return(rval);
382	+	argv[0] = "-i";
383		if ((rval = mg_iterate(ac-i, argv, f)) != MG_OK)
384		return(rval);
385	+	argv[0] = mg_ename[MG_E_OBJECT];
386	+	if ((rval = handle_it(MG_E_OBJECT, 1, argv)) != MG_OK)
387	+	return(rval);
388		}
389		} else if ((rval = (*f)()) != MG_OK)    /* else do this instance */
390		return(rval);
#	Line 511 | Line 538 | char   **av;
538		return(MG_EARGC);
539		if ((cv = c_getvert(av[1])) == NULL)
540		return(MG_EUNDEF);
541	<	if (cv->n[0]==0. && cv->n[1]==0. && cv->n[2]==0.)
541	>	if (is0vect(cv->n))
542		return(MG_EILL);
543		if (!isflt(av[2]) || !isflt(av[3]))
544		return(MG_ETYPE);
545		minrad = atof(av[2]);
546	+	round0(minrad);
547		maxrad = atof(av[3]);
548		/* check orientation */
549		if (minrad > 0.)
#	Line 623 | Line 651 | char   **av;
651		return(MG_EARGC);
652		if ((cv = c_getvert(av[1])) == NULL)
653		return(MG_EUNDEF);
654	<	if (cv->n[0]==0. && cv->n[1]==0. && cv->n[2]==0.)
654	>	if (is0vect(cv->n))
655		return(MG_EILL);
656		if (!isflt(av[2]) || !isflt(av[3]))
657		return(MG_ETYPE);
658		minrad = atof(av[2]);
659	+	round0(minrad);
660		maxrad = atof(av[3]);
661		if (minrad < 0. || maxrad <= minrad)
662		return(MG_EILL);
#	Line 653 | Line 682 | char   **av;
682		sprintf(p3[j], FLTFMT, cv->p[j] +
683		maxrad*u[j]*cos(theta) +
684		maxrad*v[j]*sin(theta));
685	<	if ((rv = handle_it(MG_E_VERTEX, 3, v3ent)) != MG_OK)
685	>	if ((rv = handle_it(MG_E_VERTEX, 2, v3ent)) != MG_OK)
686		return(rv);
687		if ((rv = handle_it(MG_E_POINT, 4, p3ent)) != MG_OK)
688		return(rv);
#	Line 679 | Line 708 | char   **av;
708		sprintf(p3[j], FLTFMT, cv->p[j] + maxrad*d);
709		sprintf(p4[j], FLTFMT, cv->p[j] + minrad*d);
710		}
711	<	if ((rv = handle_it(MG_E_VERTEX, 3, v3ent)) != MG_OK)
711	>	if ((rv = handle_it(MG_E_VERTEX, 2, v3ent)) != MG_OK)
712		return(rv);
713		if ((rv = handle_it(MG_E_POINT, 4, p3ent)) != MG_OK)
714		return(rv);
715	<	if ((rv = handle_it(MG_E_VERTEX, 3, v4ent)) != MG_OK)
715	>	if ((rv = handle_it(MG_E_VERTEX, 2, v4ent)) != MG_OK)
716		return(rv);
717		if ((rv = handle_it(MG_E_POINT, 4, p4ent)) != MG_OK)
718		return(rv);
#	Line 728 | Line 757 | char   **av;
757		if (!isflt(av[2]) || !isflt(av[4]))
758		return(MG_ETYPE);
759		rad1 = atof(av[2]);
760	+	round0(rad1);
761		rad2 = atof(av[4]);
762	+	round0(rad2);
763		if (rad1 == 0.) {
764		if (rad2 == 0.)
765		return(MG_EILL);
#	Line 752 | Line 783 | char   **av;
783		if ((d = normalize(w)) == 0.)
784		return(MG_EILL);
785		n1off = n2off = (rad2 - rad1)/d;
786	<	if (warpconends)                /* hack for e_sph and e_torus */
787	<	n2off = tan(atan(n2off)-(PI/4)/mg_nqcdivs);
788	<	n2off = sgn*n2off;
786	>	if (warpconends) {              /* hack for e_sph and e_torus */
787	>	d = atan(n2off) - (PI/4)/mg_nqcdivs;
788	>	if (d <= -PI/2+FTINY)
789	>	n2off = -FHUGE;
790	>	else
791	>	n2off = tan(d);
792	>	}
793		make_axes(u, v, w);
794		for (j = 0; j < 3; j++) {
795		sprintf(p3[j], FLTFMT, cv2->p[j] + rad2*u[j]);
796	<	sprintf(n3[j], FLTFMT, u[j] + w[j]*n2off);
796	>	if (n2off <= -FHUGE)
797	>	sprintf(n3[j], FLTFMT, -w[j]);
798	>	else
799	>	sprintf(n3[j], FLTFMT, u[j] + w[j]*n2off);
800		}
801		if ((rv = handle_it(MG_E_VERTEX, 3, v3ent)) != MG_OK)
802		return(rv);
#	Line 781 | Line 819 | char   **av;
819		for (j = 0; j < 3; j++) {
820		d = u[j]*cos(theta) + v[j]*sin(theta);
821		sprintf(p3[j], FLTFMT, cv2->p[j] + rad2*d);
822	<	sprintf(n3[j], FLTFMT, d + w[j]*n2off);
822	>	if (n2off > -FHUGE)
823	>	sprintf(n3[j], FLTFMT, d + w[j]*n2off);
824		}
825	<	if ((rv = handle_it(MG_E_VERTEX, 3, v3ent)) != MG_OK)
825	>	if ((rv = handle_it(MG_E_VERTEX, 2, v3ent)) != MG_OK)
826		return(rv);
827		if ((rv = handle_it(MG_E_POINT, 4, p3ent)) != MG_OK)
828		return(rv);
829	<	if ((rv = handle_it(MG_E_NORMAL, 4, n3ent)) != MG_OK)
829	>	if (n2off > -FHUGE &&
830	>	(rv = handle_it(MG_E_NORMAL, 4, n3ent)) != MG_OK)
831		return(rv);
832		if ((rv = handle_it(MG_E_FACE, 4, fent)) != MG_OK)
833		return(rv);
834		}
835		} else {                        /* quads */
836		v1ent[3] = "_cv4";
837	<	if (warpconends)                /* hack for e_sph and e_torus */
838	<	n1off = tan(atan(n1off)+(PI/4)/mg_nqcdivs);
839	<	n1off = sgn*n1off;
837	>	if (warpconends) {              /* hack for e_sph and e_torus */
838	>	d = atan(n1off) + (PI/4)/mg_nqcdivs;
839	>	if (d >= PI/2-FTINY)
840	>	n1off = FHUGE;
841	>	else
842	>	n1off = tan(atan(n1off)+(PI/4)/mg_nqcdivs);
843	>	}
844		for (j = 0; j < 3; j++) {
845		sprintf(p4[j], FLTFMT, cv1->p[j] + rad1*u[j]);
846	<	sprintf(n4[j], FLTFMT, u[j] + w[j]*n1off);
846	>	if (n1off >= FHUGE)
847	>	sprintf(n4[j], FLTFMT, w[j]);
848	>	else
849	>	sprintf(n4[j], FLTFMT, u[j] + w[j]*n1off);
850		}
851		if ((rv = handle_it(MG_E_VERTEX, 3, v4ent)) != MG_OK)
852		return(rv);
#	Line 816 | Line 863 | char   **av;
863		for (j = 0; j < 3; j++) {
864		d = u[j]*cos(theta) + v[j]*sin(theta);
865		sprintf(p3[j], FLTFMT, cv2->p[j] + rad2*d);
866	<	sprintf(n3[j], FLTFMT, d + w[j]*n2off);
866	>	if (n2off > -FHUGE)
867	>	sprintf(n3[j], FLTFMT, d + w[j]*n2off);
868		sprintf(p4[j], FLTFMT, cv1->p[j] + rad1*d);
869	<	sprintf(n4[j], FLTFMT, d + w[j]*n1off);
869	>	if (n1off < FHUGE)
870	>	sprintf(n4[j], FLTFMT, d + w[j]*n1off);
871		}
872	<	if ((rv = handle_it(MG_E_VERTEX, 3, v3ent)) != MG_OK)
872	>	if ((rv = handle_it(MG_E_VERTEX, 2, v3ent)) != MG_OK)
873		return(rv);
874		if ((rv = handle_it(MG_E_POINT, 4, p3ent)) != MG_OK)
875		return(rv);
876	<	if ((rv = handle_it(MG_E_NORMAL, 4, n3ent)) != MG_OK)
876	>	if (n2off > -FHUGE &&
877	>	(rv = handle_it(MG_E_NORMAL, 4, n3ent)) != MG_OK)
878		return(rv);
879	<	if ((rv = handle_it(MG_E_VERTEX, 3, v4ent)) != MG_OK)
879	>	if ((rv = handle_it(MG_E_VERTEX, 2, v4ent)) != MG_OK)
880		return(rv);
881		if ((rv = handle_it(MG_E_POINT, 4, p4ent)) != MG_OK)
882		return(rv);
883	<	if ((rv = handle_it(MG_E_NORMAL, 4, n4ent)) != MG_OK)
883	>	if (n1off < FHUGE &&
884	>	(rv = handle_it(MG_E_NORMAL, 4, n4ent)) != MG_OK)
885		return(rv);
886		if ((rv = handle_it(MG_E_FACE, 5, fent)) != MG_OK)
887		return(rv);
888		}
889	+	}
890	+	return(MG_OK);
891	+	}
892	+
893	+
894	+	static int
895	+	e_prism(ac, av)                 /* turn a prism into polygons */
896	+	int     ac;
897	+	char    **av;
898	+	{
899	+	static char     p[3][24];
900	+	static char     *vent[4] = {mg_ename[MG_E_VERTEX],NULL,"="};
901	+	static char     *pent[5] = {mg_ename[MG_E_POINT],p[0],p[1],p[2]};
902	+	char    *newav[MG_MAXARGC], nvn[MG_MAXARGC-1][8];
903	+	double  length;
904	+	FVECT   v1, v2, v3, norm;
905	+	register C_VERTEX       *cv;
906	+	C_VERTEX        *cv0;
907	+	int     rv;
908	+	register int    i, j;
909	+
910	+	if (ac < 5)
911	+	return(MG_EARGC);
912	+	if (!isflt(av[ac-1]))
913	+	return(MG_ETYPE);
914	+	length = atof(av[ac-1]);
915	+	if (length <= FTINY && length >= -FTINY)
916	+	return(MG_EILL);
917	+	/* do bottom face */
918	+	newav[0] = mg_ename[MG_E_FACE];
919	+	for (i = 1; i < ac-1; i++)
920	+	newav[i] = av[i];
921	+	newav[i] = NULL;
922	+	if ((rv = handle_it(MG_E_FACE, i, newav)) != MG_OK)
923	+	return(rv);
924	+	/* compute face normal */
925	+	if ((cv0 = c_getvert(av[1])) == NULL)
926	+	return(MG_EUNDEF);
927	+	norm[0] = norm[1] = norm[2] = 0.;
928	+	v1[0] = v1[1] = v1[2] = 0.;
929	+	for (i = 2; i < ac-1; i++) {
930	+	if ((cv = c_getvert(av[i])) == NULL)
931	+	return(MG_EUNDEF);
932	+	v2[0] = cv->p[0] - cv0->p[0];
933	+	v2[1] = cv->p[1] - cv0->p[1];
934	+	v2[2] = cv->p[2] - cv0->p[2];
935	+	fcross(v3, v1, v2);
936	+	norm[0] += v3[0];
937	+	norm[1] += v3[1];
938	+	norm[2] += v3[2];
939	+	VCOPY(v1, v2);
940	+	}
941	+	if (normalize(norm) == 0.)
942	+	return(MG_EILL);
943	+	/* create moved vertices */
944	+	for (i = 1; i < ac-1; i++) {
945	+	sprintf(nvn[i-1], "_pv%d", i);
946	+	vent[1] = nvn[i-1];
947	+	if ((rv = handle_it(MG_E_VERTEX, 3, vent)) != MG_OK)
948	+	return(rv);
949	+	cv = c_getvert(av[i]);          /* checked above */
950	+	for (j = 0; j < 3; j++)
951	+	sprintf(p[j], FLTFMT, cv->p[j] - length*norm[j]);
952	+	if ((rv = handle_it(MG_E_POINT, 4, pent)) != MG_OK)
953	+	return(rv);
954	+	newav[ac-1-i] = nvn[i-1];       /* reverse */
955	+	}
956	+	/* do top face */
957	+	if ((rv = handle_it(MG_E_FACE, ac-1, newav)) != MG_OK)
958	+	return(rv);
959	+	/* do the side faces */
960	+	newav[5] = NULL;
961	+	newav[3] = av[ac-2];
962	+	newav[4] = nvn[ac-3];
963	+	for (i = 1; i < ac-1; i++) {
964	+	newav[1] = nvn[i-1];
965	+	newav[2] = av[i];
966	+	if ((rv = handle_it(MG_E_FACE, 5, newav)) != MG_OK)
967	+	return(rv);
968	+	newav[3] = newav[2];
969	+	newav[4] = newav[1];
970	+	}
971	+	return(MG_OK);
972	+	}
973	+
974	+
975	+	static int
976	+	e_cspec(ac, av)                 /* handle spectral color */
977	+	int     ac;
978	+	char    **av;
979	+	{
980	+	static char     xbuf[24], ybuf[24];
981	+	static char     *ccom[4] = {mg_ename[MG_E_CXY], xbuf, ybuf};
982	+	int     rv;
983	+
984	+	c_ccvt(c_ccolor, C_CSXY);
985	+	/* if it's really their handler, use it */
986	+	if (mg_ehand[MG_E_CXY] != c_hcolor) {
987	+	sprintf(xbuf, "%.4f", c_ccolor->cx);
988	+	sprintf(ybuf, "%.4f", c_ccolor->cy);
989	+	if ((rv = handle_it(MG_E_CXY, 3, ccom)) != MG_OK)
990	+	return(rv);
991	+	}
992	+	return(MG_OK);
993	+	}
994	+
995	+
996	+	static int
997	+	e_cmix(ac, av)                  /* handle mixing of colors */
998	+	int     ac;
999	+	char    **av;
1000	+	{
1001	+	char    wl[2][6], vbuf[C_CNSS][24];
1002	+	char    *newav[C_CNSS+4];
1003	+	int     rv;
1004	+	register int    i;
1005	+	/*
1006	+	* Contorted logic works as follows:
1007	+	*      1. the colors are already mixed in c_hcolor() support function
1008	+	*      2. if we would handle a spectral result, make sure it's not
1009	+	*      3. if c_hcolor() would handle a spectral result, don't bother
1010	+	*      4. otherwise, make cspec entity and pass it to their handler
1011	+	*      5. if we have only xy results, handle it as c_spec() would
1012	+	*/
1013	+	if (mg_ehand[MG_E_CSPEC] == e_cspec)
1014	+	c_ccvt(c_ccolor, C_CSXY);
1015	+	else if (c_ccolor->flags & C_CDSPEC) {
1016	+	if (mg_ehand[MG_E_CSPEC] != c_hcolor) {
1017	+	sprintf(wl[0], "%d", C_CMINWL);
1018	+	sprintf(wl[1], "%d", C_CMAXWL);
1019	+	newav[0] = mg_ename[MG_E_CSPEC];
1020	+	newav[1] = wl[0];
1021	+	newav[2] = wl[1];
1022	+	for (i = 0; i < C_CNSS; i++) {
1023	+	sprintf(vbuf[i], "%.6f",
1024	+	(double)c_ccolor->ssamp[i] /
1025	+	c_ccolor->ssum);
1026	+	newav[i+3] = vbuf[i];
1027	+	}
1028	+	newav[C_CNSS+3] = NULL;
1029	+	if ((rv = handle_it(MG_E_CSPEC, C_CNSS+3, newav)) != MG_OK)
1030	+	return(rv);
1031	+	}
1032	+	return(MG_OK);
1033	+	}
1034	+	if (mg_ehand[MG_E_CXY] != c_hcolor) {
1035	+	sprintf(vbuf[0], "%.4f", c_ccolor->cx);
1036	+	sprintf(vbuf[1], "%.4f", c_ccolor->cy);
1037	+	newav[0] = mg_ename[MG_E_CXY];
1038	+	newav[1] = vbuf[0];
1039	+	newav[2] = vbuf[1];
1040	+	newav[3] = NULL;
1041	+	if ((rv = handle_it(MG_E_CXY, 3, newav)) != MG_OK)
1042	+	return(rv);
1043		}
1044		return(MG_OK);
1045		}

Diff Legend

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