src/common/mesh.h

/* RCSid $Id$ */
/*
 * Header for compact triangle mesh geometry
 *
 *  Include after standard.h, object.h and octree.h
 */

#include "copyright.h"

#include "lookup.h"

#ifndef uint4
#define uint4   unsigned int4
#endif
#ifndef BYTE
#define BYTE    unsigned char
#endif

/*
 * Vertex space is minimized without compromising accuracy by using a
 * 4-byte unsigned int to indicate position in the enclosing octree cube.
 * The same trick is used for any local (u,v) coordinates, whose limits
 * are recorded separately in the parent MESH structure.  The uvlimit's
 * in the MESH structure are set such that (0,0) is out of range, so
 * we use this to indicate an unspecified local coordinate.
 * A vertex normal, if specified, is stored in a single 4-byte
 * integer using the codec in dircode.c.  The encodedir() function
 * never generates 0, so we can use this for unspecified normals.
 *
 * Vertex ID's are encoded using the bottom 8 bits of a 4-byte integer
 * to index a vertex in a patch indicated by the 22 bits above (8-29).
 * For triangle ID's, the top 22 bits (10-31) indicate the patch, and
 * the bit 9 (0x200) indicates whether the triangle joins patches.
 * If not, then the bottom 9 bits index into the local PTri array.
 * If it's a joiner, then the 8th bit indicates whether the triangle joins
 * two patches, in which case the bottom 8 bits index the PJoin2 array.
 * Otherwise, the bottom 8 bits index the PJoin1 array.
 *
 * These shenanigans minimize vertex reference memory requirements
 * in compiled mesh structures, where the octree leaves contain sets 
 * of triangle ID's rather than the more usual objects.  It seems like
 * a lot of effort, but it can reduce mesh storage by a factor of 3
 * or more.  This is important, as the whole point is to model very
 * complicated geometry with this structure, and memory is the main
 * limitation.
 */

/* A triangle mesh patch */
typedef struct {
        uint4           (*xyz)[3];      /* up to 256 patch vertices */
        int4            *norm;          /* vertex normals */
        uint4           (*uv)[2];       /* vertex local coordinates */
        struct PTri {
                BYTE            v1, v2, v3;     /* local vertices */
        }               *tri;           /* local triangles */
        short           solemat;        /* sole material */
        int2            *trimat;        /* or local material indices */
        struct PJoin1 {
                int4            v1j;            /* non-local vertex */
                int2            mat;            /* material index */
                BYTE            v2, v3;         /* local vertices */
        }               *j1tri;         /* joiner triangles */
        struct PJoin2 {
                int4            v1j, v2j;       /* non-local vertices */
                int2            mat;            /* material index */
                BYTE            v3;             /* local vertex */
        }               *j2tri;         /* double joiner triangles */
        short           nverts;         /* vertex count */
        short           ntris;          /* triangle count */
        short           nj1tris;        /* joiner triangle count */
        short           nj2tris;        /* double joiner triangle count */
} MESHPATCH;

/* A loaded mesh */
typedef struct mesh {
        char            *name;          /* mesh file name */
        int             nref;           /* reference count */
        int             ldflags;        /* what we've loaded */
        CUBE            mcube;          /* bounds and octree */
        FLOAT           uvlim[2][2];    /* local coordinate extrema */
        OBJECT          mat0;           /* base material index */
        OBJECT          nmats;          /* number of materials */
        MESHPATCH       *patch;         /* mesh patch list */
        int             npatches;       /* number of mesh patches */
        OBJREC          *pseudo;        /* mesh pseudo objects */
        LUTAB           lut;            /* vertex lookup table */
        struct mesh     *next;          /* next mesh in list */
} MESH;

/* A mesh instance */
typedef struct {
        FULLXF          x;              /* forward and backward transforms */
        MESH            *msh;           /* mesh object reference */
} MESHINST;

                                /* vertex flags */
#define MT_V            01
#define MT_N            02
#define MT_UV           04
#define MT_ALL          07

/* A mesh vertex */
typedef struct {
        int             fl;             /* setting flags */
        FVECT           v;              /* vertex location */
        FVECT           n;              /* vertex normal */
        FLOAT           uv[2];          /* local coordinates */
} MESHVERT;

                                /* mesh format identifier */
#define MESHFMT         "Radiance_tmesh"
                                /* magic number for mesh files */
#define MESHMAGIC       ( 1 *MAXOBJSIZ+311)     /* increment first value */

#ifdef NOPROTO

extern MESH     *getmesh();
extern MESHINST *getmeshinst();
extern int      getmeshtrivid();
extern int      getmeshvert();
extern int      getmeshtri();
extern OBJREC   *getmeshpseudo();
extern int4     addmeshvert();
extern OBJECT   addmeshtri();
extern char     *checkmesh();
extern void     printmeshstats();
extern void     freemesh();
extern void     freemeshinst();
extern void     readmesh();
extern void     writemesh();

#else

extern MESH     *getmesh(char *mname, int flags);
extern MESHINST *getmeshinst(OBJREC *o, int flags);
extern int      getmeshtrivid(int4 tvid[3], OBJECT *mo,
                                MESH *mp, OBJECT ti);
extern int      getmeshvert(MESHVERT *vp, MESH *mp, int4 vid, int what);
extern int      getmeshtri(MESHVERT tv[3], OBJECT *mo,
                                MESH *mp, OBJECT ti, int what);
extern OBJREC   *getmeshpseudo(MESH *mp, OBJECT mo);
extern int4     addmeshvert(MESH *mp, MESHVERT *vp);
extern OBJECT   addmeshtri(MESH *mp, MESHVERT tv[3], OBJECT mo);
extern char     *checkmesh(MESH *mp);
extern void     printmeshstats(MESH *ms, FILE *fp);
extern void     freemesh(MESH *ms);
extern void     freemeshinst(OBJREC *o);
extern void     readmesh(MESH *mp, char *path, int flags);
extern void     writemesh(MESH *mp, FILE *fp);

#endif /* NOPROTO */
Revision:	2.4
Committed:	Tue May 13 17:58:32 2003 UTC (20 years, 11 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.3:	+1 -1 lines
Log Message:	Changed (char ) casts for memory copies to (void ) and other fixes
#	User	Rev	Content
1	greg	2.1	/* RCSid $Id$ */
2			/*
3			* Header for compact triangle mesh geometry
4			*
5			* Include after standard.h, object.h and octree.h
6			*/
7
8			#include "copyright.h"
9
10	greg	2.3	#include "lookup.h"
11
12	greg	2.1	#ifndef uint4
13			#define uint4 unsigned int4
14			#endif
15			#ifndef BYTE
16			#define BYTE unsigned char
17			#endif
18
19			/*
20			* Vertex space is minimized without compromising accuracy by using a
21			* 4-byte unsigned int to indicate position in the enclosing octree cube.
22			* The same trick is used for any local (u,v) coordinates, whose limits
23			* are recorded separately in the parent MESH structure. The uvlimit's
24			* in the MESH structure are set such that (0,0) is out of range, so
25			* we use this to indicate an unspecified local coordinate.
26			* A vertex normal, if specified, is stored in a single 4-byte
27			* integer using the codec in dircode.c. The encodedir() function
28			* never generates 0, so we can use this for unspecified normals.
29			*
30			* Vertex ID's are encoded using the bottom 8 bits of a 4-byte integer
31	greg	2.2	* to index a vertex in a patch indicated by the 22 bits above (8-29).
32			* For triangle ID's, the top 22 bits (10-31) indicate the patch, and
33			* the bit 9 (0x200) indicates whether the triangle joins patches.
34	greg	2.1	* If not, then the bottom 9 bits index into the local PTri array.
35	greg	2.2	* If it's a joiner, then the 8th bit indicates whether the triangle joins
36	greg	2.1	* two patches, in which case the bottom 8 bits index the PJoin2 array.
37			* Otherwise, the bottom 8 bits index the PJoin1 array.
38			*
39			* These shenanigans minimize vertex reference memory requirements
40			* in compiled mesh structures, where the octree leaves contain sets
41			* of triangle ID's rather than the more usual objects. It seems like
42			* a lot of effort, but it can reduce mesh storage by a factor of 3
43			* or more. This is important, as the whole point is to model very
44			* complicated geometry with this structure, and memory is the main
45	greg	2.3	* limitation.
46	greg	2.1	*/
47
48			/* A triangle mesh patch */
49			typedef struct {
50			uint4 (xyz)[3]; / up to 256 patch vertices */
51			int4 norm; / vertex normals */
52			uint4 (uv)[2]; / vertex local coordinates */
53			struct PTri {
54			BYTE v1, v2, v3; /* local vertices */
55			} tri; / local triangles */
56	greg	2.3	short solemat; /* sole material */
57			int2 trimat; / or local material indices */
58	greg	2.1	struct PJoin1 {
59			int4 v1j; /* non-local vertex */
60	greg	2.3	int2 mat; /* material index */
61	greg	2.1	BYTE v2, v3; /* local vertices */
62			} j1tri; / joiner triangles */
63			struct PJoin2 {
64			int4 v1j, v2j; /* non-local vertices */
65	greg	2.3	int2 mat; /* material index */
66	greg	2.1	BYTE v3; /* local vertex */
67			} j2tri; / double joiner triangles */
68			short nverts; /* vertex count */
69			short ntris; /* triangle count */
70			short nj1tris; /* joiner triangle count */
71			short nj2tris; /* double joiner triangle count */
72			} MESHPATCH;
73
74			/* A loaded mesh */
75			typedef struct mesh {
76			char name; / mesh file name */
77			int nref; /* reference count */
78			int ldflags; /* what we've loaded */
79			CUBE mcube; /* bounds and octree */
80			FLOAT uvlim[2][2]; /* local coordinate extrema */
81	greg	2.3	OBJECT mat0; /* base material index */
82			OBJECT nmats; /* number of materials */
83	greg	2.1	MESHPATCH patch; / mesh patch list */
84			int npatches; /* number of mesh patches */
85	greg	2.3	OBJREC pseudo; / mesh pseudo objects */
86			LUTAB lut; /* vertex lookup table */
87	greg	2.1	struct mesh next; / next mesh in list */
88			} MESH;
89
90			/* A mesh instance */
91			typedef struct {
92			FULLXF x; /* forward and backward transforms */
93			MESH msh; / mesh object reference */
94			} MESHINST;
95
96			/* vertex flags */
97			#define MT_V 01
98			#define MT_N 02
99			#define MT_UV 04
100			#define MT_ALL 07
101
102			/* A mesh vertex */
103			typedef struct {
104			int fl; /* setting flags */
105			FVECT v; /* vertex location */
106			FVECT n; /* vertex normal */
107			FLOAT uv[2]; /* local coordinates */
108			} MESHVERT;
109
110			/* mesh format identifier */
111			#define MESHFMT "Radiance_tmesh"
112			/* magic number for mesh files */
113	greg	2.3	#define MESHMAGIC ( 1 MAXOBJSIZ+311) / increment first value */
114	greg	2.1
115			#ifdef NOPROTO
116
117			extern MESH *getmesh();
118	greg	2.4	extern MESHINST *getmeshinst();
119	greg	2.1	extern int getmeshtrivid();
120			extern int getmeshvert();
121			extern int getmeshtri();
122	greg	2.3	extern OBJREC *getmeshpseudo();
123	greg	2.1	extern int4 addmeshvert();
124			extern OBJECT addmeshtri();
125	greg	2.3	extern char *checkmesh();
126	greg	2.1	extern void printmeshstats();
127			extern void freemesh();
128			extern void freemeshinst();
129			extern void readmesh();
130			extern void writemesh();
131
132			#else
133
134			extern MESH getmesh(char mname, int flags);
135			extern MESHINST getmeshinst(OBJREC o, int flags);
136	greg	2.3	extern int getmeshtrivid(int4 tvid[3], OBJECT *mo,
137			MESH *mp, OBJECT ti);
138	greg	2.1	extern int getmeshvert(MESHVERT vp, MESH mp, int4 vid, int what);
139	greg	2.3	extern int getmeshtri(MESHVERT tv[3], OBJECT *mo,
140			MESH *mp, OBJECT ti, int what);
141			extern OBJREC getmeshpseudo(MESH mp, OBJECT mo);
142	greg	2.1	extern int4 addmeshvert(MESH mp, MESHVERT vp);
143	greg	2.3	extern OBJECT addmeshtri(MESH *mp, MESHVERT tv[3], OBJECT mo);
144			extern char checkmesh(MESH mp);
145	greg	2.1	extern void printmeshstats(MESH ms, FILE fp);
146			extern void freemesh(MESH *ms);
147			extern void freemeshinst(OBJREC *o);
148			extern void readmesh(MESH mp, char path, int flags);
149			extern void writemesh(MESH mp, FILE fp);
150
151			#endif /* NOPROTO */