glvertex_api.h

Go to the documentation of this file.

// (c) by Stefan Roettger, licensed under MIT license
 
#ifndef GLVERTEX_API_H
#define GLVERTEX_API_H
 
#include "glvertex_core.h"
 
#include <time.h> // for seed
 
static GL LGL; // LGL immediate mode singleton
inline GL *getGL() {return(&LGL);}
 
// legacy OpenGL API (as specified by OpenGL 1.2):
 
inline void lglBegin(lgl_primitive_enum primitive)
   {LGL.lglBegin(primitive);}
 
inline void lglVertex(const vec4 &v)
   {LGL.lglVertex(v);}
 
inline void lglVertex(double x, double y, double z, double w = 1)
   {LGL.lglVertex(x,y,z,w);}
 
inline void lglColor(const vec4f &c)
   {LGL.lglColor(c);}
 
inline void lglColor(float r, float g, float b, float a = 1)
   {LGL.lglColor(r,g,b,a);}
 
inline void lglNormal(const vec3f &n)
   {LGL.lglNormal(n);}
 
inline void lglNormal(float x, float y, float z)
   {LGL.lglNormal(x,y,z);}
 
inline void lglTexCoord(const vec4f &t)
   {LGL.lglTexCoord(t);}
 
inline void lglTexCoord(float s, float t = 0, float r = 0, float w = 1)
   {LGL.lglTexCoord(s,t,r,w);}
 
inline void lglEnd()
   {LGL.lglEnd();}
 
inline void lglMatrixMode(lgl_matrixmode_enum mode = LGL_MODELVIEW)
   {LGL.lglMatrixMode(mode);}
 
inline void lglLoadIdentity()
   {LGL.lglLoadIdentity();}
 
inline void lglLoadMatrix(const mat4 &matrix)
   {LGL.lglLoadMatrix(matrix);}
 
inline void lglMultMatrix(const mat4 &matrix)
   {LGL.lglMultMatrix(matrix);}
 
inline void lglPushMatrix()
   {LGL.lglPushMatrix();}
 
inline void lglPopMatrix()
   {LGL.lglPopMatrix();}
 
inline void lglScale(const vec4 &c)
   {LGL.lglScale(c);}
 
inline void lglScale(double s, double t, double r, double w = 1)
   {LGL.lglScale(s,t,r,w);}
 
inline void lglScale(double s, double w = 1)
   {LGL.lglScale(s,w);}
 
inline void lglTranslate(const vec4 &v)
   {LGL.lglTranslate(v);}
 
inline void lglTranslate(double x, double y, double z, double w = 1)
   {LGL.lglTranslate(x,y,z,w);}
 
inline void lglRotate(double angle, const vec3 &v)
   {LGL.lglRotate(angle, v);}
 
inline void lglRotate(double angle, double vx, double vy, double vz)
   {LGL.lglRotate(angle, vx,vy,vz);}
 
inline void lglOrtho(double left, double right, double bottom, double top, double nearp = -1, double farp = 1)
   {LGL.lglOrtho(left, right, bottom, top, nearp, farp);}
 
inline void lglFrustum(double left, double right, double bottom, double top, double nearp, double farp)
   {LGL.lglFrustum(left, right, bottom, top, nearp, farp);}
 
inline void lglPerspective(double fovy, double aspect, double nearp, double farp)
   {LGL.lglPerspective(fovy, aspect, nearp, farp);}
 
inline void lglLookAt(const vec3 &eye, const vec3 &at, const vec3 &up = vec3(0,1,0))
   {LGL.lglLookAt(eye, at, up);}
 
inline void lglLookAt(double eye_x, double eye_y, double eye_z,
                      double at_x, double at_y, double at_z,
                      double up_x = 0, double up_y = 1, double up_z = 0)
   {LGL.lglLookAt(eye_x,eye_y,eye_z, at_x,at_y,at_z, up_x,up_y,up_z);}
 
inline void lglViewport(int ax, int ay, int bx, int by)
   {LGL.lglViewport(ax, ay, bx, by);}
 
inline void lglClearColor(float w=0, float a=1)
   {LGL.lglClearColor(w,w,w,a);}
 
inline void lglClearColor(float r, float g, float b, float a=1)
   {LGL.lglClearColor(r,g,b,a);}
 
inline void lglClear(GLuint bits = GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
   {LGL.lglClear(bits);}
 
inline void lglClipPlane(vec4 equation = vec4(0,0,0,0), unsigned int n = 0, bool camera_plane = false)
   {LGL.lglClipPlane(equation, n, camera_plane);}
 
inline void lglClipPlane(double a, double b, double c, double d, unsigned int n = 0, bool camera_plane = false)
   {LGL.lglClipPlane(a, b, c, d, n, camera_plane);}
 
inline void lglClipPlane(vec3 point, vec3 normal, unsigned int n = 0, bool camera_plane = false)
   {LGL.lglClipPlane(point, normal, n, camera_plane);}
 
inline void lglFog(float density = 0.0f, vec4f color = vec4f(1))
   {LGL.lglFog(density, color);}
 
inline void lglLineWidth(float width = 1.0f)
   {LGL.lglLineWidth(width);}
 
inline void lglPolygonMode(lgl_polygonmode_enum mode)
   {LGL.lglPolygonMode(mode);}
 
inline std::string lglGetError()
   {return(LGL.lglGetError());}
 
// extended OpenGL API:
 
inline vec4 lglGetColor()
   {return(LGL.lglGetColor());}
 
inline void lglAttribute(const vec4f &a, unsigned int n = 0)
   {LGL.lglAttribute(a,n);}
 
inline void lglAttribute(float x, float y, float z, float w = 1.0f, unsigned int n = 0)
   {LGL.lglAttribute(x,y,z,w, n);}
 
inline lgl_matrixmode_enum lglGetMatrixMode()
   {return(LGL.lglGetMatrixMode());}
 
inline mat4 lglGetMatrix()
   {return(LGL.lglGetMatrix());}
 
inline mat4 lglGetProjectionMatrix()
   {return(LGL.lglGetProjectionMatrix());}
 
inline mat4 lglGetModelViewMatrix()
   {return(LGL.lglGetModelViewMatrix());}
 
inline mat4 lglGetInverseModelViewMatrix()
   {return(LGL.lglGetInverseModelViewMatrix());}
 
inline mat4 lglGetInverseTransposeModelViewMatrix()
   {return(LGL.lglGetInverseTransposeModelViewMatrix());}
 
inline mat4 lglGetModelViewProjectionMatrix()
   {return(LGL.lglGetModelViewProjectionMatrix());}
 
inline mat4 lglGetTextureMatrix()
   {return(LGL.lglGetTextureMatrix());}
 
inline void lglRotateX(double angle)
   {LGL.lglRotateX(angle);}
 
inline void lglRotateY(double angle)
   {LGL.lglRotateY(angle);}
 
inline void lglRotateZ(double angle)
   {LGL.lglRotateZ(angle);}
 
inline void lglParallel(const vec3 &p,const vec3 &n,const vec3 &d)
   {LGL.lglParallel(p, n, d);}
 
inline void lglProjection()
   {LGL.lglProjection();}
 
inline void lglProjection(const mat4 &projection)
   {LGL.lglProjection(projection);}
 
inline void lglProjection(double left, double right, double bottom, double top, double nearp, double farp)
   {LGL.lglProjection(left, right, bottom, top, nearp, farp);}
 
inline void lglProjection(double fovy, double aspect, double nearp, double farp)
   {LGL.lglProjection(fovy, aspect, nearp, farp);}
 
inline double getFovy()
   {return(LGL.getFovy());}
 
inline double getAspect()
   {return(LGL.getAspect());}
 
inline double getNear()
   {return(LGL.getNear());}
 
inline double getFar()
   {return(LGL.getFar());}
 
inline void lglModelView()
   {LGL.lglModelView();}
 
inline void lglModelView(const mat4 &modelview)
   {LGL.lglModelView(modelview);}
 
inline void lglView(const vec3 &eye, const vec3 &at, const vec3 &up = vec3(0,1,0))
   {LGL.lglView(eye, at, up);}
 
inline void lglView(double eye_x, double eye_y, double eye_z,
                    double at_x, double at_y, double at_z,
                    double up_x = 0, double up_y = 1, double up_z = 0)
   {LGL.lglView(eye_x,eye_y,eye_z, at_x,at_y,at_z, up_x,up_y,up_z);}
 
inline vec3 getEye()
   {return(LGL.getEye());}
 
inline vec3 getLookAt()
   {return(LGL.getLookAt());}
 
inline vec3 getUp()
   {return(LGL.getUp());}
 
inline void lglManip(bool on = true)
   {LGL.lglManip(on);}
 
inline void lglManip(const mat4 &manip)
   {LGL.lglManip(manip);}
 
inline void lglManip(double focus, double angle, double tilt, double zoom)
   {LGL.lglManip(focus, angle, tilt, zoom);}
 
inline void lglManip(double dx, double dy, double zoom = 1)
   {LGL.lglManip(dx, dy, zoom);}
 
inline void lglManip(vec2 delta, double zoom = 1)
   {LGL.lglManip(delta, zoom);}
 
inline void lglResetManip()
   {LGL.lglResetManip();}
 
inline mat4 lglGetManip()
   {return(LGL.lglGetManip());}
 
inline bool lglIsManipApplied()
   {return(LGL.lglIsManipApplied());}
 
inline mat4 lglGetInverseTransposeManip()
   {return(LGL.lglGetInverseTransposeManip());}
 
inline void lglModel(const mat4 &model)
   {LGL.lglModel(model);}
 
inline mat4 lglGetModelMatrix()
   {return(LGL.lglGetModelMatrix());}
 
inline mat4 lglGetInverseTransposeModelMatrix()
   {return(LGL.lglGetInverseTransposeModelMatrix());}
 
inline void lglTex(const mat4 &tex)
   {LGL.lglTex(tex);}
 
inline void lglTex(const vec4 &scale, const vec4 &offset)
   {LGL.lglTex(scale, offset);}
 
inline mat4 lglGetTexMatrix()
   {return(LGL.lglGetTexMatrix());}
 
inline void lglLight(vec4f light = vec4f(0,0,1,0), bool camera_light = true,
                     vec3f ka = vec3f(0.1f), vec3f kd = vec3f(0.7f), vec3f ks = vec3f(0.2f),
                     vec3f Ia = vec3f(1), vec3f Id = vec3f(1), vec3f Is = vec3f(1),
                     float exponent = 30, vec3f falloff = vec3f(1,0,0))
   {LGL.lglLight(light, camera_light, ka, kd, ks, Ia, Id, Is, exponent, falloff);}
 
inline void lglInitializeOpenGL(float r=0, float g=0, float b=0, float a=1,
                                bool ztest = true, bool culling = false)
   {LGL.lglInitializeOpenGL(r,g,b,a, ztest, culling);}
 
inline void lglRGBAWrite(bool r = true, bool g = true, bool b = true, bool a = true)
   {LGL.lglRGBAWrite(r,g,b,a);}
 
inline bool lglGetRGBAWrite()
   {return(LGL.lglGetRGBAWrite());}
 
inline void lglZWrite(bool on = true)
   {LGL.lglZWrite(on);}
 
inline bool lglGetZWrite()
   {return(LGL.lglGetZWrite());}
 
inline void lglDepthTest(bool on = false)
   {LGL.lglDepthTest(on);}
 
inline bool lglGetDepthTest()
   {return(LGL.lglGetDepthTest());}
 
inline void lglBackFaceCulling(bool on = true)
   {LGL.lglBackFaceCulling(on);}
 
inline bool lglGetBackFaceCulling()
   {return(LGL.lglGetBackFaceCulling());}
 
inline void lglBlendMode(lgl_blendmode_enum mode)
   {LGL.lglBlendMode(mode);}
 
inline bool lglGetBlending()
   {return(LGL.lglGetBlending());}
 
inline lgl_blendmode_enum lglGetBlendMode()
   {return(LGL.lglGetBlendMode());}
 
inline void lglAlphaTest(bool on = false, float value = 0.0f, bool greater = true, bool equal = false)
   {LGL.lglAlphaTest(on, value, greater, equal);}
 
inline bool lglGetAlphaTest()
   {return(LGL.lglGetAlphaTest());}
 
inline float lglGetAlphaTestValue()
   {return(LGL.lglGetAlphaTestValue());}
 
inline bool lglGetAlphaTestGreater()
   {return(LGL.lglGetAlphaTestGreater());}
 
inline bool lglGetAlphaTestEqual()
   {return(LGL.lglGetAlphaTestEqual());}
 
inline bool lglGetClipPlane(unsigned int n = 0)
   {return(LGL.lglGetClipPlane(n));}
 
inline vec4 lglGetClipPlaneEquation(unsigned int n = 0)
   {return(LGL.lglGetClipPlaneEquation(n));}
 
inline vec4 lglGetClipPlaneEquation(vec3 point, vec3 normal)
   {return(LGL.lglGetClipPlaneEquation(point, normal));}
 
inline bool lglGetFog()
   {return(LGL.lglGetFog());}
 
inline float lglGetFogDensity()
   {return(LGL.lglGetFogDensity());}
 
inline vec4f lglGetFogColor()
   {return(LGL.lglGetFogColor());}
 
inline float lglGetLineWidth()
   {return(LGL.lglGetLineWidth());}
 
inline void lglTogglePolygonMode()
   {LGL.lglTogglePolygonMode();}
 
inline lgl_polygonmode_enum lglGetPolygonMode()
   {return(LGL.lglGetPolygonMode());}
 
inline void lglInterlacingMode(lgl_interlacing_enum mode)
   {LGL.lglInterlacingMode(mode);}
 
inline void lglComplementaryInterlacingMode(lgl_interlacing_enum mode)
   {LGL.lglComplementaryInterlacingMode(mode);}
 
inline lgl_interlacing_enum lglGetInterlacingMode()
   {return(LGL.lglGetInterlacingMode());}
 
inline GLuint lglSupportsGLSL()
   {return(LGL.lglSupportsGLSL());}
 
inline std::string lglGetGLSLVersionString()
   {return(LGL.lglGetGLSLVersionString());}
 
inline std::string lglPlainGLSLVertexShader()
   {return(LGL.lglPlainGLSLVertexShader());}
 
inline std::string lglPlainGLSLFragmentShader()
   {return(LGL.lglPlainGLSLFragmentShader());}
 
inline std::string lglPlainGLSLProgram()
   {return(LGL.lglPlainGLSLProgram());}
 
inline std::string lglBasicGLSLVertexShader(bool colors = false, bool normals = false, bool texcoords = false)
   {return(LGL.lglBasicGLSLVertexShader(colors, normals, texcoords));}
 
inline std::string lglBasicGLSLFragmentShader(bool colors = false, bool normals = false, bool texcoords = false, bool tex3D = false)
   {return(LGL.lglBasicGLSLFragmentShader(colors, normals, texcoords, tex3D));}
 
inline GLuint lglCompileGLSLVertexShader(std::string shader)
   {return(LGL.lglCompileGLSLVertexShader(shader));}
 
inline GLuint lglCompileGLSLFragmentShader(std::string shader)
   {return(LGL.lglCompileGLSLFragmentShader(shader));}
 
inline GLuint lglLinkGLSLProgram(GLuint vertex_shader_id, GLuint fragment_shader_id, GLuint custom_shader_program = 0)
   {return(LGL.lglLinkGLSLProgram(vertex_shader_id, fragment_shader_id, custom_shader_program));}
 
inline GLuint lglCompileGLSLProgram(std::string vertex_shader, std::string fragment_shader)
   {return(LGL.lglCompileGLSLProgram(vertex_shader, fragment_shader));}
 
inline GLuint lglLoadGLSLProgram(const char *vertex_shader_file, const char *fragment_shader_file)
   {return(LGL.lglLoadGLSLProgram(vertex_shader_file, fragment_shader_file));}
 
inline std::string lglCombineGLSLProgram(const std::string &vertex_shader, const std::string &fragment_shader)
   {return(LGL.lglCombineGLSLProgram(vertex_shader, fragment_shader));}
 
inline bool lglSplitGLSLProgram(std::string shader, std::string &vertex_shader, std::string &fragment_shader)
   {return(LGL.lglSplitGLSLProgram(shader, vertex_shader, fragment_shader));}
 
inline GLuint lglCompileGLSLProgram(std::string shader)
   {return(LGL.lglCompileGLSLProgram(shader));}
 
inline GLuint lglLoadGLSLProgram(const char *shader_file)
   {return(LGL.lglLoadGLSLProgram(shader_file));}
 
inline void lglDeleteGLSLShader(GLuint shader_id)
   {LGL.lglDeleteGLSLShader(shader_id);}
 
inline void lglDeleteGLSLProgram(GLuint program)
   {LGL.lglDeleteGLSLProgram(program);}
 
inline void lglUseProgram(GLuint program, bool clear = true)
   {LGL.lglUseProgram(program, clear);}
 
inline void lglUseDefaultProgram(bool clear = true)
   {LGL.lglUseDefaultProgram(clear);}
 
inline void lglReplaceDefaultProgram(GLuint program, bool colors = false, bool normals = true, bool texcoords = false, bool tex3D = false)
   {LGL.lglReplaceDefaultProgram(program, colors, normals, texcoords, tex3D);}
 
inline GLuint lglGetProgram()
   {return(LGL.lglGetProgram());}
 
inline GLuint lglGetActiveProgram()
   {return(LGL.lglGetActiveProgram());}
 
inline void lglReuseProgram(GLuint program)
   {LGL.lglReuseProgram(program);}
 
inline unsigned int lglUniform(std::string uniform)
   {return(LGL.lglUniform(uniform));}
 
inline unsigned int lglUniformi(std::string uniform, int value)
   {return(LGL.lglUniformi(uniform, value));}
 
inline void lglUniformi(unsigned int index, int value)
   {LGL.lglUniformi(index, value);}
 
inline unsigned int lglUniformf(std::string uniform, double value)
   {return(LGL.lglUniformf(uniform, value));}
 
inline void lglUniformf(unsigned int index, double value)
   {LGL.lglUniformf(index, value);}
 
inline unsigned int lglUniformf(std::string uniform, double x, double y, double z, double w = 1)
   {return(LGL.lglUniformf(uniform, x, y, z, w));}
 
inline void lglUniformf(unsigned int index, double x, double y, double z, double w = 1)
   {LGL.lglUniformf(index, x, y, z, w);}
 
inline unsigned int lglUniformfv(std::string uniform, const vec2f &value)
   {return(LGL.lglUniformfv(uniform, value));}
 
inline void lglUniformfv(unsigned int index, const vec2f &value)
   {LGL.lglUniformfv(index, value);}
 
inline unsigned int lglUniformfv(std::string uniform, const vec2 &value)
   {return(LGL.lglUniformfv(uniform, value));}
 
inline void lglUniformfv(unsigned int index, const vec2 &value)
   {LGL.lglUniformfv(index, value);}
 
inline unsigned int lglUniformfv(std::string uniform, const vec3f &value)
   {return(LGL.lglUniformfv(uniform, value));}
 
inline void lglUniformfv(unsigned int index, const vec3f &value)
   {LGL.lglUniformfv(index, value);}
 
inline unsigned int lglUniformfv(std::string uniform, const vec3 &value)
   {return(LGL.lglUniformfv(uniform, value));}
 
inline void lglUniformfv(unsigned int index, const vec3 &value)
   {LGL.lglUniformfv(index, value);}
 
inline unsigned int lglUniformfv(std::string uniform, const vec4f &value)
   {return(LGL.lglUniformfv(uniform, value));}
 
inline void lglUniformfv(unsigned int index, const vec4f &value)
   {LGL.lglUniformfv(index, value);}
 
inline unsigned int lglUniformfv(std::string uniform, const vec4 &value)
   {return(LGL.lglUniformfv(uniform, value));}
 
inline void lglUniformfv(unsigned int index, const vec4 &value)
   {LGL.lglUniformfv(index, value);}
 
inline unsigned int lglUniformfv(std::string uniform, const mat2f &value)
   {return(LGL.lglUniformfv(uniform, value));}
 
inline void lglUniformfv(unsigned int index, const mat2f &value)
   {LGL.lglUniformfv(index, value);}
 
inline unsigned int lglUniformfv(std::string uniform, const mat2 &value)
   {return(LGL.lglUniformfv(uniform, value));}
 
inline void lglUniformfv(unsigned int index, const mat2 &value)
   {LGL.lglUniformfv(index, value);}
 
inline unsigned int lglUniformfv(std::string uniform, const mat3f &value)
   {return(LGL.lglUniformfv(uniform, value));}
 
inline void lglUniformfv(unsigned int index, const mat3f &value)
   {LGL.lglUniformfv(index, value);}
 
inline unsigned int lglUniformfv(std::string uniform, const mat3 &value)
   {return(LGL.lglUniformfv(uniform, value));}
 
inline void lglUniformfv(unsigned int index, const mat3 &value)
   {LGL.lglUniformfv(index, value);}
 
inline unsigned int lglUniformfv(std::string uniform, const mat4f &value)
   {return(LGL.lglUniformfv(uniform, value));}
 
inline void lglUniformfv(unsigned int index, const mat4f &value)
   {LGL.lglUniformfv(index, value);}
 
inline unsigned int lglUniformfv(std::string uniform, const mat4 &value)
   {return(LGL.lglUniformfv(uniform, value));}
 
inline void lglUniformfv(unsigned int index, const mat4 &value)
   {LGL.lglUniformfv(index, value);}
 
inline unsigned int lglSampler(std::string sampler, int value = 0, bool warn = true)
   {return(LGL.lglSampler(sampler, value, warn));}
 
inline void lglSampler(unsigned int index, int value = 0, bool warn = true)
   {LGL.lglSampler(index, value, warn);}
 
inline unsigned int lglSampler2D(std::string sampler, GLuint texid2D, int value = 0, bool warn = true)
   {return(LGL.lglSampler2D(sampler, texid2D, value, warn));}
 
inline void lglSampler2D(unsigned int index, GLuint texid2D, int value = 0, bool warn = true)
   {LGL.lglSampler2D(index, texid2D, value, warn);}
 
inline unsigned int lglSampler3D(std::string sampler, GLuint texid3D, int value = 0, bool warn = true)
   {return(LGL.lglSampler3D(sampler, texid3D, value, warn));}
 
inline void lglSampler3D(unsigned int index, GLuint texid3D, int value = 0, bool warn = true)
   {LGL.lglSampler3D(index, texid3D, value, warn);}
 
inline void lglPrintUniforms()
   {LGL.lglPrintUniforms();}
 
inline void lglLightDirection(vec3f light = vec3f(0,0,1), bool camera_light = true)
   {LGL.lglLightDirection(light, camera_light);}
 
inline void lglLightPosition(vec3f light = vec3f(0,0,0), bool camera_light = true)
   {LGL.lglLightPosition(light, camera_light);}
 
inline void lglLightVector(vec4f light = vec4f(0,0,1,0), bool camera_light = true)
   {LGL.lglLightVector(light, camera_light);}
 
inline vec4f lglGetLightVector()
   {return(LGL.lglGetLightVector());}
 
inline void lglLightParameters(vec3f ka = vec3f(0.1f), vec3f kd = vec3f(0.7f), vec3f ks = vec3f(0.2f),
                               vec3f Ia = vec3f(1), vec3f Id = vec3f(1), vec3f Is = vec3f(1),
                               float exponent = 30, vec3f falloff = vec3f(1,0,0))
   {LGL.lglLightParameters(ka, kd, ks, Ia, Id, Is, exponent, falloff);}
 
inline void lglGetLightParameters(vec3f &ka, vec3f &kd, vec3f &ks,
                                  vec3f &Ia, vec3f &Id, vec3f &Is,
                                  float &exponent, vec3f &falloff)
   {LGL.lglGetLightParameters(ka, kd, ks, Ia, Id, Is, exponent, falloff);}
 
inline void lglLightSourceParameters(vec3f Ia = vec3f(1), vec3f Id = vec3f(1), vec3f Is = vec3f(1),
                                     vec3f falloff = vec3f(1,0,0))
   {LGL.lglLightSourceParameters(Ia, Id, Is, falloff);}
 
inline void lglGetLightSourceParameters(vec3f &Ia, vec3f &Id, vec3f &Is,
                                        vec3f &falloff)
   {LGL.lglGetLightSourceParameters(Ia, Id, Is, falloff);}
 
inline void lglMaterialParameters(vec3f ka = vec3f(0.1f), vec3f kd = vec3f(0.7f), vec3f ks = vec3f(0.2f),
                                  float exponent = 30)
   {LGL.lglMaterialParameters(ka, kd, ks, exponent);}
 
inline void lglGetMaterialParameters(vec3f &ka, vec3f &kd, vec3f &ks,
                                     float &exponent)
   {LGL.lglGetMaterialParameters(ka, kd, ks, exponent);}
 
inline void lglTexture2D(GLuint texid, bool owner = false)
   {LGL.lglTexture2D(texid, owner);}
 
inline GLuint lglGetTexture2D()
   {return(LGL.lglGetTexture2D());}
 
inline void lglTexture3D(GLuint texid, bool owner = false)
   {LGL.lglTexture3D(texid, owner);}
 
inline GLuint lglGetTexture3D()
   {return(LGL.lglGetTexture3D());}
 
inline void lglDeleteTexture()
   {LGL.lglDeleteTexture();}
 
inline void lglTexCoordGen(lgl_texgenmode_enum mode = LGL_TEXGEN_LINEAR)
   {LGL.lglTexCoordGen(mode);}
 
inline lgl_texgenmode_enum lglGetTexCoordGen()
   {return(LGL.lglGetTexCoordGen());}
 
inline void lglColoring(bool on)
   {LGL.lglColoring(on);}
 
inline bool lglGetColoring()
   {return(LGL.lglGetColoring());}
 
inline void lglLighting(bool on)
   {LGL.lglLighting(on);}
 
inline bool lglGetLighting()
   {return(LGL.lglGetLighting());}
 
inline void lglTexturing(bool on)
   {LGL.lglTexturing(on);}
 
inline bool lglGetTexturing()
   {return(LGL.lglGetTexturing());}
 
inline void lglDisableColoring(bool off)
   {LGL.lglDisableColoring(off);}
 
inline void lglDisableLighting(bool off)
   {LGL.lglDisableLighting(off);}
 
inline void lglDisableTexturing(bool off)
   {LGL.lglDisableTexturing(off);}
 
inline void lglRender(lglVBO *vbo, const GL *gl = &LGL)
   {vbo->lglRender(gl);}
 
inline void lglRender(lglVBO &vbo, const GL *gl = &LGL)
   {vbo.lglRender(gl);}
 
inline void lglCloneState(const GL *gl)
   {LGL.lglCloneState(gl);}
 
inline void lglCloneState(const lglVBO *vbo)
   {LGL.lglCloneState(vbo);}
 
inline void lglCopyUniforms(const GL *gl, bool warn = false)
   {LGL.lglCopyUniforms(gl);}
 
inline void lglCopyUniforms(const lglVBO *vbo, bool warn = false)
   {LGL.lglCopyUniforms(vbo);}
 
inline unsigned char *lglReadRGBPixels(int x, int y, int width, int height)
   {return(LGL.lglReadRGBPixels(x, y, width, height));}
 
inline void lglBeginRayCast(vec3 origin, vec3 direction, double mindist = 0)
   {LGL.lglBeginRayCast(origin, direction, mindist);}
 
inline void lglRayCast(lglVBO *vbo)
   {LGL.lglRayCast(vbo);}
 
inline LGL_VBO_TYPE *lglEndRayCast()
   {return(LGL.lglEndRayCast());}
 
inline double lglGetRayCastDistance()
   {return(LGL.lglGetRayCastDistance());}
 
inline void lglEnableViewCulling(int minsize = 0)
   {LGL.lglEnableViewCulling(minsize);}
 
inline void lglDisableViewCulling()
   {LGL.lglDisableViewCulling();}
 
inline void lglBeginExport(void (*callback)(LGL_VBO_TYPE *vbo, void *data), void *data, mat4 m = mat4(1))
   {LGL.lglBeginExport(callback, data, m);}
 
inline void lglEndExport()
   {LGL.lglEndExport();}
 
inline int lglGetGLVersion()
   {return(LGL.lglGetGLVersion());}
 
inline int lglMapGL2GLSLVersion(int glversion)
   {return(LGL.lglMapGL2GLSLVersion(glversion));}
 
inline int lglGetGLSLVersion()
   {return(LGL.lglGetGLSLVersion());}
 
inline std::string lglGetRenderer()
   {return(LGL.lglGetRenderer());}
 
inline lgl_vendor_enum lglGetVendor()
   {return(LGL.lglGetVendor());}
 
inline std::string lglGetVendorName()
   {return(LGL.lglGetVendorName());}
 
// wrapped extension function
inline void lglTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
   {LGL.lglTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);}
 
// wrapped extension function
inline void lglTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
   {LGL.lglTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);}
 
inline void lglMessage(std::string m)
   {LGL.lglMessage(m);}
 
inline void lglError(std::string e)
   {LGL.lglError(e);}
 
inline void lglWarning(std::string w)
   {LGL.lglWarning(w);}
 
inline void lglFatal(std::string e)
   {LGL.lglFatal(e);}
 
inline std::string lglGetWarning()
   {return(LGL.lglGetWarning());}
 
inline void lglVerbosity(lgl_verbosity_enum v)
   {LGL.lglVerbosity(v);}
 
// scoped matrix stack
class lglScopedMatrixStack
{
public:
 
   lglScopedMatrixStack()
      {lglPushMatrix();}
 
   ~lglScopedMatrixStack()
      {lglPopMatrix();}
 
};
 
#define lglPushMatrixScoped() lglScopedMatrixStack __lglPushMatrixScoped__
 
#define lglRandom() drand48()
 
#define lglSeed() srand48((unsigned int)time(NULL))
 
#define LGL_WARN(s) lglWarn(std::string(s)+" @ "+__FILE__+":"+glslmath::to_string(__LINE__))
 
#define LGL_ERROR(s) lglError(std::string(s)+" @ "+__FILE__+":"+glslmath::to_string(__LINE__))
 
#ifdef LGL_CORE
 
// explicitly disallow the usage of all OpenGL legacy functions
#define glVertex2f(x,y) LGL_ERROR("use lglVertex instead of glVertex2f")
#define glVertex2d(x,y) LGL_ERROR("use lglVertex instead of glVertex2d")
#define glVertex3f(x,y,z) LGL_ERROR("use lglVertex instead of glVertex3f")
#define glVertex3d(x,y,z) LGL_ERROR("use lglVertex instead of glVertex3d")
#define glVertex4f(x,y,z,w) LGL_ERROR("use lglVertex instead of glVertex4f")
#define glVertex4d(x,y,z,w) LGL_ERROR("use lglVertex instead of glVertex4d")
#define glColor3f(x,y,z) LGL_ERROR("use lglColor instead of glColor3f")
#define glColor3d(x,y,z) LGL_ERROR("use lglColor instead of glColor3d")
#define glNormal3f(x,y,z) LGL_ERROR("use lglNormal instead of glNormal3f")
#define glNormal3d(x,y,z) LGL_ERROR("use lglNormal instead of glNormal3d")
#define glTexCoord2f(x,y) LGL_ERROR("use lglTexCoord instead of glTexCoord2f")
#define glTexCoord2d(x,y) LGL_ERROR("use lglTexCoord instead of glTexCoord2d")
#define glTexCoord3f(x,y,z) LGL_ERROR("use lglTexCoord instead of glTexCoord3f")
#define glTexCoord3d(x,y,z) LGL_ERROR("use lglTexCoord instead of glTexCoord3d")
#define glTexCoord4f(x,y,z,w) LGL_ERROR("use lglTexCoord instead of glTexCoord4f")
#define glTexCoord4d(x,y,z,w) LGL_ERROR("use lglTexCoord instead of glTexCoord4d")
#define glMatrixMode(m) LGL_ERROR("use lglMatrixMode instead of glMatrixMode")
#define glLoadIdentity(m) LGL_ERROR("use lglLoadIdentity instead of glLoadIdentity")
#define glLoadMatrixf(m) LGL_ERROR("use lglLoadMatrix instead of glLoadMatrixf")
#define glLoadMatrixd(m) LGL_ERROR("use lglLoadMatrix instead of glLoadMatrixd")
#define glMultMatrixf(m) LGL_ERROR("use lglMultMatrix instead of glMultMatrixf")
#define glMultMatrixd(m) LGL_ERROR("use lglMultMatrix instead of glMultMatrixd")
#define glPushMatrix() LGL_ERROR("use lglPushMatrix instead of glPushMatrix")
#define glPopMatrix() LGL_ERROR("use lglPopMatrix instead of glPopMatrix")
#define glTranslatef(x,y,z) LGL_ERROR("use lglTranslate instead of glTranslatef")
#define glTranslated(x,y,z) LGL_ERROR("use lglTranslate instead of glTranslated")
#define glRotatef(a,x,y,z) LGL_ERROR("use lglRotate instead of glRotatef")
#define glRotated(a,x,y,z) LGL_ERROR("use lglRotate instead of glRotated")
#define glScalef(x,y,z) LGL_ERROR("use lglScale instead of glScalef")
#define glScaled(x,y,z) LGL_ERROR("use lglScale instead of glScaled")
#define glOrtho(l,r,b,t,n,f) LGL_ERROR("use lglOrtho instead of glOrtho")
 
#ifdef GLU_VERSION
#define gluPerspective(fy,ar,np,fp) LGL_ERROR("use lglPerspective instead of gluPerspective")
#define gluLookAt(ex,ey,ez,ax,ay,az,ux,uy,uz) LGL_ERROR("use lglLookAt instead of gluLookAt")
#endif
 
#endif
 
#endif