/*
   render/gl.h
   This file is part of the Osirion project and is distributed under
   the terms of the GNU General Public License version 2
*/

#ifndef __INCLUDED_RENDER_GL_H__
#define __INCLUDED_RENDER_GL_H__

#include "sys/sys.h"

#include "SDL2/SDL_opengl.h"

#include "math/vector2f.h"
#include "math/vector3f.h"
#include "math/matrix4f.h"
#include "math/axis.h"
#include "math/color.h"

#ifdef _WIN32

#ifndef GL_RESCALE_NORMAL
#define GL_RESCALE_NORMAL	0x803A
#endif

#ifndef GL_TEXTURE_MAX_LEVEL
#define GL_TEXTURE_MAX_LEVEL	0x813D
#endif

#ifndef GL_GENERATE_MIPMAP
#define GL_GENERATE_MIPMAP	0x8191
#endif

#ifndef GL_REFLECTION_MAP
#define GL_REFLECTION_MAP	0x8512
#endif

#ifndef GL_CLAMP_TO_EDGE
#define GL_CLAMP_TO_EDGE	0x812F
#endif

#ifndef GL_ARRAY_BUFFER
#define GL_ARRAY_BUFFER 	0x8892
#endif

#ifndef GL_STATIC_DRAW
#define GL_STATIC_DRAW		0x88E4
#endif

#endif // _WIN32

/*
 * @brief wrapper class for OpenGL functions
 * The gl class accesses the OpenGL library functions
 * through function pointers.
 * This allows loading the library at runtime 
 * and makes static builds possible
 */
/*
class GL {

private:
	typedef void (* APIENTRY gl_genbuffers_func)(GLuint count, GLuint *id);
	typedef void (* APIENTRY gl_deletebuffers_func)(GLuint count, GLuint *id);
	typedef void (* APIENTRY gl_bindbuffer_func)(GLenum target, GLuint id);
	typedef void (* APIENTRY gl_bufferdata_func)(GLenum target, GLsizei size, const GLvoid *data, GLenum usage);

}
*/
/// wrapper namespace for OpenGL operations
/** The gl namespace provides a wrapper to the OpenGL library functions.
 *  All methods take floats or Vector3f and Color as parameters.
 */
namespace gl
{
/// name of the hardware OpenGL renderer
std::string renderer();
/// vender of the system OpenGL implementation
std::string vendor();
/// version of the system OpenGL implementation
std::string version();
/// Opengl Extensions string
std::string extensions();

/// enum to denote Vertex drawing modes
enum Primitive {
	Points = GL_POINTS,
	Lines = GL_LINES,
	LineStrip = GL_LINE_STRIP,
	LineLoop = GL_LINE_LOOP,
	Triangles = GL_TRIANGLES,
	TriangleStrip = GL_TRIANGLE_STRIP,
	TriangleFan = GL_TRIANGLE_FAN,
	Quads = GL_QUADS,
	QuadStrip = GL_QUAD_STRIP,
	Polygon = GL_POLYGON
};

/// glViewPort
void viewport(GLint x, GLint y, GLsizei width, GLsizei height);

/// set the color used to clear to buffer
void clearcolor(math::Color const &color);

void clearcolor(const float r, const float g, const float b, const float a);

/// clear buffers to preset values
void clear(GLbitfield mask);

/// glMatrixMode
void matrixmode(GLenum mode);

/// glEnable
void enable(GLenum cap);

/// glDisable
void disable(GLenum cap);

/// glEnableClientState
void enableclientstate(GLenum cap);

/// glDisableClientState
void disableclientstate(GLenum cap);

/// glGetIntegerv
void getinteger(GLenum pname, GLint* params);

/// glShadeModel
void shademodel(GLenum mode);

/// glCullFace
void cullface(GLenum mode);

/// glFrontFace
void frontface(GLenum mode);

/// glDepthMask
void depthmask(GLenum mode);

/// glDepthFunc
void depthfunc(GLenum func);

/// glBlendFunc
void blendfunc(GLenum sfactor, GLenum dfactor);

/// glAlphaFunc
void alphafunc(GLenum func, GLclampf ref);

/// glPolygonOffset
void polygonoffset(GLfloat factor, GLfloat units);

/// Delimite the start of a sequence of verteces describing a primitive or group of primitives
/** @param primitive The type of drawing primitive
 *  @see end()
 */
void begin(Primitive primitive);

/// delimit the end of a sequence of verteces describing a primitive or group of primitives
/** @see begin()
 */
void end();

/// Add the next vertex the the current drawing operation
/** From the glVertex() description:
 *  vertex() commands are used within begin()/end() pairs to specify point,
 *  line, and polygon vertices.  The current color, normal, and texture
 *  coordinates are associated with the vertex when vertex() is called.
 */
void vertex(const math::Vector2f& vector);
void vertex(const float x, const float y);
void vertex(const math::Vector3f& vector);
void vertex(const float x, const float y, const float z);
void vertex(const GLfloat* v);

/// glTexCoord
void texcoord(const float x, const float y);

/// glTexCoord
void texcoord(const math::Vector2f& vector);

/// glTexCoord
void texcoord(const float x, const float y, const float z);

/// glTexCoordPointer
void texcoordpointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);

/// glNormalPointer
void normalpointer(GLenum type, GLsizei stride, const GLvoid* pointer);

/// glVertexPointer
void vertexpointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer);

/// glInterleavedArrays
void interleavedarrays(GLenum format, GLsizei stride, const GLvoid* pointer);

/// glNormal
void normal(const math::Vector3f & vector);

void normal(const float x, const float y, const float z);

/// multiply the current matrix by a general rotation matrix
/** @param angle The angle of the rotation, in degrees [0-360]
 *  @param vector The rotation axes, relative to the origin (0,0,0)
 */
void rotate(const float angle, const math::Vector3f& vector);

/// multiply the current matrix by a general rotation matrix
/** @param angle The angle of the rotation, in degrees
 *  @param x The x-coordinate of the rotation vector
 *  @param y The y-coordinate of the rotation vector
 *  @param z The z-coordinate of the rotation vector
 */
void rotate(const float angle, const float x, const float y, const float z);

/// multiply the current matrix by a general translation matrix
/** @param vector The translation vector, relative to the origin (0,0,0)
 */
void translate(const math::Vector3f& vector);

/// multiply the current matrix by a general translation matrix
/** @param x The x-coordinate of the translation vector
 *  @param y The y-coordinate of the translation vector
 *  @param z The z-coordinate of the translation vector
 */
void translate(const float x, const float y, const float z);

/// multiply the current matrix by a general scaling matrix
/** @param vector The scale factor for all 3 axes
 */
void scale(const math::Vector3f& vector);

/// multiply the current matrix by a general scaling matrix
/** @param x x-scaling factor
 * @param y y-scaling factor
 * @param z z-scaling factor
 */
void scale(const float x, const float y, const float z);

/// multiply the current matrix with a coordinate system transformation
void multmatrix(const math::Axis & axis);

/// multiply the current matrix with a 4x4 float matrix
void multmatrix(const math::Matrix4f & matrix);

/// specify the drawing color for the next GL functions
/** @param color the new drawing color
 */
void color(math::Color const & color);

/** @param r red value of the new drawing color
 *  @param g green value of the new drawing color
 *  @param b blue value of the new drawing color
 *  @param a alpha value of the new drawing color
 */
void color(const float r, const float g, const float b, const float a = 1.0f);

/// specify the specular reflectivity color
void specular(math::Color const & specular);

/// specify the shininess
void shininess(math::Color const & shine);

/// Push the current transformation matrix to the stack
void push();

/// Replace the transformation matrix with the top from the stack
void pop();

/// Replace the transformation matrix with the identity matrtix
void loadidentity();

/// Perspective matrix
void frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble znear, GLdouble zfar);

/// Light source parameters
void light(GLenum light, GLenum pname, GLfloat param);
void light(GLenum light, GLenum pname, GLint param);
void light(GLenum light, GLenum pname, const GLfloat* params);
void light(GLenum light, GLenum pname, const GLint* params);

/// Light model
void lightmodel(GLenum pname, GLfloat param);
void lightmodel(GLenum pname, GLint param);
void lightmodel(GLenum pname, const GLfloat* param);
void lightmodel(GLenum pname, const GLint* param);

/// Polygon mode
void polygonmode(GLenum face, GLenum mode);

/// Color material parameters
void colormaterial(GLenum face, GLenum mode);

/// Material parameters
void material(GLenum face, GLenum pname, GLfloat param);
void material(GLenum face, GLenum pname, GLint param);
void material(GLenum face, GLenum pname, const GLfloat* param);
void material(GLenum face, GLenum pname, const GLint* param);

/// Texture environment parameters
void texenv(GLenum target, GLenum pname, GLfloat param);
void texenv(GLenum target, GLenum pname, GLint param);
void texenv(GLenum target, GLenum pname, const GLfloat* param);
void texenv(GLenum target, GLenum pname, const GLint* param);

/// Texture coordinate generation
void texgen(GLenum coord, GLenum param, GLint value);
void texgen(GLenum coord, GLenum param, GLfloat value);
void texgen(GLenum coord, GLenum param, GLdouble value);
void texgen(GLenum coord, GLenum param, const GLint* value);
void texgen(GLenum coord, GLenum param, const GLfloat* value);
void texgen(GLenum coord, GLenum param, const GLdouble* value);

/// Texture parameters
void texparameter(GLenum target, GLenum pname, GLfloat param);
void texparameter(GLenum target, GLenum pname, GLint param);
void texparameter(GLenum target, GLenum pname, const GLfloat* params);
void texparameter(GLenum target, GLenum pname, const GLint* params);

typedef void (* APIENTRY genbuffers_func)(GLuint count, GLuint *id);
typedef void (* APIENTRY deletebuffers_func)(GLuint count, GLuint *id);
typedef void (* APIENTRY bindbuffer_func)(GLenum target, GLuint id);
typedef void (* APIENTRY bufferdata_func)(GLenum target, GLsizei size, const GLvoid *data, GLenum usage);
typedef void (*APIENTRY activetexture_func)(GLenum texture);
typedef void (*APIENTRY clientactivetexture_func)(GLenum texture);

extern genbuffers_func genbuffers;
extern deletebuffers_func deletebuffers;
extern bindbuffer_func bindbuffer;
extern bufferdata_func bufferdata;
extern activetexture_func activetexture;
extern clientactivetexture_func clientactivetexture;

}

#endif // __INCLUDED_RENDER_GL_H__