diff plugins/crazychat/glm.h @ 11218:ed017b9c532d

[gaim-migrate @ 13350] crazychat commit, first one. committer: Tailor Script <[e-mail]>

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/plugins/crazychat/glm.h	Tue Aug 09 07:10:23 2005 +0000
@@ -0,0 +1,277 @@
+#ifndef __GLM__H__
+#define __GLM__H__
+
+/*    
+      glm.h
+      Nate Robins, 1997
+      [e-mail], http://www.pobox.com/~ndr/
+ 
+      Wavefront OBJ model file format reader/writer/manipulator.
+
+      Includes routines for generating smooth normals with
+      preservation of edges, welding redundant vertices & texture
+      coordinate generation (spheremap and planar projections) + more.
+
+ */
+
+
+#if defined(WIN32)
+#include "glut.h"
+#else
+//#include <GL/glut.h>
+#endif
+
+#include<GL/glu.h>
+
+#ifndef M_PI
+#define M_PI 3.14159265
+#endif
+
+#define GLM_NONE     (0)		/* render with only vertices */
+#define GLM_FLAT     (1 << 0)		/* render with facet normals */
+#define GLM_SMOOTH   (1 << 1)		/* render with vertex normals */
+#define GLM_TEXTURE  (1 << 2)		/* render with texture coords */
+#define GLM_COLOR    (1 << 3)		/* render with colors */
+#define GLM_MATERIAL (1 << 4)		/* render with materials */
+
+
+/* GLMmaterial: Structure that defines a material in a model. 
+ */
+typedef struct _GLMmaterial
+{
+  char* name;				/* name of material */
+  GLfloat diffuse[4];			/* diffuse component */
+  GLfloat ambient[4];			/* ambient component */
+  GLfloat specular[4];			/* specular component */
+  GLfloat emmissive[4];			/* emmissive component */
+  GLfloat shininess;			/* specular exponent */
+} GLMmaterial;
+
+typedef struct _GLMmat_str{
+  GLint num_materials;
+  GLMmaterial* materials;
+} GLMmat_str;
+
+
+/* GLMtriangle: Structure that defines a triangle in a model.
+ */
+typedef struct _GLMtriangle {
+  GLuint vindices[3];			/* array of triangle vertex indices */
+  GLuint nindices[3];			/* array of triangle normal indices */
+  GLuint tindices[3];			/* array of triangle texcoord indices*/
+  GLuint findex;			/* index of triangle facet normal */
+} GLMtriangle;
+
+/* GLMgroup: Structure that defines a group in a model.
+ */
+typedef struct _GLMgroup {
+  char*             name;		/* name of this group */
+  GLuint            numtriangles;	/* number of triangles in this group */
+  GLuint*           triangles;		/* array of triangle indices */
+  GLuint            material;           /* index to material for group */
+  struct _GLMgroup* next;		/* pointer to next group in model */
+} GLMgroup;
+
+/* GLMmodel: Structure that defines a model.
+ */
+typedef struct _GLMmodel {
+  char*    pathname;			/* path to this model */
+  char*    mtllibname;			/* name of the material library */
+
+  GLuint   numvertices;			/* number of vertices in model */
+  GLfloat* vertices;			/* array of vertices  */
+
+  GLuint   numnormals;			/* number of normals in model */
+  GLfloat* normals;			/* array of normals */
+
+  GLuint   numtexcoords;		/* number of texcoords in model */
+  GLfloat* texcoords;			/* array of texture coordinates */
+
+  GLuint   numfacetnorms;		/* number of facetnorms in model */
+  GLfloat* facetnorms;			/* array of facetnorms */
+
+  GLuint       numtriangles;		/* number of triangles in model */
+  GLMtriangle* triangles;		/* array of triangles */
+
+  GLuint       nummaterials;		/* number of materials in model */
+  GLMmaterial* materials;		/* array of materials */
+
+  GLuint       numgroups;		/* number of groups in model */
+  GLMgroup*    groups;			/* linked list of groups */
+
+  GLfloat position[3];			/* position of the model */
+
+} GLMmodel;
+
+#  ifdef __cplusplus
+extern "C" {
+#  endif /* __cplusplus */
+
+/* glmUnitize: "unitize" a model by translating it to the origin and
+ * scaling it to fit in a unit cube around the origin.  Returns the
+ * scalefactor used.
+ *
+ * model - properly initialized GLMmodel structure 
+ */
+GLfloat
+glmUnitize(GLMmodel* model);
+
+/* glmDimensions: Calculates the dimensions (width, height, depth) of
+ * a model.
+ *
+ * model      - initialized GLMmodel structure
+ * dimensions - array of 3 GLfloats (GLfloat dimensions[3])
+ */
+GLvoid
+glmDimensions(GLMmodel* model, GLfloat* dimensions);
+
+/* glmScale: Scales a model by a given amount.
+ * 
+ * model - properly initialized GLMmodel structure
+ * scale - scalefactor (0.5 = half as large, 2.0 = twice as large)
+ */
+GLvoid
+glmScale(GLMmodel* model, GLfloat scale);
+
+/* glmReverseWinding: Reverse the polygon winding for all polygons in
+ * this model.  Default winding is counter-clockwise.  Also changes
+ * the direction of the normals.
+ * 
+ * model - properly initialized GLMmodel structure 
+ */
+GLvoid
+glmReverseWinding(GLMmodel* model);
+
+/* glmFacetNormals: Generates facet normals for a model (by taking the
+ * cross product of the two vectors derived from the sides of each
+ * triangle).  Assumes a counter-clockwise winding.
+ *
+ * model - initialized GLMmodel structure
+ */
+GLvoid
+glmFacetNormals(GLMmodel* model);
+
+/* glmVertexNormals: Generates smooth vertex normals for a model.
+ * First builds a list of all the triangles each vertex is in.  Then
+ * loops through each vertex in the the list averaging all the facet
+ * normals of the triangles each vertex is in.  Finally, sets the
+ * normal index in the triangle for the vertex to the generated smooth
+ * normal.  If the dot product of a facet normal and the facet normal
+ * associated with the first triangle in the list of triangles the
+ * current vertex is in is greater than the cosine of the angle
+ * parameter to the function, that facet normal is not added into the
+ * average normal calculation and the corresponding vertex is given
+ * the facet normal.  This tends to preserve hard edges.  The angle to
+ * use depends on the model, but 90 degrees is usually a good start.
+ *
+ * model - initialized GLMmodel structure
+ * angle - maximum angle (in degrees) to smooth across
+ */
+GLvoid
+glmVertexNormals(GLMmodel* model, GLfloat angle);
+
+/* glmLinearTexture: Generates texture coordinates according to a
+ * linear projection of the texture map.  It generates these by
+ * linearly mapping the vertices onto a square.
+ *
+ * model - pointer to initialized GLMmodel structure
+ */
+GLvoid
+glmLinearTexture(GLMmodel* model);
+
+/* glmSpheremapTexture: Generates texture coordinates according to a
+ * spherical projection of the texture map.  Sometimes referred to as
+ * spheremap, or reflection map texture coordinates.  It generates
+ * these by using the normal to calculate where that vertex would map
+ * onto a sphere.  Since it is impossible to map something flat
+ * perfectly onto something spherical, there is distortion at the
+ * poles.  This particular implementation causes the poles along the X
+ * axis to be distorted.
+ *
+ * model - pointer to initialized GLMmodel structure
+ */
+GLvoid
+glmSpheremapTexture(GLMmodel* model);
+
+/* glmDelete: Deletes a GLMmodel structure.
+ *
+ * model - initialized GLMmodel structure
+ */
+GLvoid
+glmDelete(GLMmodel* model);
+
+/* glmReadOBJ: Reads a model description from a Wavefront .OBJ file.
+ * Returns a pointer to the created object which should be free'd with
+ * glmDelete().
+ *
+ * filename - name of the file containing the Wavefront .OBJ format data.  
+ */
+GLMmodel* 
+glmReadOBJ(char* filename);
+
+/* glmWriteOBJ: Writes a model description in Wavefront .OBJ format to
+ * a file.
+ *
+ * model    - initialized GLMmodel structure
+ * filename - name of the file to write the Wavefront .OBJ format data to
+ * mode     - a bitwise or of values describing what is written to the file
+ *            GLM_NONE    -  write only vertices
+ *            GLM_FLAT    -  write facet normals
+ *            GLM_SMOOTH  -  write vertex normals
+ *            GLM_TEXTURE -  write texture coords
+ *            GLM_FLAT and GLM_SMOOTH should not both be specified.
+ */
+GLvoid
+glmWriteOBJ(GLMmodel* model, char* filename, GLuint mode);
+
+/* glmDraw: Renders the model to the current OpenGL context using the
+ * mode specified.
+ *
+ * model    - initialized GLMmodel structure
+ * mode     - a bitwise OR of values describing what is to be rendered.
+ *            GLM_NONE    -  render with only vertices
+ *            GLM_FLAT    -  render with facet normals
+ *            GLM_SMOOTH  -  render with vertex normals
+ *            GLM_TEXTURE -  render with texture coords
+ *            GLM_FLAT and GLM_SMOOTH should not both be specified.
+ */
+GLvoid
+glmDraw(GLMmodel* model, GLuint mode);
+
+/* glmList: Generates and returns a display list for the model using
+ * the mode specified.
+ *
+ * model    - initialized GLMmodel structure
+ * mode     - a bitwise OR of values describing what is to be rendered.
+ *            GLM_NONE    -  render with only vertices
+ *            GLM_FLAT    -  render with facet normals
+ *            GLM_SMOOTH  -  render with vertex normals
+ *            GLM_TEXTURE -  render with texture coords
+ *            GLM_FLAT and GLM_SMOOTH should not both be specified.  
+ */
+GLuint
+glmList(GLMmodel* model, GLuint mode);
+
+/* glmWeld: eliminate (weld) vectors that are within an epsilon of
+ * each other.
+ *
+ * model      - initialized GLMmodel structure
+ * epsilon    - maximum difference between vertices
+ *              ( 0.00001 is a good start for a unitized model)
+ *
+ */
+GLvoid
+glmWeld(GLMmodel* model, GLfloat epsilon);
+
+GLMmat_str* 
+glmMTL(char* name);
+
+void 
+glmSetMat(GLMmat_str* mats, GLint index);
+
+#  ifdef __cplusplus
+}
+#  endif /* __cplusplus */
+
+
+#endif