cv/mgflib/parser.h

/* RCSid: $Id: parser.h,v 1.37 2003/11/15 17:54:06 schorsch Exp $ */
/*
 * Header file for MGF interpreter
 */
#ifndef _MGF_PARSER_H_
#define _MGF_PARSER_H_
#ifdef __cplusplus
extern "C" {
#endif

/* must include stdio.h and stdlib.h before us */

#include "ccolor.h"

#define MG_VMAJOR       2               /* major version number */
#define MG_VMINOR       0               /* minor version number */

                        /* Entities (list is only appended, never modified) */
#define MG_E_COMMENT    0               /* #            */
#define MG_E_COLOR      1               /* c            */
#define MG_E_CCT        2               /* cct          */
#define MG_E_CONE       3               /* cone         */
#define MG_E_CMIX       4               /* cmix         */
#define MG_E_CSPEC      5               /* cspec        */
#define MG_E_CXY        6               /* cxy          */
#define MG_E_CYL        7               /* cyl          */
#define MG_E_ED         8               /* ed           */
#define MG_E_FACE       9               /* f            */
#define MG_E_INCLUDE    10              /* i            */
#define MG_E_IES        11              /* ies          */
#define MG_E_IR         12              /* ir           */
#define MG_E_MATERIAL   13              /* m            */
#define MG_E_NORMAL     14              /* n            */
#define MG_E_OBJECT     15              /* o            */
#define MG_E_POINT      16              /* p            */
#define MG_E_PRISM      17              /* prism        */
#define MG_E_RD         18              /* rd           */
#define MG_E_RING       19              /* ring         */
#define MG_E_RS         20              /* rs           */
#define MG_E_SIDES      21              /* sides        */
#define MG_E_SPH        22              /* sph          */
#define MG_E_TD         23              /* td           */
#define MG_E_TORUS      24              /* torus        */
#define MG_E_TS         25              /* ts           */
#define MG_E_VERTEX     26              /* v            */
#define MG_E_XF         27              /* xf           */
                        /* end of Version 1 entities */
#define MG_E_FACEH      28              /* fh           */
                        /* end of Version 2 entities */

#define MG_NENTITIES    29              /* total # entities */

#define MG_NELIST       {28,29}         /* entity count for version 1 and up */

#define MG_NAMELIST     {"#","c","cct","cone","cmix","cspec","cxy","cyl","ed",\
                        "f","i","ies","ir","m","n","o","p","prism","rd",\
                        "ring","rs","sides","sph","td","torus","ts","v","xf",\
                        "fh"}

#define MG_MAXELEN      6

extern char     mg_ename[MG_NENTITIES][MG_MAXELEN];

                        /* Handler routines for each entity and unknown ones */
extern int      (*mg_ehand[MG_NENTITIES])(int argc, char **argv);
extern int      (*mg_uhand)(int argc, char **argv);
extern int      mg_defuhand(int, char **);

extern unsigned mg_nunknown;            /* count of unknown entities */

                        /* Error codes */
#define MG_OK           0               /* normal return value */
#define MG_EUNK         1               /* unknown entity */
#define MG_EARGC        2               /* wrong number of arguments */
#define MG_ETYPE        3               /* argument type error */
#define MG_EILL         4               /* illegal argument value */
#define MG_EUNDEF       5               /* undefined reference */
#define MG_ENOFILE      6               /* cannot open input file */
#define MG_EINCL        7               /* error in included file */
#define MG_EMEM         8               /* out of memory */
#define MG_ESEEK        9               /* file seek error */
#define MG_EBADMAT      10              /* bad material specification */
#define MG_ELINE        11              /* input line too long */
#define MG_ECNTXT       12              /* unmatched context close */

#define MG_NERRS        13

extern char     *mg_err[MG_NERRS];      /* list of error messages */

/*
 * The general process for running the parser is to fill in the mg_ehand
 * array with handlers for each entity you know how to handle.
 * Then, call mg_init to fill in the rest.  This function will report
 * an error and quit if you try to support an inconsistent set of entities.
 * For each file you want to parse, call mg_load with the file name.
 * To read from standard input, use NULL as the file name.
 * For additional control over error reporting and file management,
 * use mg_open, mg_read, mg_parse and mg_close instead of mg_load.
 * To pass an entity of your own construction to the parser, use
 * the mg_handle function rather than the mg_ehand routines directly.
 * (The first argument to mg_handle is the entity #, or -1.)
 * To free any data structures and clear the parser, use mg_clear.
 * If there is an error, mg_load, mg_open, mg_parse, mg_handle and
 * mg_fgoto will return an error from the list above.  In addition,
 * mg_load will report the error to stderr.  The mg_read routine
 * returns 0 when the end of file has been reached.
 */

#define MG_MAXLINE      4096            /* maximum input line length */
#define MG_MAXARGC      (MG_MAXLINE/4)  /* maximum argument count */

typedef struct mg_fctxt {
        char    fname[96];                      /* file name */
        FILE    *fp;                            /* stream pointer */
        int     fid;                            /* unique file context id */
        char    inpline[MG_MAXLINE];            /* input line */
        int     lineno;                         /* line number */
        struct mg_fctxt *prev;                  /* previous context */
} MG_FCTXT;

typedef struct {
        int     fid;                            /* file this position is for */
        int     lineno;                         /* line number in file */
        long    offset;                         /* offset from beginning */
} MG_FPOS;

extern MG_FCTXT *mg_file;               /* current file context */

extern void     mg_init(void);          /* fill in mg_ehand array */
extern int      mg_load(char *);        /* parse a file */
extern int      mg_open(MG_FCTXT *, char *);    /* open new input file */
extern int      mg_read(void);          /* read next line */
extern int      mg_parse(void);         /* parse current line */
extern void     mg_fgetpos(MG_FPOS *);  /* get position on input file */
extern int      mg_fgoto(MG_FPOS *);    /* go to position on input file */
extern void     mg_close(void);         /* close input file */
extern void     mg_clear(void);         /* clear parser */
extern int      mg_handle(int, int, char **);   /* handle an entity */

#ifndef MG_NQCD
#define MG_NQCD         5               /* default number of divisions */
#endif

extern int      mg_nqcdivs;             /* divisions per quarter circle */

/*
 * The following library routines are included for your convenience:
 */

extern int mg_entity(char *);           /* get entity number from its name */
extern int isint(char *);               /* non-zero if integer format */
extern int isintd(char *, char *);      /* same with delimiter set */
extern int isflt(char *);               /* non-zero if floating point format */
extern int isfltd(char *, char *);      /* same with delimiter set */
extern int isname(char *);              /* non-zero if legal identifier name */
extern int badarg(int, char **, char *);/* check argument format */
extern int e_include(int, char **);     /* expand include entity */
extern int e_pipe(int, char **);        /* expand piped command */
extern int e_sph(int, char **);         /* expand sphere as other entities */
extern int e_torus(int, char **);       /* expand torus as other entities */
extern int e_cyl(int, char **);         /* expand cylinder as other entities */
extern int e_ring(int, char **);        /* expand ring as other entities */
extern int e_cone(int, char **);        /* expand cone as other entities */
extern int e_prism(int, char **);       /* expand prism as other entities */
extern int e_faceh(int, char **);       /* expand face w/ holes as face */

/************************************************************************
 *      Definitions for 3-d vector manipulation functions
 */

#ifdef  SMLFLT
#define  RREAL          float
#define  FTINY          (1e-3)
#else
#define  RREAL          double
#define  FTINY          (1e-6)
#endif
#define  FHUGE          (1e10)

typedef RREAL  FVECT[3];

#define  VCOPY(v1,v2)   ((v1)[0]=(v2)[0],(v1)[1]=(v2)[1],(v1)[2]=(v2)[2])
#define  DOT(v1,v2)     ((v1)[0]*(v2)[0]+(v1)[1]*(v2)[1]+(v1)[2]*(v2)[2])
#define  VSUM(vr,v1,v2,f)       ((vr)[0]=(v1)[0]+(f)*(v2)[0], \
                                (vr)[1]=(v1)[1]+(f)*(v2)[1], \
                                (vr)[2]=(v1)[2]+(f)*(v2)[2])

#define is0vect(v)      (DOT(v,v) <= FTINY*FTINY)

#define round0(x)       if (x <= FTINY && x >= -FTINY) x = 0

extern double   normalize(FVECT);       /* normalize a vector */
extern void     fcross(FVECT,FVECT,FVECT);/* cross product of two vectors */

/************************************************************************
 *      Definitions for context handling routines
 *      (materials, colors, vectors)
 */

#define C_1SIDEDTHICK   0.005           /* assumed thickness of 1-sided mat. */

typedef struct {
        int     clock;          /* incremented each change -- resettable */
        char    *client_data;   /* pointer to private client-owned data */
        int     sided;          /* 1 if surface is 1-sided, 0 for 2-sided */
        float   nr, ni;         /* index of refraction, real and imaginary */
        float   rd;             /* diffuse reflectance */
        C_COLOR rd_c;           /* diffuse reflectance color */
        float   td;             /* diffuse transmittance */
        C_COLOR td_c;           /* diffuse transmittance color */
        float   ed;             /* diffuse emittance */
        C_COLOR ed_c;           /* diffuse emittance color */
        float   rs;             /* specular reflectance */
        C_COLOR rs_c;           /* specular reflectance color */
        float   rs_a;           /* specular reflectance roughness */
        float   ts;             /* specular transmittance */
        C_COLOR ts_c;           /* specular transmittance color */
        float   ts_a;           /* specular transmittance roughness */
} C_MATERIAL;           /* material context */

typedef struct {
        int     clock;          /* incremented each change -- resettable */
        char    *client_data;   /* pointer to private client-owned data */
        FVECT   p, n;           /* point and normal */
} C_VERTEX;             /* vertex context */

#define C_DEFMATERIAL   {1,NULL,0,1.,0.,0.,C_DEFCOLOR,0.,C_DEFCOLOR,0.,\
                                C_DEFCOLOR,0.,C_DEFCOLOR,0.,0.,C_DEFCOLOR,0.}
#define C_DEFVERTEX     {1,NULL,{0.,0.,0.},{0.,0.,0.}}

extern C_COLOR          *c_ccolor;      /* the current color */
extern char             *c_ccname;      /* current color name */
extern C_MATERIAL       *c_cmaterial;   /* the current material */
extern char             *c_cmname;      /* current material name */
extern C_VERTEX         *c_cvertex;     /* the current vertex */
extern char             *c_cvname;      /* current vertex name */

extern int      c_hcolor(int, char **);         /* handle color entity */
extern int      c_hmaterial(int, char **);      /* handle material entity */
extern int      c_hvertex(int, char **);        /* handle vertex entity */
extern void     c_clearall(void);               /* clear context tables */
extern C_MATERIAL       *c_getmaterial(char *); /* get a named material */
extern C_VERTEX *c_getvert(char *);             /* get a named vertex */
extern C_COLOR  *c_getcolor(char *);            /* get a named color */

/*************************************************************************
 *      Definitions for hierarchical object name handler
 */

extern int      obj_nnames;             /* depth of name hierarchy */
extern char     **obj_name;             /* names in hierarchy */

extern int      obj_handler(int, char **);      /* handle an object entity */
extern void     obj_clear(void);                /* clear object stack */

/**************************************************************************
 *      Definitions for hierarchical transformation handler
 */

typedef RREAL  MAT4[4][4];

#define  copymat4(m4a,m4b)      (void)memcpy((char *)m4a,(char *)m4b,sizeof(MAT4))

#define  MAT4IDENT              { {1.,0.,0.,0.}, {0.,1.,0.,0.}, \
                                {0.,0.,1.,0.}, {0.,0.,0.,1.} }

extern MAT4  m4ident;

#define  setident4(m4)          copymat4(m4, m4ident)

                                /* regular transformation */
typedef struct {
        MAT4    xfm;                            /* transform matrix */
        RREAL   sca;                            /* scalefactor */
}  XF;

#define identxf(xp)             (void)(setident4((xp)->xfm),(xp)->sca=1.0)

#define XF_MAXDIM       8               /* maximum array dimensions */

struct xf_array {
        MG_FPOS spos;                   /* starting position on input */
        int     ndim;                   /* number of array dimensions */
        struct {
                short   i, n;           /* current count and maximum */
                char    arg[8];         /* string argument value */
        } aarg[XF_MAXDIM];
};

typedef struct xf_spec {
        long    xid;                    /* unique transform id */
        short   xac;                    /* context argument count */
        short   rev;                    /* boolean true if vertices reversed */
        XF      xf;                     /* cumulative transformation */
        struct xf_array *xarr;          /* transformation array pointer */
        struct xf_spec  *prev;          /* previous transformation context */
} XF_SPEC;                      /* followed by argument buffer */

extern XF_SPEC  *xf_context;                    /* current transform context */
extern char     **xf_argend;                    /* last transform argument */

#define xf_ac(xf)       ((xf)==NULL ? 0 : (xf)->xac)
#define xf_av(xf)       (xf_argend - (xf)->xac)

#define xf_argc         xf_ac(xf_context)
#define xf_argv         xf_av(xf_context)

/*
 * The transformation handler should do most of the work that needs
 * doing.  Just pass it any xf entities, then use the associated
 * functions to transform and translate points, transform vectors
 * (without translation), rotate vectors (without scaling) and scale
 * values appropriately.
 *
 * The routines xf_xfmpoint, xf_xfmvect and xf_rotvect take two
 * 3-D vectors (which may be identical), transforms the second and
 * puts the result into the first.
 */


extern int      xf_handler(int, char **);       /* handle xf entity */
extern void     xf_xfmpoint(FVECT, FVECT);      /* transform point */
extern void     xf_xfmvect(FVECT, FVECT);       /* transform vector */
extern void     xf_rotvect(FVECT, FVECT);       /* rotate vector */
extern double   xf_scale(double);               /* scale a value */
extern void     xf_clear(void);                 /* clear xf stack */

/* The following are support routines you probably won't call directly */

XF_SPEC         *new_xf(int, char **);          /* allocate new transform */
void            free_xf(XF_SPEC *);             /* free a transform */
int             xf_aname(struct xf_array *);    /* name this instance */
long            comp_xfid(MAT4);                /* compute unique ID */
extern void     multmat4(MAT4, MAT4, MAT4);     /* m4a = m4b X m4c */
extern void     multv3(FVECT, FVECT, MAT4);     /* v3a = v3b X m4 (vectors) */
extern void     multp3(FVECT, FVECT, MAT4);     /* p3a = p3b X m4 (points) */
extern int      xf(XF *, int, char **);         /* interpret transform spec. */

        /* cvrgb.c */
extern void mgf2rgb(C_COLOR *cin, double intensity, float cout[3]);


/************************************************************************
 *      Miscellaneous definitions
 */

#ifndef  PI
#ifdef  M_PI
#define  PI             ((double)M_PI)
#else
#define  PI             3.14159265358979323846
#endif
#endif

#ifndef MEM_PTR
#define MEM_PTR         void *
#endif

#ifdef __cplusplus
}
#endif
#endif /* _MGF_PARSER_H_ */

Revision:	1.38
Committed:	Mon Jan 3 20:30:21 2011 UTC (13 years, 4 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.37:	+3 -44 lines
Log Message:	Separated color manipulation routines
#	User	Rev	Content
1	greg	1.38	/* RCSid: $Id: parser.h,v 1.37 2003/11/15 17:54:06 schorsch Exp $ */
2	greg	1.1	/*
3			* Header file for MGF interpreter
4			*/
5	schorsch	1.34	#ifndef _MGF_PARSER_H_
6			#define _MGF_PARSER_H_
7			#ifdef __cplusplus
8			extern "C" {
9			#endif
10
11	greg	1.38	/* must include stdio.h and stdlib.h before us */
12	greg	1.1
13	greg	1.38	#include "ccolor.h"
14	greg	1.1
15	greg	1.30	#define MG_VMAJOR 2 /* major version number */
16			#define MG_VMINOR 0 /* minor version number */
17	greg	1.25
18			/* Entities (list is only appended, never modified) */
19	greg	1.21	#define MG_E_COMMENT 0 /* # */
20			#define MG_E_COLOR 1 /* c */
21			#define MG_E_CCT 2 /* cct */
22			#define MG_E_CONE 3 /* cone */
23			#define MG_E_CMIX 4 /* cmix */
24			#define MG_E_CSPEC 5 /* cspec */
25			#define MG_E_CXY 6 /* cxy */
26			#define MG_E_CYL 7 /* cyl */
27			#define MG_E_ED 8 /* ed */
28			#define MG_E_FACE 9 /* f */
29			#define MG_E_INCLUDE 10 /* i */
30			#define MG_E_IES 11 /* ies */
31			#define MG_E_IR 12 /* ir */
32			#define MG_E_MATERIAL 13 /* m */
33			#define MG_E_NORMAL 14 /* n */
34			#define MG_E_OBJECT 15 /* o */
35			#define MG_E_POINT 16 /* p */
36			#define MG_E_PRISM 17 /* prism */
37			#define MG_E_RD 18 /* rd */
38			#define MG_E_RING 19 /* ring */
39			#define MG_E_RS 20 /* rs */
40			#define MG_E_SIDES 21 /* sides */
41			#define MG_E_SPH 22 /* sph */
42			#define MG_E_TD 23 /* td */
43			#define MG_E_TORUS 24 /* torus */
44			#define MG_E_TS 25 /* ts */
45			#define MG_E_VERTEX 26 /* v */
46			#define MG_E_XF 27 /* xf */
47	greg	1.25	/* end of Version 1 entities */
48	greg	1.30	#define MG_E_FACEH 28 /* fh */
49			/* end of Version 2 entities */
50	greg	1.1
51	greg	1.30	#define MG_NENTITIES 29 /* total # entities */
52	greg	1.1
53	greg	1.30	#define MG_NELIST {28,29} /* entity count for version 1 and up */
54	greg	1.25
55	greg	1.18	#define MG_NAMELIST {"#","c","cct","cone","cmix","cspec","cxy","cyl","ed",\
56	greg	1.20	"f","i","ies","ir","m","n","o","p","prism","rd",\
57	greg	1.30	"ring","rs","sides","sph","td","torus","ts","v","xf",\
58			"fh"}
59	greg	1.1
60			#define MG_MAXELEN 6
61
62			extern char mg_ename[MG_NENTITIES][MG_MAXELEN];
63
64	greg	1.24	/* Handler routines for each entity and unknown ones */
65	greg	1.1	extern int (mg_ehand[MG_NENTITIES])(int argc, char *argv);
66	greg	1.24	extern int (mg_uhand)(int argc, char *argv);
67			extern int mg_defuhand(int, char **);
68	greg	1.1
69	greg	1.24	extern unsigned mg_nunknown; /* count of unknown entities */
70
71	greg	1.1	/* Error codes */
72			#define MG_OK 0 /* normal return value */
73			#define MG_EUNK 1 /* unknown entity */
74			#define MG_EARGC 2 /* wrong number of arguments */
75			#define MG_ETYPE 3 /* argument type error */
76			#define MG_EILL 4 /* illegal argument value */
77			#define MG_EUNDEF 5 /* undefined reference */
78			#define MG_ENOFILE 6 /* cannot open input file */
79			#define MG_EINCL 7 /* error in included file */
80			#define MG_EMEM 8 /* out of memory */
81			#define MG_ESEEK 9 /* file seek error */
82	greg	1.2	#define MG_EBADMAT 10 /* bad material specification */
83	greg	1.26	#define MG_ELINE 11 /* input line too long */
84	greg	1.27	#define MG_ECNTXT 12 /* unmatched context close */
85	greg	1.1
86	greg	1.27	#define MG_NERRS 13
87	greg	1.1
88	greg	1.24	extern char mg_err[MG_NERRS]; / list of error messages */
89	greg	1.1
90			/*
91			* The general process for running the parser is to fill in the mg_ehand
92			* array with handlers for each entity you know how to handle.
93			* Then, call mg_init to fill in the rest. This function will report
94			* an error and quit if you try to support an inconsistent set of entities.
95			* For each file you want to parse, call mg_load with the file name.
96			* To read from standard input, use NULL as the file name.
97			* For additional control over error reporting and file management,
98			* use mg_open, mg_read, mg_parse and mg_close instead of mg_load.
99	greg	1.10	* To pass an entity of your own construction to the parser, use
100			* the mg_handle function rather than the mg_ehand routines directly.
101			* (The first argument to mg_handle is the entity #, or -1.)
102	greg	1.1	* To free any data structures and clear the parser, use mg_clear.
103	greg	1.15	* If there is an error, mg_load, mg_open, mg_parse, mg_handle and
104	greg	1.21	* mg_fgoto will return an error from the list above. In addition,
105	greg	1.15	* mg_load will report the error to stderr. The mg_read routine
106			* returns 0 when the end of file has been reached.
107	greg	1.1	*/
108
109	greg	1.17	#define MG_MAXLINE 4096 /* maximum input line length */
110	greg	1.1	#define MG_MAXARGC (MG_MAXLINE/4) /* maximum argument count */
111
112			typedef struct mg_fctxt {
113	greg	1.7	char fname[96]; /* file name */
114	greg	1.1	FILE fp; / stream pointer */
115	greg	1.10	int fid; /* unique file context id */
116	greg	1.1	char inpline[MG_MAXLINE]; /* input line */
117			int lineno; /* line number */
118			struct mg_fctxt prev; / previous context */
119			} MG_FCTXT;
120
121	greg	1.10	typedef struct {
122			int fid; /* file this position is for */
123			int lineno; /* line number in file */
124			long offset; /* offset from beginning */
125			} MG_FPOS;
126
127	greg	1.1	extern MG_FCTXT mg_file; / current file context */
128
129			extern void mg_init(void); /* fill in mg_ehand array */
130			extern int mg_load(char ); / parse a file */
131			extern int mg_open(MG_FCTXT , char ); /* open new input file */
132			extern int mg_read(void); /* read next line */
133			extern int mg_parse(void); /* parse current line */
134	greg	1.10	extern void mg_fgetpos(MG_FPOS ); / get position on input file */
135			extern int mg_fgoto(MG_FPOS ); / go to position on input file */
136	greg	1.1	extern void mg_close(void); /* close input file */
137			extern void mg_clear(void); /* clear parser */
138	greg	1.10	extern int mg_handle(int, int, char *); / handle an entity */
139	greg	1.1
140			#ifndef MG_NQCD
141			#define MG_NQCD 5 /* default number of divisions */
142			#endif
143
144			extern int mg_nqcdivs; /* divisions per quarter circle */
145
146			/*
147			* The following library routines are included for your convenience:
148			*/
149
150			extern int mg_entity(char ); / get entity number from its name */
151			extern int isint(char ); / non-zero if integer format */
152	greg	1.30	extern int isintd(char , char ); /* same with delimiter set */
153	greg	1.1	extern int isflt(char ); / non-zero if floating point format */
154	greg	1.30	extern int isfltd(char , char ); /* same with delimiter set */
155	greg	1.22	extern int isname(char ); / non-zero if legal identifier name */
156	greg	1.30	extern int badarg(int, char *, char );/* check argument format */
157			extern int e_include(int, char *); / expand include entity */
158	gregl	1.31	extern int e_pipe(int, char *); / expand piped command */
159	greg	1.30	extern int e_sph(int, char *); / expand sphere as other entities */
160			extern int e_torus(int, char *); / expand torus as other entities */
161			extern int e_cyl(int, char *); / expand cylinder as other entities */
162			extern int e_ring(int, char *); / expand ring as other entities */
163			extern int e_cone(int, char *); / expand cone as other entities */
164			extern int e_prism(int, char *); / expand prism as other entities */
165			extern int e_faceh(int, char *); / expand face w/ holes as face */
166	greg	1.1
167			/************************************************************************
168			* Definitions for 3-d vector manipulation functions
169			*/
170
171	greg	1.3	#ifdef SMLFLT
172	schorsch	1.35	#define RREAL float
173	greg	1.3	#define FTINY (1e-3)
174	greg	1.2	#else
175	schorsch	1.35	#define RREAL double
176	greg	1.3	#define FTINY (1e-6)
177	greg	1.2	#endif
178	greg	1.3	#define FHUGE (1e10)
179	greg	1.1
180	schorsch	1.35	typedef RREAL FVECT[3];
181	greg	1.2
182	greg	1.3	#define VCOPY(v1,v2) ((v1)[0]=(v2)[0],(v1)[1]=(v2)[1],(v1)[2]=(v2)[2])
183			#define DOT(v1,v2) ((v1)[0](v2)[0]+(v1)[1](v2)[1]+(v1)[2]*(v2)[2])
184			#define VSUM(vr,v1,v2,f) ((vr)[0]=(v1)[0]+(f)*(v2)[0], \
185			(vr)[1]=(v1)[1]+(f)*(v2)[1], \
186			(vr)[2]=(v1)[2]+(f)*(v2)[2])
187
188	greg	1.6	#define is0vect(v) (DOT(v,v) <= FTINY*FTINY)
189	greg	1.3
190			#define round0(x) if (x <= FTINY && x >= -FTINY) x = 0
191
192	greg	1.1	extern double normalize(FVECT); /* normalize a vector */
193	greg	1.30	extern void fcross(FVECT,FVECT,FVECT);/* cross product of two vectors */
194	greg	1.1
195			/************************************************************************
196			* Definitions for context handling routines
197			* (materials, colors, vectors)
198			*/
199
200	greg	1.20	#define C_1SIDEDTHICK 0.005 /* assumed thickness of 1-sided mat. */
201
202	greg	1.5	typedef struct {
203	greg	1.2	int clock; /* incremented each change -- resettable */
204	gregl	1.31	char client_data; / pointer to private client-owned data */
205	greg	1.13	int sided; /* 1 if surface is 1-sided, 0 for 2-sided */
206	greg	1.20	float nr, ni; /* index of refraction, real and imaginary */
207	greg	1.2	float rd; /* diffuse reflectance */
208	greg	1.1	C_COLOR rd_c; /* diffuse reflectance color */
209	greg	1.2	float td; /* diffuse transmittance */
210	greg	1.1	C_COLOR td_c; /* diffuse transmittance color */
211	greg	1.2	float ed; /* diffuse emittance */
212	greg	1.1	C_COLOR ed_c; /* diffuse emittance color */
213	greg	1.2	float rs; /* specular reflectance */
214	greg	1.1	C_COLOR rs_c; /* specular reflectance color */
215	greg	1.2	float rs_a; /* specular reflectance roughness */
216			float ts; /* specular transmittance */
217	greg	1.1	C_COLOR ts_c; /* specular transmittance color */
218	greg	1.2	float ts_a; /* specular transmittance roughness */
219	greg	1.1	} C_MATERIAL; /* material context */
220
221			typedef struct {
222	greg	1.8	int clock; /* incremented each change -- resettable */
223	gregl	1.31	char client_data; / pointer to private client-owned data */
224	greg	1.1	FVECT p, n; /* point and normal */
225			} C_VERTEX; /* vertex context */
226	greg	1.3
227	gregl	1.31	#define C_DEFMATERIAL {1,NULL,0,1.,0.,0.,C_DEFCOLOR,0.,C_DEFCOLOR,0.,\
228			C_DEFCOLOR,0.,C_DEFCOLOR,0.,0.,C_DEFCOLOR,0.}
229			#define C_DEFVERTEX {1,NULL,{0.,0.,0.},{0.,0.,0.}}
230	greg	1.1
231			extern C_COLOR c_ccolor; / the current color */
232	greg	1.12	extern char c_ccname; / current color name */
233	greg	1.1	extern C_MATERIAL c_cmaterial; / the current material */
234	greg	1.12	extern char c_cmname; / current material name */
235	greg	1.1	extern C_VERTEX c_cvertex; / the current vertex */
236	greg	1.12	extern char c_cvname; / current vertex name */
237	greg	1.1
238			extern int c_hcolor(int, char *); / handle color entity */
239			extern int c_hmaterial(int, char *); / handle material entity */
240			extern int c_hvertex(int, char *); / handle vertex entity */
241			extern void c_clearall(void); /* clear context tables */
242	greg	1.11	extern C_MATERIAL c_getmaterial(char ); /* get a named material */
243	greg	1.1	extern C_VERTEX c_getvert(char ); /* get a named vertex */
244	greg	1.7	extern C_COLOR c_getcolor(char ); /* get a named color */
245	greg	1.1
246			/*************************************************************************
247			* Definitions for hierarchical object name handler
248			*/
249
250			extern int obj_nnames; /* depth of name hierarchy */
251			extern char *obj_name; / names in hierarchy */
252
253			extern int obj_handler(int, char *); / handle an object entity */
254	greg	1.2	extern void obj_clear(void); /* clear object stack */
255	greg	1.1
256			/**************************************************************************
257			* Definitions for hierarchical transformation handler
258			*/
259
260	schorsch	1.35	typedef RREAL MAT4[4][4];
261	greg	1.1
262			#define copymat4(m4a,m4b) (void)memcpy((char )m4a,(char )m4b,sizeof(MAT4))
263
264			#define MAT4IDENT { {1.,0.,0.,0.}, {0.,1.,0.,0.}, \
265			{0.,0.,1.,0.}, {0.,0.,0.,1.} }
266
267			extern MAT4 m4ident;
268
269			#define setident4(m4) copymat4(m4, m4ident)
270
271			/* regular transformation */
272			typedef struct {
273	greg	1.14	MAT4 xfm; /* transform matrix */
274	schorsch	1.35	RREAL sca; /* scalefactor */
275	greg	1.1	} XF;
276
277			#define identxf(xp) (void)(setident4((xp)->xfm),(xp)->sca=1.0)
278
279	greg	1.10	#define XF_MAXDIM 8 /* maximum array dimensions */
280
281			struct xf_array {
282			MG_FPOS spos; /* starting position on input */
283			int ndim; /* number of array dimensions */
284			struct {
285			short i, n; /* current count and maximum */
286			char arg[8]; /* string argument value */
287			} aarg[XF_MAXDIM];
288			};
289
290	greg	1.1	typedef struct xf_spec {
291	greg	1.10	long xid; /* unique transform id */
292	greg	1.23	short xac; /* context argument count */
293	greg	1.14	short rev; /* boolean true if vertices reversed */
294	greg	1.10	XF xf; /* cumulative transformation */
295			struct xf_array xarr; / transformation array pointer */
296			struct xf_spec prev; / previous transformation context */
297			} XF_SPEC; /* followed by argument buffer */
298	greg	1.1
299	greg	1.23	extern XF_SPEC xf_context; / current transform context */
300			extern char *xf_argend; / last transform argument */
301
302	greg	1.28	#define xf_ac(xf) ((xf)==NULL ? 0 : (xf)->xac)
303	greg	1.23	#define xf_av(xf) (xf_argend - (xf)->xac)
304
305	greg	1.28	#define xf_argc xf_ac(xf_context)
306	greg	1.23	#define xf_argv xf_av(xf_context)
307	greg	1.1
308			/*
309			* The transformation handler should do most of the work that needs
310			* doing. Just pass it any xf entities, then use the associated
311			* functions to transform and translate points, transform vectors
312			* (without translation), rotate vectors (without scaling) and scale
313			* values appropriately.
314			*
315			* The routines xf_xfmpoint, xf_xfmvect and xf_rotvect take two
316			* 3-D vectors (which may be identical), transforms the second and
317			* puts the result into the first.
318			*/
319
320
321	greg	1.2	extern int xf_handler(int, char *); / handle xf entity */
322			extern void xf_xfmpoint(FVECT, FVECT); /* transform point */
323			extern void xf_xfmvect(FVECT, FVECT); /* transform vector */
324			extern void xf_rotvect(FVECT, FVECT); /* rotate vector */
325			extern double xf_scale(double); /* scale a value */
326			extern void xf_clear(void); /* clear xf stack */
327	greg	1.1
328			/* The following are support routines you probably won't call directly */
329
330	greg	1.28	XF_SPEC new_xf(int, char ); / allocate new transform */
331			void free_xf(XF_SPEC ); / free a transform */
332			int xf_aname(struct xf_array ); / name this instance */
333			long comp_xfid(MAT4); /* compute unique ID */
334	greg	1.1	extern void multmat4(MAT4, MAT4, MAT4); /* m4a = m4b X m4c */
335			extern void multv3(FVECT, FVECT, MAT4); /* v3a = v3b X m4 (vectors) */
336			extern void multp3(FVECT, FVECT, MAT4); /* p3a = p3b X m4 (points) */
337	greg	1.6	extern int xf(XF , int, char ); / interpret transform spec. */
338	schorsch	1.37
339			/* cvrgb.c */
340			extern void mgf2rgb(C_COLOR *cin, double intensity, float cout[3]);
341	greg	1.1
342
343			/************************************************************************
344			* Miscellaneous definitions
345			*/
346
347	greg	1.29	#ifndef PI
348	greg	1.1	#ifdef M_PI
349	gregl	1.32	#define PI ((double)M_PI)
350	greg	1.1	#else
351			#define PI 3.14159265358979323846
352	greg	1.29	#endif
353	greg	1.1	#endif
354
355			#ifndef MEM_PTR
356			#define MEM_PTR void *
357			#endif
358	greg	1.30
359	schorsch	1.34	#ifdef __cplusplus
360			}
361			#endif
362			#endif /* _MGF_PARSER_H_ */
363