path: root/src/render/gl.cc

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

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

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 depthfunc(GLenum func)
{
	::glDepthFunc(func);
}

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 alphafunc(GLenum func, GLclampf ref)
{
	::glAlphaFunc(func, ref);
}

void polygonoffset(GLfloat factor, GLfloat units)
{
	::glPolygonOffset(factor, units);
}

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

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

void enableclientstate(GLenum cap)
{
	glEnableClientState(cap);
}

void disableclientstate(GLenum cap)
{
	glDisableClientState(cap);
}

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

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 vertex(const GLfloat* v)
{
	glVertex3fv(v);
}

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

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

void texcoord(const float x, const float y)
{
	glTexCoord2f(x, y);
}

void texcoord(const math::Vector2f& vector)
{
	glTexCoord2fv(vector.ptr());
}

void texcoord(const float x, const float y, const float z)
{
	glTexCoord3f(x, y, z);
}

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

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

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

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

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 specular(Color const & specular)
{
	glMaterialfv(GL_FRONT, GL_SPECULAR, specular.ptr());
}

void shininess(Color const & shine)
{
	glMaterialfv(GL_FRONT, GL_SHININESS, shine.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);
}

void light(GLenum light, GLenum pname, GLfloat param)
{
	glLightf(light, pname, param);
}

void light(GLenum light, GLenum pname, GLint param)
{
	glLighti(light, pname, param);
}

void light(GLenum light, GLenum pname, const GLfloat* params)
{
	glLightfv(light, pname, params);
}

void light(GLenum light, GLenum pname, const GLint* params)
{
	glLightiv(light, pname, params);
}

void lightmodel(GLenum pname, GLfloat param)
{
	glLightModelf(pname, param);
}

void lightmodel(GLenum pname, GLint param)
{
	glLightModeli(pname, param);
}

void lightmodel(GLenum pname, const GLfloat* param)
{
	glLightModelfv(pname, param);
}

void lightmodel(GLenum pname, const GLint* param)
{
	glLightModeliv(pname, param);
}

void polygonmode(GLenum face, GLenum mode)
{
	glPolygonMode(face, mode);
}

void colormaterial(GLenum face, GLenum mode)
{
	glColorMaterial(face, mode);
}

void material(GLenum face, GLenum pname, GLfloat param)
{
	glMaterialf(face, pname, param);
}

void material(GLenum face, GLenum pname, GLint param)
{
	glMateriali(face, pname, param);
}

void material(GLenum face, GLenum pname, const GLfloat* param)
{
	glMaterialfv(face, pname, param);
}

void material(GLenum face, GLenum pname, const GLint* param)
{
	glMaterialiv(face, pname, param);
}

void texenv(GLenum target, GLenum pname, GLfloat param)
{
	glTexEnvf(target, pname, param);
}

void texenv(GLenum target, GLenum pname, GLint param)
{
	glTexEnvi(target, pname, param);
}

void texenv(GLenum target, GLenum pname, const GLfloat* param)
{
	glTexEnvfv(target, pname, param);
}

void texenv(GLenum target, GLenum pname, const GLint* param)
{
	glTexEnviv(target, pname, param);
}

void texgen(GLenum coord, GLenum param, GLint value)
{
	glTexGeni(coord, param, value);
}

void texgen(GLenum coord, GLenum param, GLfloat value)
{
	glTexGenf(coord, param, value);
}

void texgen(GLenum coord, GLenum param, GLdouble value)
{
	glTexGend(coord, param, value);
}

void texgen(GLenum coord, GLenum param, const GLint* value)
{
	glTexGeniv(coord, param, value);
}

void texgen(GLenum coord, GLenum param, const GLfloat* value)
{
	glTexGenfv(coord, param, value);
}

void texgen(GLenum coord, GLenum param, const GLdouble* value)
{
	glTexGendv(coord, param, value);
}

void texparameter(GLenum target, GLenum pname, GLfloat param)
{
	glTexParameterf(target, pname, param);
}

void texparameter(GLenum target, GLenum pname, GLint param)
{
	glTexParameteri(target, pname, param);
}

void texparameter(GLenum target, GLenum pname, const GLfloat* params)
{
	glTexParameterfv(target, pname, params);
}

void texparameter(GLenum target, GLenum pname, const GLint* params)
{
	glTexParameteriv(target, pname, params);
}

} // namespace gl