cv/mgflib/parser.h

/* Copyright (c) 1994 Regents of the University of California */

/* SCCSid "$SunId$ LBL" */

/*
 * Header file for MGF interpreter
 */

/* must include stdio.h before us */

                        /* Entities (order doesn't really matter) */
#define MG_E_COMMENT    0
#define MG_E_COLOR      1
#define MG_E_CONE       2
#define MG_E_CMIX       3
#define MG_E_CSPEC      4
#define MG_E_CXY        5
#define MG_E_CYL        6
#define MG_E_ED         7
#define MG_E_FACE       8
#define MG_E_INCLUDE    9
#define MG_E_IES        10
#define MG_E_MATERIAL   11
#define MG_E_NORMAL     12
#define MG_E_OBJECT     13
#define MG_E_POINT      14
#define MG_E_PRISM      15
#define MG_E_RD         16
#define MG_E_RING       17
#define MG_E_RS         18
#define MG_E_SPH        19
#define MG_E_TD         20
#define MG_E_TORUS      21
#define MG_E_TS         22
#define MG_E_VERTEX     23
#define MG_E_XF         24

#define MG_NENTITIES    25

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

#define MG_MAXELEN      6

extern char     mg_ename[MG_NENTITIES][MG_MAXELEN];

                        /* Handler routines for each entity */

#ifdef NOPROTO
extern int      (*mg_ehand[MG_NENTITIES])();
#else
extern int      (*mg_ehand[MG_NENTITIES])(int argc, char **argv);
#endif

                        /* 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_NERRS        11

extern char     *mg_err[MG_NERRS];

/*
 * 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, and mg_rewind
 * 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      512             /* 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 */

#ifdef NOPROTO
extern void     mg_init();              /* fill in mg_ehand array */
extern int      mg_load();              /* parse a file */
extern int      mg_open();              /* open new input file */
extern int      mg_read();              /* read next line */
extern int      mg_parse();             /* parse current line */
extern void     mg_fgetpos();           /* get position on input file */
extern int      mg_fgoto();             /* go to position on input file */
extern void     mg_close();             /* close input file */
extern void     mg_clear();             /* clear parser */
extern int      mg_handle();            /* handle an entity */
#else
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 */
#endif

#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:
 */

#ifdef NOPROTO
extern int mg_entity();                 /* get entity number from its name */
extern int isint();                     /* non-zero if integer format */
extern int isflt();                     /* non-zero if floating point format */
#else
extern int mg_entity(char *);           /* get entity number from its name */
extern int isint(char *);               /* non-zero if integer format */
extern int isflt(char *);               /* non-zero if floating point format */
#endif

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

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

typedef FLOAT  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

#ifdef NOPROTO
extern double   normalize();            /* normalize a vector */
#else
extern double   normalize(FVECT);       /* normalize a vector */
#endif

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

#define C_CMINWL        380             /* minimum wavelength */
#define C_CMAXWL        780             /* maximum wavelength */
#define C_CNSS          41              /* number of spectral samples */
#define C_CWLI          ((C_CMAXWL-C_CMINWL)/(C_CNSS-1))
#define C_CMAXV         10000           /* nominal maximum sample value */

#define C_CSSPEC        01              /* flag if spectrum is set */
#define C_CDSPEC        02              /* flag if defined w/ spectrum */
#define C_CSXY          04              /* flag if xy is set */
#define C_CDXY          010             /* flag if defined w/ xy */

typedef struct {
        char    *name;                  /* material name */
        int     clock;                  /* incremented each change */
        short   flags;                  /* what's been set */
        short   ssamp[C_CNSS];          /* spectral samples, min wl to max */
        long    ssum;                   /* straight sum of spectral values */
        float   cx, cy;                 /* xy chromaticity value */
} C_COLOR;

#define C_DEFCOLOR      { NULL, 0, C_CDXY|C_CSXY|C_CSSPEC,\
                        {C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
                        C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
                        C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
                        C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
                        C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
                        C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
                        C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV},\
                        (long)C_CNSS*C_CMAXV, 1./3., 1./3. }

#define C_CIEX          { "_cie_x", 0, C_CDSPEC|C_CSSPEC|C_CSXY,\
                        {14,42,143,435,1344,2839,3483,3362,2908,1954,956,\
                        320,49,93,633,1655,2904,4334,5945,7621,9163,10263,\
                        10622,10026,8544,6424,4479,2835,1649,874,468,227,\
                        114,58,29,14,7,3,2,1,0}, 106836L, .735, .265 }

#define C_CIEY          { "_cie_y", 0, C_CDSPEC|C_CSSPEC|C_CSXY,\
                        {0,1,4,12,40,116,230,380,600,910,1390,2080,3230,\
                        5030,7100,8620,9540,9950,9950,9520,8700,7570,6310,\
                        5030,3810,2650,1750,1070,610,320,170,82,41,21,10,\
                        5,2,1,1,0,0}, 106856L, .274, .717 }

#define C_CIEZ          { "_cie_z", 0, C_CDSPEC|C_CSSPEC|C_CSXY,\
                        {65,201,679,2074,6456,13856,17471,17721,16692,\
                        12876,8130,4652,2720,1582,782,422,203,87,39,21,17,\
                        11,8,3,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},\
                        106770L, .167, .009 }

#define c_cval(c,l)     ((double)(c)->ssamp[((l)-C_MINWL)/C_CWLI] / (c)->sum)

typedef struct {
        char    *name;          /* material name */
        int     clock;          /* incremented each change -- resettable */
        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 {
        char    *name;          /* vector name */
        int     clock;          /* incremented each change -- resettable */
        FVECT   p, n;           /* point and normal */
} C_VERTEX;             /* vertex context */

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

extern C_COLOR          *c_ccolor;      /* the current color */
extern C_MATERIAL       *c_cmaterial;   /* the current material */
extern C_VERTEX         *c_cvertex;     /* the current vertex */

#ifdef NOPROTO
extern int      c_hcolor();                     /* handle color entity */
extern int      c_hmaterial();                  /* handle material entity */
extern int      c_hvertex();                    /* handle vertex entity */
extern void     c_clearall();                   /* clear context tables */
extern C_MATERIAL       *c_getmaterial();       /* get a named material */
extern C_VERTEX *c_getvert();                   /* get a named vertex */
extern C_COLOR  *c_getcolor();                  /* get a named color */
extern void     c_ccvt();                       /* fix color representation */
extern int      c_isgrey();                     /* check if color is grey */
#else
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 */
extern void     c_ccvt(C_COLOR *, int);         /* fix color representation */
extern int      c_isgrey(C_COLOR *);            /* check if color is grey */
#endif

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

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

#ifdef NOPROTO
extern int      obj_handler();                  /* handle an object entity */
extern void     obj_clear();                    /* clear object stack */
#else
extern int      obj_handler(int, char **);      /* handle an object entity */
extern void     obj_clear(void);                /* clear object stack */
#endif

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

typedef FLOAT  MAT4[4][4];

#ifdef  BSD
#define  copymat4(m4a,m4b)      bcopy((char *)m4b,(char *)m4a,sizeof(MAT4))
#else
#define  copymat4(m4a,m4b)      (void)memcpy((char *)m4a,(char *)m4b,sizeof(MAT4))
#endif

#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 */
        FLOAT  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   xav0;                   /* zeroeth argument in xf_argv array */
        short   xac;                    /* transform argument count */
        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 int      xf_argc;                        /* total # transform args. */
extern char     **xf_argv;                      /* transform arguments */
extern XF_SPEC  *xf_context;                    /* current 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.
 */

#ifdef NOPROTO

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

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

extern void     multmat4();             /* m4a = m4b X m4c */
extern void     multv3();               /* v3a = v3b X m4 (vectors) */
extern void     multp3();               /* p3a = p3b X m4 (points) */
extern int      xf();                   /* interpret transform spec. */

#else

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 */

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. */

#endif

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

#ifdef  M_PI
#define  PI             M_PI
#else
#define  PI             3.14159265358979323846
#endif

#ifdef DCL_ATOF
extern double   atof();
#endif

#ifndef MEM_PTR
#define MEM_PTR         void *
#endif

extern MEM_PTR  malloc();
extern MEM_PTR  calloc();
extern MEM_PTR  realloc();
extern void     free();
Revision:	1.11
Committed:	Thu Jun 30 11:07:38 1994 UTC (29 years, 10 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 1.10:	+2 -0 lines
Log Message:	added c_getmaterial() call
#	User	Rev	Content
1	greg	1.1	/* Copyright (c) 1994 Regents of the University of California */
2
3			/* SCCSid "$SunId$ LBL" */
4
5			/*
6			* Header file for MGF interpreter
7			*/
8
9			/* must include stdio.h before us */
10
11			/* Entities (order doesn't really matter) */
12			#define MG_E_COMMENT 0
13			#define MG_E_COLOR 1
14			#define MG_E_CONE 2
15	greg	1.5	#define MG_E_CMIX 3
16	greg	1.6	#define MG_E_CSPEC 4
17			#define MG_E_CXY 5
18	greg	1.5	#define MG_E_CYL 6
19			#define MG_E_ED 7
20			#define MG_E_FACE 8
21			#define MG_E_INCLUDE 9
22			#define MG_E_IES 10
23			#define MG_E_MATERIAL 11
24			#define MG_E_NORMAL 12
25			#define MG_E_OBJECT 13
26			#define MG_E_POINT 14
27			#define MG_E_PRISM 15
28			#define MG_E_RD 16
29			#define MG_E_RING 17
30			#define MG_E_RS 18
31			#define MG_E_SPH 19
32			#define MG_E_TD 20
33			#define MG_E_TORUS 21
34			#define MG_E_TS 22
35			#define MG_E_VERTEX 23
36			#define MG_E_XF 24
37	greg	1.1
38	greg	1.5	#define MG_NENTITIES 25
39	greg	1.1
40	greg	1.5	#define MG_NAMELIST {"#","c","cone","cmix","cspec","cxy","cyl","ed","f",\
41			"i","ies","m","n","o","p","prism","rd","ring","rs",\
42			"sph","td","torus","ts","v","xf"}
43	greg	1.1
44			#define MG_MAXELEN 6
45
46			extern char mg_ename[MG_NENTITIES][MG_MAXELEN];
47
48			/* Handler routines for each entity */
49
50			#ifdef NOPROTO
51			extern int (*mg_ehand[MG_NENTITIES])();
52			#else
53			extern int (mg_ehand[MG_NENTITIES])(int argc, char *argv);
54			#endif
55
56			/* Error codes */
57			#define MG_OK 0 /* normal return value */
58			#define MG_EUNK 1 /* unknown entity */
59			#define MG_EARGC 2 /* wrong number of arguments */
60			#define MG_ETYPE 3 /* argument type error */
61			#define MG_EILL 4 /* illegal argument value */
62			#define MG_EUNDEF 5 /* undefined reference */
63			#define MG_ENOFILE 6 /* cannot open input file */
64			#define MG_EINCL 7 /* error in included file */
65			#define MG_EMEM 8 /* out of memory */
66			#define MG_ESEEK 9 /* file seek error */
67	greg	1.2	#define MG_EBADMAT 10 /* bad material specification */
68	greg	1.1
69	greg	1.2	#define MG_NERRS 11
70	greg	1.1
71			extern char *mg_err[MG_NERRS];
72
73			/*
74			* The general process for running the parser is to fill in the mg_ehand
75			* array with handlers for each entity you know how to handle.
76			* Then, call mg_init to fill in the rest. This function will report
77			* an error and quit if you try to support an inconsistent set of entities.
78			* For each file you want to parse, call mg_load with the file name.
79			* To read from standard input, use NULL as the file name.
80			* For additional control over error reporting and file management,
81			* use mg_open, mg_read, mg_parse and mg_close instead of mg_load.
82	greg	1.10	* To pass an entity of your own construction to the parser, use
83			* the mg_handle function rather than the mg_ehand routines directly.
84			* (The first argument to mg_handle is the entity #, or -1.)
85	greg	1.1	* To free any data structures and clear the parser, use mg_clear.
86			* If there is an error, mg_load, mg_open, mg_parse, and mg_rewind
87			* will return an error from the list above. In addition, mg_load
88			* will report the error to stderr. The mg_read routine returns 0
89			* when the end of file has been reached.
90			*/
91
92			#define MG_MAXLINE 512 /* maximum input line length */
93			#define MG_MAXARGC (MG_MAXLINE/4) /* maximum argument count */
94
95			typedef struct mg_fctxt {
96	greg	1.7	char fname[96]; /* file name */
97	greg	1.1	FILE fp; / stream pointer */
98	greg	1.10	int fid; /* unique file context id */
99	greg	1.1	char inpline[MG_MAXLINE]; /* input line */
100			int lineno; /* line number */
101			struct mg_fctxt prev; / previous context */
102			} MG_FCTXT;
103
104	greg	1.10	typedef struct {
105			int fid; /* file this position is for */
106			int lineno; /* line number in file */
107			long offset; /* offset from beginning */
108			} MG_FPOS;
109
110	greg	1.1	extern MG_FCTXT mg_file; / current file context */
111
112			#ifdef NOPROTO
113			extern void mg_init(); /* fill in mg_ehand array */
114			extern int mg_load(); /* parse a file */
115			extern int mg_open(); /* open new input file */
116			extern int mg_read(); /* read next line */
117			extern int mg_parse(); /* parse current line */
118	greg	1.10	extern void mg_fgetpos(); /* get position on input file */
119			extern int mg_fgoto(); /* go to position on input file */
120	greg	1.1	extern void mg_close(); /* close input file */
121			extern void mg_clear(); /* clear parser */
122	greg	1.10	extern int mg_handle(); /* handle an entity */
123	greg	1.1	#else
124			extern void mg_init(void); /* fill in mg_ehand array */
125			extern int mg_load(char ); / parse a file */
126			extern int mg_open(MG_FCTXT , char ); /* open new input file */
127			extern int mg_read(void); /* read next line */
128			extern int mg_parse(void); /* parse current line */
129	greg	1.10	extern void mg_fgetpos(MG_FPOS ); / get position on input file */
130			extern int mg_fgoto(MG_FPOS ); / go to position on input file */
131	greg	1.1	extern void mg_close(void); /* close input file */
132			extern void mg_clear(void); /* clear parser */
133	greg	1.10	extern int mg_handle(int, int, char *); / handle an entity */
134	greg	1.1	#endif
135
136			#ifndef MG_NQCD
137			#define MG_NQCD 5 /* default number of divisions */
138			#endif
139
140			extern int mg_nqcdivs; /* divisions per quarter circle */
141
142			/*
143			* The following library routines are included for your convenience:
144			*/
145
146			#ifdef NOPROTO
147			extern int mg_entity(); /* get entity number from its name */
148			extern int isint(); /* non-zero if integer format */
149			extern int isflt(); /* non-zero if floating point format */
150			#else
151			extern int mg_entity(char ); / get entity number from its name */
152			extern int isint(char ); / non-zero if integer format */
153			extern int isflt(char ); / non-zero if floating point format */
154			#endif
155
156			/************************************************************************
157			* Definitions for 3-d vector manipulation functions
158			*/
159
160	greg	1.3	#ifdef SMLFLT
161			#define FLOAT float
162			#define FTINY (1e-3)
163	greg	1.2	#else
164	greg	1.3	#define FLOAT double
165			#define FTINY (1e-6)
166	greg	1.2	#endif
167	greg	1.3	#define FHUGE (1e10)
168	greg	1.1
169	greg	1.2	typedef FLOAT FVECT[3];
170
171	greg	1.3	#define VCOPY(v1,v2) ((v1)[0]=(v2)[0],(v1)[1]=(v2)[1],(v1)[2]=(v2)[2])
172			#define DOT(v1,v2) ((v1)[0](v2)[0]+(v1)[1](v2)[1]+(v1)[2]*(v2)[2])
173			#define VSUM(vr,v1,v2,f) ((vr)[0]=(v1)[0]+(f)*(v2)[0], \
174			(vr)[1]=(v1)[1]+(f)*(v2)[1], \
175			(vr)[2]=(v1)[2]+(f)*(v2)[2])
176
177	greg	1.6	#define is0vect(v) (DOT(v,v) <= FTINY*FTINY)
178	greg	1.3
179			#define round0(x) if (x <= FTINY && x >= -FTINY) x = 0
180
181	greg	1.1	#ifdef NOPROTO
182			extern double normalize(); /* normalize a vector */
183			#else
184			extern double normalize(FVECT); /* normalize a vector */
185			#endif
186
187			/************************************************************************
188			* Definitions for context handling routines
189			* (materials, colors, vectors)
190			*/
191
192	greg	1.6	#define C_CMINWL 380 /* minimum wavelength */
193	greg	1.5	#define C_CMAXWL 780 /* maximum wavelength */
194			#define C_CNSS 41 /* number of spectral samples */
195	greg	1.6	#define C_CWLI ((C_CMAXWL-C_CMINWL)/(C_CNSS-1))
196	greg	1.5	#define C_CMAXV 10000 /* nominal maximum sample value */
197
198	greg	1.6	#define C_CSSPEC 01 /* flag if spectrum is set */
199			#define C_CDSPEC 02 /* flag if defined w/ spectrum */
200			#define C_CSXY 04 /* flag if xy is set */
201			#define C_CDXY 010 /* flag if defined w/ xy */
202	greg	1.5
203	greg	1.1	typedef struct {
204	greg	1.8	char name; / material name */
205			int clock; /* incremented each change */
206	greg	1.5	short flags; /* what's been set */
207			short ssamp[C_CNSS]; /* spectral samples, min wl to max */
208			long ssum; /* straight sum of spectral values */
209	greg	1.6	float cx, cy; /* xy chromaticity value */
210	greg	1.5	} C_COLOR;
211
212	greg	1.9	#define C_DEFCOLOR { NULL, 0, C_CDXY\|C_CSXY\|C_CSSPEC,\
213	greg	1.5	{C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
214			C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
215			C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
216			C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
217			C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
218			C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,\
219			C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV,C_CMAXV},\
220	greg	1.6	(long)C_CNSS*C_CMAXV, 1./3., 1./3. }
221	greg	1.5
222	greg	1.9	#define C_CIEX { "_cie_x", 0, C_CDSPEC\|C_CSSPEC\|C_CSXY,\
223	greg	1.5	{14,42,143,435,1344,2839,3483,3362,2908,1954,956,\
224			320,49,93,633,1655,2904,4334,5945,7621,9163,10263,\
225			10622,10026,8544,6424,4479,2835,1649,874,468,227,\
226	greg	1.6	114,58,29,14,7,3,2,1,0}, 106836L, .735, .265 }
227	greg	1.5
228	greg	1.9	#define C_CIEY { "_cie_y", 0, C_CDSPEC\|C_CSSPEC\|C_CSXY,\
229	greg	1.5	{0,1,4,12,40,116,230,380,600,910,1390,2080,3230,\
230			5030,7100,8620,9540,9950,9950,9520,8700,7570,6310,\
231			5030,3810,2650,1750,1070,610,320,170,82,41,21,10,\
232	greg	1.6	5,2,1,1,0,0}, 106856L, .274, .717 }
233	greg	1.5
234	greg	1.9	#define C_CIEZ { "_cie_z", 0, C_CDSPEC\|C_CSSPEC\|C_CSXY,\
235	greg	1.5	{65,201,679,2074,6456,13856,17471,17721,16692,\
236			12876,8130,4652,2720,1582,782,422,203,87,39,21,17,\
237	greg	1.6	11,8,3,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},\
238			106770L, .167, .009 }
239	greg	1.5
240	greg	1.6	#define c_cval(c,l) ((double)(c)->ssamp[((l)-C_MINWL)/C_CWLI] / (c)->sum)
241	greg	1.5
242			typedef struct {
243	greg	1.2	char name; / material name */
244			int clock; /* incremented each change -- resettable */
245			float rd; /* diffuse reflectance */
246	greg	1.1	C_COLOR rd_c; /* diffuse reflectance color */
247	greg	1.2	float td; /* diffuse transmittance */
248	greg	1.1	C_COLOR td_c; /* diffuse transmittance color */
249	greg	1.2	float ed; /* diffuse emittance */
250	greg	1.1	C_COLOR ed_c; /* diffuse emittance color */
251	greg	1.2	float rs; /* specular reflectance */
252	greg	1.1	C_COLOR rs_c; /* specular reflectance color */
253	greg	1.2	float rs_a; /* specular reflectance roughness */
254			float ts; /* specular transmittance */
255	greg	1.1	C_COLOR ts_c; /* specular transmittance color */
256	greg	1.2	float ts_a; /* specular transmittance roughness */
257	greg	1.1	} C_MATERIAL; /* material context */
258
259			typedef struct {
260	greg	1.8	char name; / vector name */
261			int clock; /* incremented each change -- resettable */
262	greg	1.1	FVECT p, n; /* point and normal */
263			} C_VERTEX; /* vertex context */
264	greg	1.3
265	greg	1.9	#define C_DEFMATERIAL {NULL,0,0.,C_DEFCOLOR,0.,C_DEFCOLOR,0.,C_DEFCOLOR,\
266	greg	1.2	0.,C_DEFCOLOR,0.,0.,C_DEFCOLOR,0.}
267	greg	1.9	#define C_DEFVERTEX {NULL,0,{0.,0.,0.},{0.,0.,0.}}
268	greg	1.1
269			extern C_COLOR c_ccolor; / the current color */
270			extern C_MATERIAL c_cmaterial; / the current material */
271			extern C_VERTEX c_cvertex; / the current vertex */
272
273			#ifdef NOPROTO
274			extern int c_hcolor(); /* handle color entity */
275			extern int c_hmaterial(); /* handle material entity */
276			extern int c_hvertex(); /* handle vertex entity */
277			extern void c_clearall(); /* clear context tables */
278	greg	1.11	extern C_MATERIAL c_getmaterial(); / get a named material */
279	greg	1.1	extern C_VERTEX c_getvert(); / get a named vertex */
280	greg	1.7	extern C_COLOR c_getcolor(); / get a named color */
281	greg	1.6	extern void c_ccvt(); /* fix color representation */
282			extern int c_isgrey(); /* check if color is grey */
283	greg	1.1	#else
284			extern int c_hcolor(int, char *); / handle color entity */
285			extern int c_hmaterial(int, char *); / handle material entity */
286			extern int c_hvertex(int, char *); / handle vertex entity */
287			extern void c_clearall(void); /* clear context tables */
288	greg	1.11	extern C_MATERIAL c_getmaterial(char ); /* get a named material */
289	greg	1.1	extern C_VERTEX c_getvert(char ); /* get a named vertex */
290	greg	1.7	extern C_COLOR c_getcolor(char ); /* get a named color */
291	greg	1.6	extern void c_ccvt(C_COLOR , int); / fix color representation */
292			extern int c_isgrey(C_COLOR ); / check if color is grey */
293	greg	1.1	#endif
294
295			/*************************************************************************
296			* Definitions for hierarchical object name handler
297			*/
298
299			extern int obj_nnames; /* depth of name hierarchy */
300			extern char *obj_name; / names in hierarchy */
301
302			#ifdef NOPROTO
303			extern int obj_handler(); /* handle an object entity */
304	greg	1.2	extern void obj_clear(); /* clear object stack */
305	greg	1.1	#else
306			extern int obj_handler(int, char *); / handle an object entity */
307	greg	1.2	extern void obj_clear(void); /* clear object stack */
308	greg	1.1	#endif
309
310			/**************************************************************************
311			* Definitions for hierarchical transformation handler
312			*/
313
314	greg	1.2	typedef FLOAT MAT4[4][4];
315	greg	1.1
316			#ifdef BSD
317			#define copymat4(m4a,m4b) bcopy((char )m4b,(char )m4a,sizeof(MAT4))
318			#else
319			#define copymat4(m4a,m4b) (void)memcpy((char )m4a,(char )m4b,sizeof(MAT4))
320			#endif
321
322			#define MAT4IDENT { {1.,0.,0.,0.}, {0.,1.,0.,0.}, \
323			{0.,0.,1.,0.}, {0.,0.,0.,1.} }
324
325			extern MAT4 m4ident;
326
327			#define setident4(m4) copymat4(m4, m4ident)
328
329			/* regular transformation */
330			typedef struct {
331			MAT4 xfm; /* transform matrix */
332	greg	1.2	FLOAT sca; /* scalefactor */
333	greg	1.1	} XF;
334
335			#define identxf(xp) (void)(setident4((xp)->xfm),(xp)->sca=1.0)
336
337	greg	1.10	#define XF_MAXDIM 8 /* maximum array dimensions */
338
339			struct xf_array {
340			MG_FPOS spos; /* starting position on input */
341			int ndim; /* number of array dimensions */
342			struct {
343			short i, n; /* current count and maximum */
344			char arg[8]; /* string argument value */
345			} aarg[XF_MAXDIM];
346			};
347
348	greg	1.1	typedef struct xf_spec {
349	greg	1.10	long xid; /* unique transform id */
350			short xav0; /* zeroeth argument in xf_argv array */
351			short xac; /* transform argument count */
352			XF xf; /* cumulative transformation */
353			struct xf_array xarr; / transformation array pointer */
354			struct xf_spec prev; / previous transformation context */
355			} XF_SPEC; /* followed by argument buffer */
356	greg	1.1
357			extern int xf_argc; /* total # transform args. */
358			extern char *xf_argv; / transform arguments */
359			extern XF_SPEC xf_context; / current context */
360
361			/*
362			* The transformation handler should do most of the work that needs
363			* doing. Just pass it any xf entities, then use the associated
364			* functions to transform and translate points, transform vectors
365			* (without translation), rotate vectors (without scaling) and scale
366			* values appropriately.
367			*
368			* The routines xf_xfmpoint, xf_xfmvect and xf_rotvect take two
369			* 3-D vectors (which may be identical), transforms the second and
370			* puts the result into the first.
371			*/
372
373			#ifdef NOPROTO
374
375			extern int xf_handler(); /* handle xf entity */
376			extern void xf_xfmpoint(); /* transform point */
377			extern void xf_xfmvect(); /* transform vector */
378			extern void xf_rotvect(); /* rotate vector */
379			extern double xf_scale(); /* scale a value */
380	greg	1.2	extern void xf_clear(); /* clear xf stack */
381	greg	1.1
382			/* The following are support routines you probably won't call directly */
383
384			extern void multmat4(); /* m4a = m4b X m4c */
385			extern void multv3(); /* v3a = v3b X m4 (vectors) */
386			extern void multp3(); /* p3a = p3b X m4 (points) */
387			extern int xf(); /* interpret transform spec. */
388
389			#else
390
391	greg	1.2	extern int xf_handler(int, char *); / handle xf entity */
392			extern void xf_xfmpoint(FVECT, FVECT); /* transform point */
393			extern void xf_xfmvect(FVECT, FVECT); /* transform vector */
394			extern void xf_rotvect(FVECT, FVECT); /* rotate vector */
395			extern double xf_scale(double); /* scale a value */
396			extern void xf_clear(void); /* clear xf stack */
397	greg	1.1
398			/* The following are support routines you probably won't call directly */
399
400			extern void multmat4(MAT4, MAT4, MAT4); /* m4a = m4b X m4c */
401			extern void multv3(FVECT, FVECT, MAT4); /* v3a = v3b X m4 (vectors) */
402			extern void multp3(FVECT, FVECT, MAT4); /* p3a = p3b X m4 (points) */
403	greg	1.6	extern int xf(XF , int, char ); / interpret transform spec. */
404	greg	1.1
405			#endif
406
407			/************************************************************************
408			* Miscellaneous definitions
409			*/
410
411			#ifdef M_PI
412			#define PI M_PI
413			#else
414			#define PI 3.14159265358979323846
415			#endif
416
417			#ifdef DCL_ATOF
418			extern double atof();
419			#endif
420
421			#ifndef MEM_PTR
422			#define MEM_PTR void *
423			#endif
424
425			extern MEM_PTR malloc();
426			extern MEM_PTR calloc();
427			extern MEM_PTR realloc();
428	greg	1.4	extern void free();