#ifndef GLM_H
#define GLM_H

//added by c3r14l to accept the devil :D
#define HAVE_DEVIL
//#define DEBUG
/*    
glm.h
Nate Robins, 1997, 2000
nate@pobox.com, http://www.pobox.com/~nate

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.

*/


/*
#include <GL/gl.h>
#include <GL/glu.h>
*/
#include <gl/glut.h>

#define GLM_MAX_SHININESS 100.0 /* for Poser */
#define GLM_MAX_TEXTURE_SIZE 0 /* must be a power of 2 (i.e. 1024).
0 means no limit. */

#ifndef M_PI
#define M_PI 3.14159265f
#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 */
#define GLM_2_SIDED  (1 << 5)       /* render two-sided polygons */

/* 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 */
#if 0
	GLfloat emmissive[4];         /* emmissive component */
#endif
	GLfloat shininess;            /* specular exponent */
	GLuint map_diffuse;     /* diffuse texture ID */
#if 0
	GLuint map_ambient;     /* ambient texture ID */
	GLuint map_specular;     /* specular texture ID */
	GLuint map_bump;     /* specular texture ID */
	GLfloat dissolve;             /* transparency */
	GLuint map_dissolve;     /* alpha texture ID */
	GLuint lighting;                /* 0=disable, 1=ambient+diffuse, 2=full */
#endif
#ifdef AVL
	int height,
		width;
	unsigned char* image;
	char *t_filename;
	GLuint t_id[1];	
#endif
} GLMmaterial;

/* 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 */
#ifdef MATERIAL_BY_FACE
	GLuint material;
#endif
} GLMtriangle;

typedef struct _GLMtexture {
	char *name;
	GLuint id;                    /* OpenGL texture ID */
	GLfloat width;		/* width and height for texture coordinates */
	GLfloat height;
} GLMtexture;


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

#ifndef AVL
	GLuint       numtextures;
	GLMtexture*  textures;
#endif

	GLfloat position[3];          /* position of the model */

} GLMmodel;


#ifdef __cplusplus
extern "C" {
#endif

	/* 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
	* keep_existing - if GL_TRUE, do not overwrite existing normals
	*/
	GLvoid
		glmVertexNormals(GLMmodel* model, GLfloat angle, GLboolean keep_existing);

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

	GLuint
		glmLoadTexture(const char *filename, GLboolean alpha, GLboolean repeat, GLboolean filtering, GLboolean mipmaps, GLfloat *width, GLfloat *height);

#ifdef AVL
	//AVL Prototypes
	//AVL Flip Texture
	GLvoid glmFlipTexture(unsigned char* texture, int width, int height);

	//AVL Flip Model Textures
	GLvoid glmFlipModelTextures(GLMmodel* model);

	//AVL END Prototypes
#endif

#ifdef __cplusplus
}
#endif
#endif
