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

#include "render/gl.h"
#include "math/matrix4f.h"

namespace gl
{

using math::Vector2f;
using math::Vector3f;
using math::Color;

std::string renderer()
{
	return std::string((char *)glGetString(GL_RENDERER));
}

std::string vendor()
{
	return std::string((char *)glGetString(GL_VENDOR));
}

std::string version()
{
	return std::string((char *)glGetString(GL_VERSION));
}

std::string extensions()
{
	return std::string((char *)glGetString(GL_EXTENSIONS));
}

void begin(Primitive primitive)
{
	::glBegin(primitive);
}

void end()
{
	::glEnd();
}

void viewport(GLint x, GLint y, GLsizei width, GLsizei height)
{
	::glViewport(x, y, width, height);
}

void depthmask(GLenum mode)
{
	::glDepthMask(mode);
}


void frontface(GLenum mode)
{
	glFrontFace(mode);
}

void cullface(GLenum mode)
{
	glCullFace(mode);
}

void shademodel(GLenum mode)
{
	glShadeModel(mode);
}

void blendfunc(GLenum sfactor, GLenum dfactor)
{
	glBlendFunc(sfactor, dfactor);
}

void enable(GLenum cap)
{
	glEnable(cap);
}

void disable(GLenum cap)
{
	glDisable(cap);
}

void clear(GLbitfield mask)
{
	glClear(mask);
}

void clearcolor(Color const & color)
{
	glClearColor(color.red(), color.green(), color.blue(), color.alpha());
}

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

void rotate(const float angle, const Vector3f& vector)
{
	glRotatef(angle, vector[0], vector[1], vector[2]);
}

void rotate(const float angle, const float x, const float y, const float z)
{
	glRotatef(angle, x, y, z);
}

void translate(const Vector3f& vector)
{
	glTranslatef(vector[0], vector[1], vector[2]);
}

void translate(const float x, const float y, const float z)
{
	glTranslatef(x, y, z);
}
void scale(const Vector3f& vector)
{
	glScalef(vector[0], vector[1], vector[2]);
}

void scale(const float x, const float y, const float z)
{
	glScalef(x, y, z);
}

void vertex(const Vector2f& vector)
{
	glVertex2fv(vector.ptr());
}

void vertex(const float x, const float y)
{
	glVertex2f(x, y);
}

void vertex(const Vector3f& vector)
{
	glVertex3fv(vector.ptr());
}

void vertex(const float x, const float y, const float z)
{
	glVertex3f(x, y, z);
}

void normal(const Vector3f & vector)
{
	glNormal3fv(vector.ptr());
}

void normal(const float x, const float y, const float z)
{
	glNormal3f(x, y, z);
}

void push()
{
	glPushMatrix();
}

void pop()
{
	glPopMatrix();
}

void multmatrix(const math::Matrix4f & matrix)
{
	glMultMatrixf(matrix.ptr());
}

void multmatrix(const math::Axis & axis)
{
	math::Matrix4f matrix(axis);
	glMultMatrixf(matrix.ptr());
}

void color(const float r, const float g, const float b, const float a)
{
	glColor4f(r, g, b, a);
}
void color(Color const & color)
{
	glColor4fv(color.ptr());
}

void matrixmode(GLenum mode)
{
	glMatrixMode(mode);
}

void loadidentity()
{
	glLoadIdentity();
}

void frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble znear, GLdouble zfar)
{
	glFrustum(left, right, bottom, top, znear, zfar);
}

} // namespace gl