/*]  Copyright (c) 2009-2010, Charles McGarvey  [**************************
**]  All rights reserved.
*
* vi:ts=4 sw=4 tw=75
*
* Distributable under the terms and conditions of the 2-clause BSD license;
* see the file COPYING for a complete text of the license.
*
**************************************************************************/

#ifndef _MOOF_OPENGL_HH_
#define _MOOF_OPENGL_HH_

/**
 * \file opengl.hh
 * Defines macros for OpenGL functions that operate on scalars, vectors,
 * and matrices.
 */

#include "config.h"

#include <vector>

#include <SDL/SDL_opengl.h>

#include <moof/math.hh>


// generic function arguments

#define ARGS_P		const GLscalar* p
#define PASS_P		p

#define ARGS_M		const moof::matrix4& m
#define PASS_M		m.data()

// ordinal function arguments

#define ARGS_S2		GLscalar a, GLscalar b
#define PASS_S2		a, b
#define ARGS_S3		GLscalar a, GLscalar b, GLscalar c
#define PASS_S3		a, b, c
#define ARGS_S4		GLscalar a, GLscalar b, GLscalar c, GLscalar d
#define PASS_S4		a, b, c, d

#define ARGS_P2		const moof::vector2& p
#define PASS_P2		p.data()
#define ARGS_P3		const moof::vector3& p
#define PASS_P3		p.data()
#define ARGS_P4		const moof::vector4& p
#define PASS_P4		p.data()

#define ARGS_V2		const moof::vector2& v
#define PASS_V2		v[0], v[1]
#define ARGS_V3		const moof::vector3& v
#define PASS_V3		v[0], v[1], v[2]
#define ARGS_V4		const moof::vector4& v
#define PASS_V4		v[0], v[1], v[2], v[3]


#if ENABLE_DOUBLE_PRECISION

#define OPENGL_GENERIC_FUNC(R, N, L)									\
	inline R gl##N(ARGS_##L) { gl##N##d(PASS_##L); }//

#define OPENGL_ORDINAL_FUNC(R, N, K)									\
	inline R gl##N(ARGS_##S##K) { gl##N##K##d(PASS_##S##K); }			\
	inline R gl##N(ARGS_##P##K) { gl##N##K##d##v(PASS_##P##K); }//

#else

#define OPENGL_GENERIC_FUNC(R, N, L)									\
	inline R gl##N(ARGS_##L) { gl##N##f(PASS_##L); }//

#define OPENGL_ORDINAL_FUNC(R, N, K)									\
	inline R gl##N(ARGS_##S##K) { gl##N##K##f(PASS_##S##K); }			\
	inline R gl##N(ARGS_##P##K) { gl##N##K##f##v(PASS_##P##K); }//

#endif


OPENGL_GENERIC_FUNC(void,	LoadMatrix,	P);
OPENGL_GENERIC_FUNC(void,	LoadMatrix,	M);
OPENGL_GENERIC_FUNC(void,	MultMatrix, P);
OPENGL_GENERIC_FUNC(void,	MultMatrix, M);

OPENGL_GENERIC_FUNC(void,	Scale,		S3);
OPENGL_GENERIC_FUNC(void,	Scale,		V3);
OPENGL_GENERIC_FUNC(void,	Rotate,		S4);
OPENGL_GENERIC_FUNC(void,	Rotate,		V4);
OPENGL_GENERIC_FUNC(void,	Translate,	S3);
OPENGL_GENERIC_FUNC(void,	Translate,	V3);

OPENGL_ORDINAL_FUNC(void,	Color,		3);
OPENGL_ORDINAL_FUNC(void,	Color,		4);

OPENGL_ORDINAL_FUNC(void,	Vertex,		2);
OPENGL_ORDINAL_FUNC(void,	Vertex,		3);
OPENGL_ORDINAL_FUNC(void,	Vertex,		4);

OPENGL_ORDINAL_FUNC(void,	TexCoord,	2);
OPENGL_ORDINAL_FUNC(void,	TexCoord,	3);
OPENGL_ORDINAL_FUNC(void,	TexCoord,	4);

OPENGL_GENERIC_FUNC(void,	Rect,		S4);
OPENGL_GENERIC_FUNC(void,	Rect,		V4);


inline void glMaterial(GLenum face, GLenum pname, moof::scalar s)
{
	glMaterialf(face, pname, float(s));
}

inline void glMaterial(GLenum face, GLenum pname, const moof::vector4& v)
{
#if ENABLE_DOUBLE_PRECISION
	float f[] = {v[0], v[1], v[2], v[3]};
	glMaterialfv(face, pname, f);
#else
	glMaterialfv(face, pname, v.data());
#endif
}

inline void glVertexPointer(const std::vector<moof::vector3>& v)
{
	glVertexPointer(3, GL_SCALAR, 0, v[0].data());
}
inline void glTexCoordPointer(const std::vector<moof::vector2>& v)
{
	glTexCoordPointer(2, GL_SCALAR, 0, v[0].data());
}

inline void glDrawElements(GLenum type, const std::vector<GLuint>& v)
{
	glDrawElements(type, v.size(), GL_UNSIGNED_INT, &v[0]);
}


#if ENABLE_DOUBLE_PRECISION
inline void glGetScalar(GLenum a, GLscalar* b) { glGetDoublev(a, b); }
#else
inline void glGetScalar(GLenum a, GLscalar* b) { glGetFloatv(a, b); }
#endif


#endif // _MOOF_OPENGL_HH_