diff --git a/modules/core/include/opencv2/core/core.hpp b/modules/core/include/opencv2/core/core.hpp index 60d9d013c8..68a9689da8 100644 --- a/modules/core/include/opencv2/core/core.hpp +++ b/modules/core/include/opencv2/core/core.hpp @@ -91,7 +91,7 @@ class SparseMat; typedef Mat MatND; class GlBuffer; -class GlTexture; +class GlTexture2D; class GlArrays; class GlCamera; @@ -1311,7 +1311,7 @@ public: STD_VECTOR_MAT = 5 << KIND_SHIFT, EXPR = 6 << KIND_SHIFT, OPENGL_BUFFER = 7 << KIND_SHIFT, - OPENGL_TEXTURE = 8 << KIND_SHIFT, + OPENGL_TEXTURE2D = 8 << KIND_SHIFT, GPU_MAT = 9 << KIND_SHIFT }; _InputArray(); @@ -1328,13 +1328,13 @@ public: _InputArray(const Scalar& s); _InputArray(const double& val); _InputArray(const GlBuffer& buf); - _InputArray(const GlTexture& tex); + _InputArray(const GlTexture2D& tex); _InputArray(const gpu::GpuMat& d_mat); virtual Mat getMat(int i=-1) const; virtual void getMatVector(vector& mv) const; virtual GlBuffer getGlBuffer() const; - virtual GlTexture getGlTexture() const; + virtual GlTexture2D getGlTexture2D() const; virtual gpu::GpuMat getGpuMat() const; virtual int kind() const; @@ -1385,6 +1385,8 @@ public: template _OutputArray(Matx<_Tp, m, n>& matx); template _OutputArray(_Tp* vec, int n); _OutputArray(gpu::GpuMat& d_mat); + _OutputArray(GlBuffer& buf); + _OutputArray(GlTexture2D& tex); _OutputArray(const Mat& m); template _OutputArray(const vector<_Tp>& vec); @@ -1395,12 +1397,16 @@ public: template _OutputArray(const Matx<_Tp, m, n>& matx); template _OutputArray(const _Tp* vec, int n); _OutputArray(const gpu::GpuMat& d_mat); + _OutputArray(const GlBuffer& buf); + _OutputArray(const GlTexture2D& tex); virtual bool fixedSize() const; virtual bool fixedType() const; virtual bool needed() const; virtual Mat& getMatRef(int i=-1) const; virtual gpu::GpuMat& getGpuMatRef() const; + virtual GlBuffer& getGlBufferRef() const; + virtual GlTexture2D& getGlTexture2DRef() const; virtual void create(Size sz, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const; virtual void create(int rows, int cols, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const; virtual void create(int dims, const int* size, int type, int i=-1, bool allowTransposed=false, int fixedDepthMask=0) const; diff --git a/modules/core/include/opencv2/core/internal.hpp b/modules/core/include/opencv2/core/internal.hpp index 93e56c3ab3..c042ccaf1f 100644 --- a/modules/core/include/opencv2/core/internal.hpp +++ b/modules/core/include/opencv2/core/internal.hpp @@ -750,39 +750,4 @@ typedef struct CvBigFuncTable (tab).fn_2d[CV_32F] = (void*)FUNCNAME##_32f##FLAG; \ (tab).fn_2d[CV_64F] = (void*)FUNCNAME##_64f##FLAG -#ifdef __cplusplus -//! OpenGL extension table -class CV_EXPORTS CvOpenGlFuncTab -{ -public: - virtual ~CvOpenGlFuncTab(); - - virtual void genBuffers(int n, unsigned int* buffers) const = 0; - virtual void deleteBuffers(int n, const unsigned int* buffers) const = 0; - - virtual void bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const = 0; - virtual void bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const = 0; - - virtual void bindBuffer(unsigned int target, unsigned int buffer) const = 0; - - virtual void* mapBuffer(unsigned int target, unsigned int access) const = 0; - virtual void unmapBuffer(unsigned int target) const = 0; - - virtual void generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool underline, int start, int count, int base) const = 0; - - virtual bool isGlContextInitialized() const = 0; -}; - -CV_EXPORTS void icvSetOpenGlFuncTab(const CvOpenGlFuncTab* tab); - -CV_EXPORTS bool icvCheckGlError(const char* file, const int line, const char* func = ""); - -#if defined(__GNUC__) - #define CV_CheckGlError() CV_DbgAssert( (::icvCheckGlError(__FILE__, __LINE__, __func__)) ) -#else - #define CV_CheckGlError() CV_DbgAssert( (::icvCheckGlError(__FILE__, __LINE__)) ) -#endif - -#endif //__cplusplus - #endif // __OPENCV_CORE_INTERNAL_HPP__ diff --git a/modules/core/include/opencv2/core/opengl_interop.hpp b/modules/core/include/opencv2/core/opengl_interop.hpp index 0bd2e9fdcf..91fba7b7f9 100644 --- a/modules/core/include/opencv2/core/opengl_interop.hpp +++ b/modules/core/include/opencv2/core/opengl_interop.hpp @@ -47,40 +47,68 @@ #include "opencv2/core/core.hpp" -namespace cv -{ +namespace cv { + +CV_EXPORTS bool checkGlError(const char* file, const int line, const char* func = ""); + +#if defined(__GNUC__) + #define CV_CheckGlError() CV_DbgAssert( (cv::checkGlError(__FILE__, __LINE__, __func__)) ) +#else + #define CV_CheckGlError() CV_DbgAssert( (cv::checkGlError(__FILE__, __LINE__)) ) +#endif + +/////////////////// OpenGL Objects /////////////////// + //! Smart pointer for OpenGL buffer memory with reference counting. class CV_EXPORTS GlBuffer { public: - enum Usage + enum Target { - ARRAY_BUFFER = 0x8892, // buffer will use for OpenGL arrays (vertices, colors, normals, etc) - TEXTURE_BUFFER = 0x88EC // buffer will ise for OpenGL textures + ARRAY_BUFFER = 0x8892, //!< The buffer will be used as a source for vertex data + ELEMENT_ARRAY_BUFFER = 0x8893, //!< The buffer will be used for indices (in glDrawElements, for example) + PIXEL_PACK_BUFFER = 0x88EB, //!< The buffer will be used for reading from OpenGL textures + PIXEL_UNPACK_BUFFER = 0x88EC //!< The buffer will be used for writing to OpenGL textures }; //! create empty buffer - explicit GlBuffer(Usage usage); + GlBuffer(); + + //! create buffer from existed buffer id + GlBuffer(int arows, int acols, int atype, unsigned int abufId, bool autoRelease = false); + GlBuffer(Size asize, int atype, unsigned int abufId, bool autoRelease = false); //! create buffer - GlBuffer(int rows, int cols, int type, Usage usage); - GlBuffer(Size size, int type, Usage usage); + GlBuffer(int arows, int acols, int atype, Target target = ARRAY_BUFFER); + GlBuffer(Size asize, int atype, Target target = ARRAY_BUFFER); //! copy from host/device memory - GlBuffer(InputArray mat, Usage usage); + explicit GlBuffer(InputArray arr, Target target = ARRAY_BUFFER); - void create(int rows, int cols, int type, Usage usage); - void create(Size size, int type, Usage usage); - void create(int rows, int cols, int type); - void create(Size size, int type); + //! create buffer + void create(int arows, int acols, int atype, Target target = ARRAY_BUFFER); + void create(Size asize, int atype, Target target = ARRAY_BUFFER) { create(asize.height, asize.width, atype, target); } + //! release memory and delete buffer object void release(); - //! copy from host/device memory - void copyFrom(InputArray mat); + //! set auto release mode (if true, release will be called in object's destructor) + void setAutoRelease(bool flag); - void bind() const; - void unbind() const; + //! copy from host/device memory + void copyFrom(InputArray arr, Target target = ARRAY_BUFFER); + + //! copy to host/device memory + void copyTo(OutputArray arr, Target target = ARRAY_BUFFER) const; + + //! create copy of current buffer + GlBuffer clone(Target target = ARRAY_BUFFER) const; + + //! bind buffer for specified target + void bind(Target target) const; + + //! unbind any buffers from specified target + static void unbind(Target target); //! map to host memory Mat mapHost(); @@ -90,162 +118,134 @@ public: gpu::GpuMat mapDevice(); void unmapDevice(); - inline int rows() const { return rows_; } - inline int cols() const { return cols_; } - inline Size size() const { return Size(cols_, rows_); } - inline bool empty() const { return rows_ == 0 || cols_ == 0; } + int rows() const { return rows_; } + int cols() const { return cols_; } + Size size() const { return Size(cols_, rows_); } + bool empty() const { return rows_ == 0 || cols_ == 0; } - inline int type() const { return type_; } - inline int depth() const { return CV_MAT_DEPTH(type_); } - inline int channels() const { return CV_MAT_CN(type_); } - inline int elemSize() const { return CV_ELEM_SIZE(type_); } - inline int elemSize1() const { return CV_ELEM_SIZE1(type_); } + int type() const { return type_; } + int depth() const { return CV_MAT_DEPTH(type_); } + int channels() const { return CV_MAT_CN(type_); } + int elemSize() const { return CV_ELEM_SIZE(type_); } + int elemSize1() const { return CV_ELEM_SIZE1(type_); } - inline Usage usage() const { return usage_; } + unsigned int bufId() const; class Impl; + private: + Ptr impl_; int rows_; int cols_; int type_; - Usage usage_; - - Ptr impl_; }; template <> CV_EXPORTS void Ptr::delete_obj(); -//! Smart pointer for OpenGL 2d texture memory with reference counting. -class CV_EXPORTS GlTexture +//! Smart pointer for OpenGL 2D texture memory with reference counting. +class CV_EXPORTS GlTexture2D { public: + enum Format + { + NONE = 0, + DEPTH_COMPONENT = 0x1902, //!< Depth + RGB = 0x1907, //!< Red, Green, Blue + RGBA = 0x1908 //!< Red, Green, Blue, Alpha + }; + //! create empty texture - GlTexture(); + GlTexture2D(); + + //! create texture from existed texture id + GlTexture2D(int arows, int acols, Format aformat, unsigned int atexId, bool autoRelease = false); + GlTexture2D(Size asize, Format aformat, unsigned int atexId, bool autoRelease = false); //! create texture - GlTexture(int rows, int cols, int type); - GlTexture(Size size, int type); + GlTexture2D(int arows, int acols, Format aformat); + GlTexture2D(Size asize, Format aformat); //! copy from host/device memory - explicit GlTexture(InputArray mat, bool bgra = true); + explicit GlTexture2D(InputArray arr); - void create(int rows, int cols, int type); - void create(Size size, int type); + //! create texture + void create(int arows, int acols, Format aformat); + void create(Size asize, Format aformat) { create(asize.height, asize.width, aformat); } + + //! release memory and delete texture object void release(); + //! set auto release mode (if true, release will be called in object's destructor) + void setAutoRelease(bool flag); + //! copy from host/device memory - void copyFrom(InputArray mat, bool bgra = true); + void copyFrom(InputArray arr); + //! copy to host/device memory + void copyTo(OutputArray arr, int ddepth = CV_32F) const; + + //! bind texture to current active texture unit for GL_TEXTURE_2D target void bind() const; - void unbind() const; - inline int rows() const { return rows_; } - inline int cols() const { return cols_; } - inline Size size() const { return Size(cols_, rows_); } - inline bool empty() const { return rows_ == 0 || cols_ == 0; } + int rows() const { return rows_; } + int cols() const { return cols_; } + Size size() const { return Size(cols_, rows_); } + bool empty() const { return rows_ == 0 || cols_ == 0; } - inline int type() const { return type_; } - inline int depth() const { return CV_MAT_DEPTH(type_); } - inline int channels() const { return CV_MAT_CN(type_); } - inline int elemSize() const { return CV_ELEM_SIZE(type_); } - inline int elemSize1() const { return CV_ELEM_SIZE1(type_); } + Format format() const { return format_; } + + unsigned int texId() const; class Impl; + private: + Ptr impl_; int rows_; int cols_; - int type_; - - Ptr impl_; - GlBuffer buf_; + Format format_; }; -template <> CV_EXPORTS void Ptr::delete_obj(); +template <> CV_EXPORTS void Ptr::delete_obj(); //! OpenGL Arrays class CV_EXPORTS GlArrays { public: - inline GlArrays() - : vertex_(GlBuffer::ARRAY_BUFFER), color_(GlBuffer::ARRAY_BUFFER), bgra_(true), normal_(GlBuffer::ARRAY_BUFFER), texCoord_(GlBuffer::ARRAY_BUFFER) - { - } + GlArrays(); void setVertexArray(InputArray vertex); - inline void resetVertexArray() { vertex_.release(); } + void resetVertexArray(); - void setColorArray(InputArray color, bool bgra = true); - inline void resetColorArray() { color_.release(); } + void setColorArray(InputArray color); + void resetColorArray(); void setNormalArray(InputArray normal); - inline void resetNormalArray() { normal_.release(); } + void resetNormalArray(); void setTexCoordArray(InputArray texCoord); - inline void resetTexCoordArray() { texCoord_.release(); } + void resetTexCoordArray(); + + void release(); + + void setAutoRelease(bool flag); void bind() const; - void unbind() const; - inline int rows() const { return vertex_.rows(); } - inline int cols() const { return vertex_.cols(); } - inline Size size() const { return vertex_.size(); } - inline bool empty() const { return vertex_.empty(); } + int size() const { return size_; } + bool empty() const { return size_ == 0; } private: + int size_; GlBuffer vertex_; GlBuffer color_; - bool bgra_; GlBuffer normal_; GlBuffer texCoord_; }; -//! OpenGL Font -class CV_EXPORTS GlFont -{ -public: - enum Weight - { - WEIGHT_LIGHT = 300, - WEIGHT_NORMAL = 400, - WEIGHT_SEMIBOLD = 600, - WEIGHT_BOLD = 700, - WEIGHT_BLACK = 900 - }; - - enum Style - { - STYLE_NORMAL = 0, - STYLE_ITALIC = 1, - STYLE_UNDERLINE = 2 - }; - - static Ptr get(const std::string& family, int height = 12, Weight weight = WEIGHT_NORMAL, Style style = STYLE_NORMAL); - - void draw(const char* str, size_t len) const; - - inline const std::string& family() const { return family_; } - inline int height() const { return height_; } - inline Weight weight() const { return weight_; } - inline Style style() const { return style_; } - -private: - GlFont(const std::string& family, int height, Weight weight, Style style); - - std::string family_; - int height_; - Weight weight_; - Style style_; - - unsigned int base_; - - GlFont(const GlFont&); - GlFont& operator =(const GlFont&); -}; - -//! render functions +/////////////////// Render Functions /////////////////// //! render texture rectangle in window -CV_EXPORTS void render(const GlTexture& tex, +CV_EXPORTS void render(const GlTexture2D& tex, Rect_ wndRect = Rect_(0.0, 0.0, 1.0, 1.0), Rect_ texRect = Rect_(0.0, 0.0, 1.0, 1.0)); @@ -267,67 +267,13 @@ namespace RenderMode { //! render OpenGL arrays CV_EXPORTS void render(const GlArrays& arr, int mode = RenderMode::POINTS, Scalar color = Scalar::all(255)); +CV_EXPORTS void render(const GlArrays& arr, InputArray indices, int mode = RenderMode::POINTS, Scalar color = Scalar::all(255)); -CV_EXPORTS void render(const std::string& str, const Ptr& font, Scalar color, Point2d pos); - -//! OpenGL camera -class CV_EXPORTS GlCamera -{ -public: - GlCamera(); - - void lookAt(Point3d eye, Point3d center, Point3d up); - void setCameraPos(Point3d pos, double yaw, double pitch, double roll); - - void setScale(Point3d scale); - - void setProjectionMatrix(const Mat& projectionMatrix, bool transpose = true); - void setPerspectiveProjection(double fov, double aspect, double zNear, double zFar); - void setOrthoProjection(double left, double right, double bottom, double top, double zNear, double zFar); - - void setupProjectionMatrix() const; - void setupModelViewMatrix() const; - -private: - Point3d eye_; - Point3d center_; - Point3d up_; - - Point3d pos_; - double yaw_; - double pitch_; - double roll_; - - bool useLookAtParams_; - - Point3d scale_; - - Mat projectionMatrix_; - - double fov_; - double aspect_; - - double left_; - double right_; - double bottom_; - double top_; - - double zNear_; - double zFar_; - - bool perspectiveProjection_; -}; - -inline void GlBuffer::create(Size _size, int _type, Usage _usage) { create(_size.height, _size.width, _type, _usage); } -inline void GlBuffer::create(int _rows, int _cols, int _type) { create(_rows, _cols, _type, usage()); } -inline void GlBuffer::create(Size _size, int _type) { create(_size.height, _size.width, _type, usage()); } -inline void GlTexture::create(Size _size, int _type) { create(_size.height, _size.width, _type); } - -namespace gpu -{ +namespace gpu { //! set a CUDA device to use OpenGL interoperability CV_EXPORTS void setGlDevice(int device = 0); } + } // namespace cv #endif // __cplusplus diff --git a/modules/core/src/gl_core_3_1.cpp b/modules/core/src/gl_core_3_1.cpp new file mode 100644 index 0000000000..9e4865efb1 --- /dev/null +++ b/modules/core/src/gl_core_3_1.cpp @@ -0,0 +1,2780 @@ +#include "cvconfig.h" + +#ifdef HAVE_OPENGL + +#include +#include +#include "gl_core_3_1.hpp" + +#if defined(__APPLE__) +#include + +static void* AppleGLGetProcAddress (const GLubyte *name) +{ + static const struct mach_header* image = NULL; + NSSymbol symbol; + char* symbolName; + if (NULL == image) + { + image = NSAddImage("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", NSADDIMAGE_OPTION_RETURN_ON_ERROR); + } + /* prepend a '_' for the Unix C symbol mangling convention */ + symbolName = malloc(strlen((const char*)name) + 2); + strcpy(symbolName+1, (const char*)name); + symbolName[0] = '_'; + symbol = NULL; + /* if (NSIsSymbolNameDefined(symbolName)) + symbol = NSLookupAndBindSymbol(symbolName); */ + symbol = image ? NSLookupSymbolInImage(image, symbolName, NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : NULL; + free(symbolName); + return symbol ? NSAddressOfSymbol(symbol) : NULL; +} +#endif /* __APPLE__ */ + +#if defined(__sgi) || defined (__sun) +#include +#include + +static void* SunGetProcAddress (const GLubyte* name) +{ + static void* h = NULL; + static void* gpa; + + if (h == NULL) + { + if ((h = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL)) == NULL) return NULL; + gpa = dlsym(h, "glXGetProcAddress"); + } + + if (gpa != NULL) + return ((void*(*)(const GLubyte*))gpa)(name); + else + return dlsym(h, (const char*)name); +} +#endif /* __sgi || __sun */ + +#if defined(_WIN32) + +#ifdef _MSC_VER +#pragma warning(disable: 4055) +#pragma warning(disable: 4054) +#endif + +static int TestPointer(const PROC pTest) +{ + ptrdiff_t iTest; + if(!pTest) return 0; + iTest = (ptrdiff_t)pTest; + + if(iTest == 1 || iTest == 2 || iTest == 3 || iTest == -1) return 0; + + return 1; +} + +static PROC WinGetProcAddress(const char *name) +{ + HMODULE glMod = NULL; + PROC pFunc = wglGetProcAddress((LPCSTR)name); + if(TestPointer(pFunc)) + { + return pFunc; + } + glMod = GetModuleHandleA("OpenGL32.dll"); + return (PROC)GetProcAddress(glMod, (LPCSTR)name); +} + +#define IntGetProcAddress(name) WinGetProcAddress(name) +#else + #if defined(__APPLE__) + #define IntGetProcAddress(name) AppleGLGetProcAddress(name) + #else + #if defined(__sgi) || defined(__sun) + #define IntGetProcAddress(name) SunGetProcAddress(name) + #else /* GLX */ + #include + + #define IntGetProcAddress(name) (*glXGetProcAddressARB)((const GLubyte*)name) + #endif + #endif +#endif + +namespace gl +{ + namespace exts + { + } + + // Extension: 1.1 + typedef void (CODEGEN_FUNCPTR *PFNCULLFACEPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNFRONTFACEPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNHINTPROC)(GLenum , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNLINEWIDTHPROC)(GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNPOINTSIZEPROC)(GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNPOLYGONMODEPROC)(GLenum , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNSCISSORPROC)(GLint , GLint , GLsizei , GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERFPROC)(GLenum , GLenum , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERFVPROC)(GLenum , GLenum , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIPROC)(GLenum , GLenum , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIVPROC)(GLenum , GLenum , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNTEXIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNTEXIMAGE2DPROC)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNDRAWBUFFERPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNCLEARPROC)(GLbitfield ); + typedef void (CODEGEN_FUNCPTR *PFNCLEARCOLORPROC)(GLfloat , GLfloat , GLfloat , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNCLEARSTENCILPROC)(GLint ); + typedef void (CODEGEN_FUNCPTR *PFNCLEARDEPTHPROC)(GLdouble ); + typedef void (CODEGEN_FUNCPTR *PFNSTENCILMASKPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNCOLORMASKPROC)(GLboolean , GLboolean , GLboolean , GLboolean ); + typedef void (CODEGEN_FUNCPTR *PFNDEPTHMASKPROC)(GLboolean ); + typedef void (CODEGEN_FUNCPTR *PFNDISABLEPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNENABLEPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNFINISHPROC)(); + typedef void (CODEGEN_FUNCPTR *PFNFLUSHPROC)(); + typedef void (CODEGEN_FUNCPTR *PFNBLENDFUNCPROC)(GLenum , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNLOGICOPPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNSTENCILFUNCPROC)(GLenum , GLint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNSTENCILOPPROC)(GLenum , GLenum , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNDEPTHFUNCPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNPIXELSTOREFPROC)(GLenum , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNPIXELSTOREIPROC)(GLenum , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNREADBUFFERPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNREADPIXELSPROC)(GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNGETBOOLEANVPROC)(GLenum , GLboolean *); + typedef void (CODEGEN_FUNCPTR *PFNGETDOUBLEVPROC)(GLenum , GLdouble *); + typedef GLenum (CODEGEN_FUNCPTR *PFNGETERRORPROC)(); + typedef void (CODEGEN_FUNCPTR *PFNGETFLOATVPROC)(GLenum , GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNGETINTEGERVPROC)(GLenum , GLint *); + typedef const GLubyte * (CODEGEN_FUNCPTR *PFNGETSTRINGPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNGETTEXIMAGEPROC)(GLenum , GLint , GLenum , GLenum , GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERFVPROC)(GLenum , GLenum , GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERIVPROC)(GLenum , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETTEXLEVELPARAMETERFVPROC)(GLenum , GLint , GLenum , GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNGETTEXLEVELPARAMETERIVPROC)(GLenum , GLint , GLenum , GLint *); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISENABLEDPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNDEPTHRANGEPROC)(GLdouble , GLdouble ); + typedef void (CODEGEN_FUNCPTR *PFNVIEWPORTPROC)(GLint , GLint , GLsizei , GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNDRAWARRAYSPROC)(GLenum , GLint , GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNDRAWELEMENTSPROC)(GLenum , GLsizei , GLenum , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNGETPOINTERVPROC)(GLenum , GLvoid* *); + typedef void (CODEGEN_FUNCPTR *PFNPOLYGONOFFSETPROC)(GLfloat , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXIMAGE1DPROC)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXIMAGE2DPROC)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLsizei , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLint , GLint , GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNBINDTEXTUREPROC)(GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDELETETEXTURESPROC)(GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNGENTEXTURESPROC)(GLsizei , GLuint *); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISTEXTUREPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNINDEXUBPROC)(GLubyte ); + typedef void (CODEGEN_FUNCPTR *PFNINDEXUBVPROC)(const GLubyte *); + + // Extension: 1.2 + typedef void (CODEGEN_FUNCPTR *PFNBLENDCOLORPROC)(GLfloat , GLfloat , GLfloat , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNBLENDEQUATIONPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNDRAWRANGEELEMENTSPROC)(GLenum , GLuint , GLuint , GLsizei , GLenum , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNTEXSUBIMAGE3DPROC)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNCOPYTEXSUBIMAGE3DPROC)(GLenum , GLint , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei ); + + // Extension: 1.3 + typedef void (CODEGEN_FUNCPTR *PFNACTIVETEXTUREPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNSAMPLECOVERAGEPROC)(GLfloat , GLboolean ); + typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXIMAGE3DPROC)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXIMAGE2DPROC)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXIMAGE1DPROC)(GLenum , GLint , GLenum , GLsizei , GLint , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum , GLint , GLint , GLsizei , GLenum , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNGETCOMPRESSEDTEXIMAGEPROC)(GLenum , GLint , GLvoid *); + + // Extension: 1.4 + typedef void (CODEGEN_FUNCPTR *PFNBLENDFUNCSEPARATEPROC)(GLenum , GLenum , GLenum , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNMULTIDRAWARRAYSPROC)(GLenum , const GLint *, const GLsizei *, GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNMULTIDRAWELEMENTSPROC)(GLenum , const GLsizei *, GLenum , const GLvoid* const *, GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERFPROC)(GLenum , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERFVPROC)(GLenum , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERIPROC)(GLenum , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNPOINTPARAMETERIVPROC)(GLenum , const GLint *); + + // Extension: 1.5 + typedef void (CODEGEN_FUNCPTR *PFNGENQUERIESPROC)(GLsizei , GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNDELETEQUERIESPROC)(GLsizei , const GLuint *); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISQUERYPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNBEGINQUERYPROC)(GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNENDQUERYPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNGETQUERYIVPROC)(GLenum , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETQUERYOBJECTIVPROC)(GLuint , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETQUERYOBJECTUIVPROC)(GLuint , GLenum , GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNBINDBUFFERPROC)(GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDELETEBUFFERSPROC)(GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNGENBUFFERSPROC)(GLsizei , GLuint *); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISBUFFERPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNBUFFERDATAPROC)(GLenum , GLsizeiptr , const GLvoid *, GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNBUFFERSUBDATAPROC)(GLenum , GLintptr , GLsizeiptr , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNGETBUFFERSUBDATAPROC)(GLenum , GLintptr , GLsizeiptr , GLvoid *); + typedef GLvoid* (CODEGEN_FUNCPTR *PFNMAPBUFFERPROC)(GLenum , GLenum ); + typedef GLboolean (CODEGEN_FUNCPTR *PFNUNMAPBUFFERPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNGETBUFFERPARAMETERIVPROC)(GLenum , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETBUFFERPOINTERVPROC)(GLenum , GLenum , GLvoid* *); + + // Extension: 2.0 + typedef void (CODEGEN_FUNCPTR *PFNBLENDEQUATIONSEPARATEPROC)(GLenum , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNDRAWBUFFERSPROC)(GLsizei , const GLenum *); + typedef void (CODEGEN_FUNCPTR *PFNSTENCILOPSEPARATEPROC)(GLenum , GLenum , GLenum , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNSTENCILFUNCSEPARATEPROC)(GLenum , GLenum , GLint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNSTENCILMASKSEPARATEPROC)(GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNATTACHSHADERPROC)(GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNBINDATTRIBLOCATIONPROC)(GLuint , GLuint , const GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNCOMPILESHADERPROC)(GLuint ); + typedef GLuint (CODEGEN_FUNCPTR *PFNCREATEPROGRAMPROC)(); + typedef GLuint (CODEGEN_FUNCPTR *PFNCREATESHADERPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNDELETEPROGRAMPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDELETESHADERPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDETACHSHADERPROC)(GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDISABLEVERTEXATTRIBARRAYPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNENABLEVERTEXATTRIBARRAYPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEATTRIBPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLint *, GLenum *, GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLint *, GLenum *, GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNGETATTACHEDSHADERSPROC)(GLuint , GLsizei , GLsizei *, GLuint *); + typedef GLint (CODEGEN_FUNCPTR *PFNGETATTRIBLOCATIONPROC)(GLuint , const GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNGETPROGRAMIVPROC)(GLuint , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETPROGRAMINFOLOGPROC)(GLuint , GLsizei , GLsizei *, GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNGETSHADERIVPROC)(GLuint , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETSHADERINFOLOGPROC)(GLuint , GLsizei , GLsizei *, GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNGETSHADERSOURCEPROC)(GLuint , GLsizei , GLsizei *, GLchar *); + typedef GLint (CODEGEN_FUNCPTR *PFNGETUNIFORMLOCATIONPROC)(GLuint , const GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMFVPROC)(GLuint , GLint , GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMIVPROC)(GLuint , GLint , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBDVPROC)(GLuint , GLenum , GLdouble *); + typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBFVPROC)(GLuint , GLenum , GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBIVPROC)(GLuint , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBPOINTERVPROC)(GLuint , GLenum , GLvoid* *); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISPROGRAMPROC)(GLuint ); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISSHADERPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNLINKPROGRAMPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNSHADERSOURCEPROC)(GLuint , GLsizei , const GLchar* const *, const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNUSEPROGRAMPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1FPROC)(GLint , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2FPROC)(GLint , GLfloat , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3FPROC)(GLint , GLfloat , GLfloat , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4FPROC)(GLint , GLfloat , GLfloat , GLfloat , GLfloat ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1IPROC)(GLint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2IPROC)(GLint , GLint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3IPROC)(GLint , GLint , GLint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4IPROC)(GLint , GLint , GLint , GLint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1FVPROC)(GLint , GLsizei , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2FVPROC)(GLint , GLsizei , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3FVPROC)(GLint , GLsizei , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4FVPROC)(GLint , GLsizei , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1IVPROC)(GLint , GLsizei , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2IVPROC)(GLint , GLsizei , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3IVPROC)(GLint , GLsizei , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4IVPROC)(GLint , GLsizei , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX2FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX3FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX4FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNVALIDATEPROGRAMPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBPOINTERPROC)(GLuint , GLint , GLenum , GLboolean , GLsizei , const GLvoid *); + + // Extension: 2.1 + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX2X3FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX3X2FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX2X4FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX4X2FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX3X4FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMMATRIX4X3FVPROC)(GLint , GLsizei , GLboolean , const GLfloat *); + + // Extension: ARB_vertex_array_object + typedef void (CODEGEN_FUNCPTR *PFNBINDVERTEXARRAYPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDELETEVERTEXARRAYSPROC)(GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNGENVERTEXARRAYSPROC)(GLsizei , GLuint *); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISVERTEXARRAYPROC)(GLuint ); + + // Extension: ARB_map_buffer_range + typedef GLvoid* (CODEGEN_FUNCPTR *PFNMAPBUFFERRANGEPROC)(GLenum , GLintptr , GLsizeiptr , GLbitfield ); + typedef void (CODEGEN_FUNCPTR *PFNFLUSHMAPPEDBUFFERRANGEPROC)(GLenum , GLintptr , GLsizeiptr ); + + // Extension: ARB_framebuffer_object + typedef GLboolean (CODEGEN_FUNCPTR *PFNISRENDERBUFFERPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNBINDRENDERBUFFERPROC)(GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDELETERENDERBUFFERSPROC)(GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNGENRENDERBUFFERSPROC)(GLsizei , GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNRENDERBUFFERSTORAGEPROC)(GLenum , GLenum , GLsizei , GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNGETRENDERBUFFERPARAMETERIVPROC)(GLenum , GLenum , GLint *); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISFRAMEBUFFERPROC)(GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNBINDFRAMEBUFFERPROC)(GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDELETEFRAMEBUFFERSPROC)(GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNGENFRAMEBUFFERSPROC)(GLsizei , GLuint *); + typedef GLenum (CODEGEN_FUNCPTR *PFNCHECKFRAMEBUFFERSTATUSPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURE1DPROC)(GLenum , GLenum , GLenum , GLuint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURE2DPROC)(GLenum , GLenum , GLenum , GLuint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURE3DPROC)(GLenum , GLenum , GLenum , GLuint , GLint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERRENDERBUFFERPROC)(GLenum , GLenum , GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum , GLenum , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGENERATEMIPMAPPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNBLITFRAMEBUFFERPROC)(GLint , GLint , GLint , GLint , GLint , GLint , GLint , GLint , GLbitfield , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum , GLsizei , GLenum , GLsizei , GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNFRAMEBUFFERTEXTURELAYERPROC)(GLenum , GLenum , GLuint , GLint , GLint ); + + // Extension: 3.0 + typedef void (CODEGEN_FUNCPTR *PFNCOLORMASKIPROC)(GLuint , GLboolean , GLboolean , GLboolean , GLboolean ); + typedef void (CODEGEN_FUNCPTR *PFNGETBOOLEANI_VPROC)(GLenum , GLuint , GLboolean *); + typedef void (CODEGEN_FUNCPTR *PFNGETINTEGERI_VPROC)(GLenum , GLuint , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNENABLEIPROC)(GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNDISABLEIPROC)(GLenum , GLuint ); + typedef GLboolean (CODEGEN_FUNCPTR *PFNISENABLEDIPROC)(GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNBEGINTRANSFORMFEEDBACKPROC)(GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNENDTRANSFORMFEEDBACKPROC)(); + typedef void (CODEGEN_FUNCPTR *PFNBINDBUFFERRANGEPROC)(GLenum , GLuint , GLuint , GLintptr , GLsizeiptr ); + typedef void (CODEGEN_FUNCPTR *PFNBINDBUFFERBASEPROC)(GLenum , GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNTRANSFORMFEEDBACKVARYINGSPROC)(GLuint , GLsizei , const GLchar* const *, GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLsizei *, GLenum *, GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNCLAMPCOLORPROC)(GLenum , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNBEGINCONDITIONALRENDERPROC)(GLuint , GLenum ); + typedef void (CODEGEN_FUNCPTR *PFNENDCONDITIONALRENDERPROC)(); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBIPOINTERPROC)(GLuint , GLint , GLenum , GLsizei , const GLvoid *); + typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBIIVPROC)(GLuint , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETVERTEXATTRIBIUIVPROC)(GLuint , GLenum , GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1IPROC)(GLuint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2IPROC)(GLuint , GLint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3IPROC)(GLuint , GLint , GLint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4IPROC)(GLuint , GLint , GLint , GLint , GLint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1UIPROC)(GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2UIPROC)(GLuint , GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3UIPROC)(GLuint , GLuint , GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4UIPROC)(GLuint , GLuint , GLuint , GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1IVPROC)(GLuint , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2IVPROC)(GLuint , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3IVPROC)(GLuint , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4IVPROC)(GLuint , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI1UIVPROC)(GLuint , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI2UIVPROC)(GLuint , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI3UIVPROC)(GLuint , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4UIVPROC)(GLuint , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4BVPROC)(GLuint , const GLbyte *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4SVPROC)(GLuint , const GLshort *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4UBVPROC)(GLuint , const GLubyte *); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXATTRIBI4USVPROC)(GLuint , const GLushort *); + typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMUIVPROC)(GLuint , GLint , GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNBINDFRAGDATALOCATIONPROC)(GLuint , GLuint , const GLchar *); + typedef GLint (CODEGEN_FUNCPTR *PFNGETFRAGDATALOCATIONPROC)(GLuint , const GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1UIPROC)(GLint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2UIPROC)(GLint , GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3UIPROC)(GLint , GLuint , GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4UIPROC)(GLint , GLuint , GLuint , GLuint , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM1UIVPROC)(GLint , GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM2UIVPROC)(GLint , GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM3UIVPROC)(GLint , GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORM4UIVPROC)(GLint , GLsizei , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIIVPROC)(GLenum , GLenum , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNTEXPARAMETERIUIVPROC)(GLenum , GLenum , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERIIVPROC)(GLenum , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETTEXPARAMETERIUIVPROC)(GLenum , GLenum , GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERIVPROC)(GLenum , GLint , const GLint *); + typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERUIVPROC)(GLenum , GLint , const GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERFVPROC)(GLenum , GLint , const GLfloat *); + typedef void (CODEGEN_FUNCPTR *PFNCLEARBUFFERFIPROC)(GLenum , GLint , GLfloat , GLint ); + typedef const GLubyte * (CODEGEN_FUNCPTR *PFNGETSTRINGIPROC)(GLenum , GLuint ); + + // Extension: ARB_uniform_buffer_object + typedef void (CODEGEN_FUNCPTR *PFNGETUNIFORMINDICESPROC)(GLuint , GLsizei , const GLchar* const *, GLuint *); + typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMSIVPROC)(GLuint , GLsizei , const GLuint *, GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMNAMEPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLchar *); + typedef GLuint (CODEGEN_FUNCPTR *PFNGETUNIFORMBLOCKINDEXPROC)(GLuint , const GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMBLOCKIVPROC)(GLuint , GLuint , GLenum , GLint *); + typedef void (CODEGEN_FUNCPTR *PFNGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint , GLuint , GLsizei , GLsizei *, GLchar *); + typedef void (CODEGEN_FUNCPTR *PFNUNIFORMBLOCKBINDINGPROC)(GLuint , GLuint , GLuint ); + + // Extension: ARB_copy_buffer + typedef void (CODEGEN_FUNCPTR *PFNCOPYBUFFERSUBDATAPROC)(GLenum , GLenum , GLintptr , GLintptr , GLsizeiptr ); + + // Extension: 3.1 + typedef void (CODEGEN_FUNCPTR *PFNDRAWARRAYSINSTANCEDPROC)(GLenum , GLint , GLsizei , GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNDRAWELEMENTSINSTANCEDPROC)(GLenum , GLsizei , GLenum , const GLvoid *, GLsizei ); + typedef void (CODEGEN_FUNCPTR *PFNTEXBUFFERPROC)(GLenum , GLenum , GLuint ); + typedef void (CODEGEN_FUNCPTR *PFNPRIMITIVERESTARTINDEXPROC)(GLuint ); + + // Legacy + typedef void (CODEGEN_FUNCPTR *PFNENABLECLIENTSTATEPROC)(GLenum cap); + typedef void (CODEGEN_FUNCPTR *PFNDISABLECLIENTSTATEPROC)(GLenum cap); + typedef void (CODEGEN_FUNCPTR *PFNVERTEXPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr); + typedef void (CODEGEN_FUNCPTR *PFNNORMALPOINTERPROC)(GLenum type, GLsizei stride, const GLvoid *ptr); + typedef void (CODEGEN_FUNCPTR *PFNCOLORPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr); + typedef void (CODEGEN_FUNCPTR *PFNTEXCOORDPOINTERPROC)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr); + + typedef void (CODEGEN_FUNCPTR *PFNTEXENVIPROC)(GLenum target, GLenum pname, GLint param); + + typedef void (CODEGEN_FUNCPTR *PFNMATRIXMODEPROC)(GLenum modem); + typedef void (CODEGEN_FUNCPTR *PFNLOADIDENTITYPROC)(void); + typedef void (CODEGEN_FUNCPTR *PFNORTHOPROC)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val); + + typedef void (CODEGEN_FUNCPTR *PFNCOLOR3DPROC)(GLdouble red, GLdouble green, GLdouble blue); + + + + // Extension: 1.1 + PFNCULLFACEPROC CullFace; + PFNFRONTFACEPROC FrontFace; + PFNHINTPROC Hint; + PFNLINEWIDTHPROC LineWidth; + PFNPOINTSIZEPROC PointSize; + PFNPOLYGONMODEPROC PolygonMode; + PFNSCISSORPROC Scissor; + PFNTEXPARAMETERFPROC TexParameterf; + PFNTEXPARAMETERFVPROC TexParameterfv; + PFNTEXPARAMETERIPROC TexParameteri; + PFNTEXPARAMETERIVPROC TexParameteriv; + PFNTEXIMAGE1DPROC TexImage1D; + PFNTEXIMAGE2DPROC TexImage2D; + PFNDRAWBUFFERPROC DrawBuffer; + PFNCLEARPROC Clear; + PFNCLEARCOLORPROC ClearColor; + PFNCLEARSTENCILPROC ClearStencil; + PFNCLEARDEPTHPROC ClearDepth; + PFNSTENCILMASKPROC StencilMask; + PFNCOLORMASKPROC ColorMask; + PFNDEPTHMASKPROC DepthMask; + PFNDISABLEPROC Disable; + PFNENABLEPROC Enable; + PFNFINISHPROC Finish; + PFNFLUSHPROC Flush; + PFNBLENDFUNCPROC BlendFunc; + PFNLOGICOPPROC LogicOp; + PFNSTENCILFUNCPROC StencilFunc; + PFNSTENCILOPPROC StencilOp; + PFNDEPTHFUNCPROC DepthFunc; + PFNPIXELSTOREFPROC PixelStoref; + PFNPIXELSTOREIPROC PixelStorei; + PFNREADBUFFERPROC ReadBuffer; + PFNREADPIXELSPROC ReadPixels; + PFNGETBOOLEANVPROC GetBooleanv; + PFNGETDOUBLEVPROC GetDoublev; + PFNGETERRORPROC GetError; + PFNGETFLOATVPROC GetFloatv; + PFNGETINTEGERVPROC GetIntegerv; + PFNGETSTRINGPROC GetString; + PFNGETTEXIMAGEPROC GetTexImage; + PFNGETTEXPARAMETERFVPROC GetTexParameterfv; + PFNGETTEXPARAMETERIVPROC GetTexParameteriv; + PFNGETTEXLEVELPARAMETERFVPROC GetTexLevelParameterfv; + PFNGETTEXLEVELPARAMETERIVPROC GetTexLevelParameteriv; + PFNISENABLEDPROC IsEnabled; + PFNDEPTHRANGEPROC DepthRange; + PFNVIEWPORTPROC Viewport; + PFNDRAWARRAYSPROC DrawArrays; + PFNDRAWELEMENTSPROC DrawElements; + PFNGETPOINTERVPROC GetPointerv; + PFNPOLYGONOFFSETPROC PolygonOffset; + PFNCOPYTEXIMAGE1DPROC CopyTexImage1D; + PFNCOPYTEXIMAGE2DPROC CopyTexImage2D; + PFNCOPYTEXSUBIMAGE1DPROC CopyTexSubImage1D; + PFNCOPYTEXSUBIMAGE2DPROC CopyTexSubImage2D; + PFNTEXSUBIMAGE1DPROC TexSubImage1D; + PFNTEXSUBIMAGE2DPROC TexSubImage2D; + PFNBINDTEXTUREPROC BindTexture; + PFNDELETETEXTURESPROC DeleteTextures; + PFNGENTEXTURESPROC GenTextures; + PFNISTEXTUREPROC IsTexture; + PFNINDEXUBPROC Indexub; + PFNINDEXUBVPROC Indexubv; + + // Extension: 1.2 + PFNBLENDCOLORPROC BlendColor; + PFNBLENDEQUATIONPROC BlendEquation; + PFNDRAWRANGEELEMENTSPROC DrawRangeElements; + PFNTEXSUBIMAGE3DPROC TexSubImage3D; + PFNCOPYTEXSUBIMAGE3DPROC CopyTexSubImage3D; + + // Extension: 1.3 + PFNACTIVETEXTUREPROC ActiveTexture; + PFNSAMPLECOVERAGEPROC SampleCoverage; + PFNCOMPRESSEDTEXIMAGE3DPROC CompressedTexImage3D; + PFNCOMPRESSEDTEXIMAGE2DPROC CompressedTexImage2D; + PFNCOMPRESSEDTEXIMAGE1DPROC CompressedTexImage1D; + PFNCOMPRESSEDTEXSUBIMAGE3DPROC CompressedTexSubImage3D; + PFNCOMPRESSEDTEXSUBIMAGE2DPROC CompressedTexSubImage2D; + PFNCOMPRESSEDTEXSUBIMAGE1DPROC CompressedTexSubImage1D; + PFNGETCOMPRESSEDTEXIMAGEPROC GetCompressedTexImage; + + // Extension: 1.4 + PFNBLENDFUNCSEPARATEPROC BlendFuncSeparate; + PFNMULTIDRAWARRAYSPROC MultiDrawArrays; + PFNMULTIDRAWELEMENTSPROC MultiDrawElements; + PFNPOINTPARAMETERFPROC PointParameterf; + PFNPOINTPARAMETERFVPROC PointParameterfv; + PFNPOINTPARAMETERIPROC PointParameteri; + PFNPOINTPARAMETERIVPROC PointParameteriv; + + // Extension: 1.5 + PFNGENQUERIESPROC GenQueries; + PFNDELETEQUERIESPROC DeleteQueries; + PFNISQUERYPROC IsQuery; + PFNBEGINQUERYPROC BeginQuery; + PFNENDQUERYPROC EndQuery; + PFNGETQUERYIVPROC GetQueryiv; + PFNGETQUERYOBJECTIVPROC GetQueryObjectiv; + PFNGETQUERYOBJECTUIVPROC GetQueryObjectuiv; + PFNBINDBUFFERPROC BindBuffer; + PFNDELETEBUFFERSPROC DeleteBuffers; + PFNGENBUFFERSPROC GenBuffers; + PFNISBUFFERPROC IsBuffer; + PFNBUFFERDATAPROC BufferData; + PFNBUFFERSUBDATAPROC BufferSubData; + PFNGETBUFFERSUBDATAPROC GetBufferSubData; + PFNMAPBUFFERPROC MapBuffer; + PFNUNMAPBUFFERPROC UnmapBuffer; + PFNGETBUFFERPARAMETERIVPROC GetBufferParameteriv; + PFNGETBUFFERPOINTERVPROC GetBufferPointerv; + + // Extension: 2.0 + PFNBLENDEQUATIONSEPARATEPROC BlendEquationSeparate; + PFNDRAWBUFFERSPROC DrawBuffers; + PFNSTENCILOPSEPARATEPROC StencilOpSeparate; + PFNSTENCILFUNCSEPARATEPROC StencilFuncSeparate; + PFNSTENCILMASKSEPARATEPROC StencilMaskSeparate; + PFNATTACHSHADERPROC AttachShader; + PFNBINDATTRIBLOCATIONPROC BindAttribLocation; + PFNCOMPILESHADERPROC CompileShader; + PFNCREATEPROGRAMPROC CreateProgram; + PFNCREATESHADERPROC CreateShader; + PFNDELETEPROGRAMPROC DeleteProgram; + PFNDELETESHADERPROC DeleteShader; + PFNDETACHSHADERPROC DetachShader; + PFNDISABLEVERTEXATTRIBARRAYPROC DisableVertexAttribArray; + PFNENABLEVERTEXATTRIBARRAYPROC EnableVertexAttribArray; + PFNGETACTIVEATTRIBPROC GetActiveAttrib; + PFNGETACTIVEUNIFORMPROC GetActiveUniform; + PFNGETATTACHEDSHADERSPROC GetAttachedShaders; + PFNGETATTRIBLOCATIONPROC GetAttribLocation; + PFNGETPROGRAMIVPROC GetProgramiv; + PFNGETPROGRAMINFOLOGPROC GetProgramInfoLog; + PFNGETSHADERIVPROC GetShaderiv; + PFNGETSHADERINFOLOGPROC GetShaderInfoLog; + PFNGETSHADERSOURCEPROC GetShaderSource; + PFNGETUNIFORMLOCATIONPROC GetUniformLocation; + PFNGETUNIFORMFVPROC GetUniformfv; + PFNGETUNIFORMIVPROC GetUniformiv; + PFNGETVERTEXATTRIBDVPROC GetVertexAttribdv; + PFNGETVERTEXATTRIBFVPROC GetVertexAttribfv; + PFNGETVERTEXATTRIBIVPROC GetVertexAttribiv; + PFNGETVERTEXATTRIBPOINTERVPROC GetVertexAttribPointerv; + PFNISPROGRAMPROC IsProgram; + PFNISSHADERPROC IsShader; + PFNLINKPROGRAMPROC LinkProgram; + PFNSHADERSOURCEPROC ShaderSource; + PFNUSEPROGRAMPROC UseProgram; + PFNUNIFORM1FPROC Uniform1f; + PFNUNIFORM2FPROC Uniform2f; + PFNUNIFORM3FPROC Uniform3f; + PFNUNIFORM4FPROC Uniform4f; + PFNUNIFORM1IPROC Uniform1i; + PFNUNIFORM2IPROC Uniform2i; + PFNUNIFORM3IPROC Uniform3i; + PFNUNIFORM4IPROC Uniform4i; + PFNUNIFORM1FVPROC Uniform1fv; + PFNUNIFORM2FVPROC Uniform2fv; + PFNUNIFORM3FVPROC Uniform3fv; + PFNUNIFORM4FVPROC Uniform4fv; + PFNUNIFORM1IVPROC Uniform1iv; + PFNUNIFORM2IVPROC Uniform2iv; + PFNUNIFORM3IVPROC Uniform3iv; + PFNUNIFORM4IVPROC Uniform4iv; + PFNUNIFORMMATRIX2FVPROC UniformMatrix2fv; + PFNUNIFORMMATRIX3FVPROC UniformMatrix3fv; + PFNUNIFORMMATRIX4FVPROC UniformMatrix4fv; + PFNVALIDATEPROGRAMPROC ValidateProgram; + PFNVERTEXATTRIBPOINTERPROC VertexAttribPointer; + + // Extension: 2.1 + PFNUNIFORMMATRIX2X3FVPROC UniformMatrix2x3fv; + PFNUNIFORMMATRIX3X2FVPROC UniformMatrix3x2fv; + PFNUNIFORMMATRIX2X4FVPROC UniformMatrix2x4fv; + PFNUNIFORMMATRIX4X2FVPROC UniformMatrix4x2fv; + PFNUNIFORMMATRIX3X4FVPROC UniformMatrix3x4fv; + PFNUNIFORMMATRIX4X3FVPROC UniformMatrix4x3fv; + + // Extension: ARB_vertex_array_object + PFNBINDVERTEXARRAYPROC BindVertexArray; + PFNDELETEVERTEXARRAYSPROC DeleteVertexArrays; + PFNGENVERTEXARRAYSPROC GenVertexArrays; + PFNISVERTEXARRAYPROC IsVertexArray; + + // Extension: ARB_map_buffer_range + PFNMAPBUFFERRANGEPROC MapBufferRange; + PFNFLUSHMAPPEDBUFFERRANGEPROC FlushMappedBufferRange; + + // Extension: ARB_framebuffer_object + PFNISRENDERBUFFERPROC IsRenderbuffer; + PFNBINDRENDERBUFFERPROC BindRenderbuffer; + PFNDELETERENDERBUFFERSPROC DeleteRenderbuffers; + PFNGENRENDERBUFFERSPROC GenRenderbuffers; + PFNRENDERBUFFERSTORAGEPROC RenderbufferStorage; + PFNGETRENDERBUFFERPARAMETERIVPROC GetRenderbufferParameteriv; + PFNISFRAMEBUFFERPROC IsFramebuffer; + PFNBINDFRAMEBUFFERPROC BindFramebuffer; + PFNDELETEFRAMEBUFFERSPROC DeleteFramebuffers; + PFNGENFRAMEBUFFERSPROC GenFramebuffers; + PFNCHECKFRAMEBUFFERSTATUSPROC CheckFramebufferStatus; + PFNFRAMEBUFFERTEXTURE1DPROC FramebufferTexture1D; + PFNFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D; + PFNFRAMEBUFFERTEXTURE3DPROC FramebufferTexture3D; + PFNFRAMEBUFFERRENDERBUFFERPROC FramebufferRenderbuffer; + PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC GetFramebufferAttachmentParameteriv; + PFNGENERATEMIPMAPPROC GenerateMipmap; + PFNBLITFRAMEBUFFERPROC BlitFramebuffer; + PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC RenderbufferStorageMultisample; + PFNFRAMEBUFFERTEXTURELAYERPROC FramebufferTextureLayer; + + // Extension: 3.0 + PFNCOLORMASKIPROC ColorMaski; + PFNGETBOOLEANI_VPROC GetBooleani_v; + PFNGETINTEGERI_VPROC GetIntegeri_v; + PFNENABLEIPROC Enablei; + PFNDISABLEIPROC Disablei; + PFNISENABLEDIPROC IsEnabledi; + PFNBEGINTRANSFORMFEEDBACKPROC BeginTransformFeedback; + PFNENDTRANSFORMFEEDBACKPROC EndTransformFeedback; + PFNBINDBUFFERRANGEPROC BindBufferRange; + PFNBINDBUFFERBASEPROC BindBufferBase; + PFNTRANSFORMFEEDBACKVARYINGSPROC TransformFeedbackVaryings; + PFNGETTRANSFORMFEEDBACKVARYINGPROC GetTransformFeedbackVarying; + PFNCLAMPCOLORPROC ClampColor; + PFNBEGINCONDITIONALRENDERPROC BeginConditionalRender; + PFNENDCONDITIONALRENDERPROC EndConditionalRender; + PFNVERTEXATTRIBIPOINTERPROC VertexAttribIPointer; + PFNGETVERTEXATTRIBIIVPROC GetVertexAttribIiv; + PFNGETVERTEXATTRIBIUIVPROC GetVertexAttribIuiv; + PFNVERTEXATTRIBI1IPROC VertexAttribI1i; + PFNVERTEXATTRIBI2IPROC VertexAttribI2i; + PFNVERTEXATTRIBI3IPROC VertexAttribI3i; + PFNVERTEXATTRIBI4IPROC VertexAttribI4i; + PFNVERTEXATTRIBI1UIPROC VertexAttribI1ui; + PFNVERTEXATTRIBI2UIPROC VertexAttribI2ui; + PFNVERTEXATTRIBI3UIPROC VertexAttribI3ui; + PFNVERTEXATTRIBI4UIPROC VertexAttribI4ui; + PFNVERTEXATTRIBI1IVPROC VertexAttribI1iv; + PFNVERTEXATTRIBI2IVPROC VertexAttribI2iv; + PFNVERTEXATTRIBI3IVPROC VertexAttribI3iv; + PFNVERTEXATTRIBI4IVPROC VertexAttribI4iv; + PFNVERTEXATTRIBI1UIVPROC VertexAttribI1uiv; + PFNVERTEXATTRIBI2UIVPROC VertexAttribI2uiv; + PFNVERTEXATTRIBI3UIVPROC VertexAttribI3uiv; + PFNVERTEXATTRIBI4UIVPROC VertexAttribI4uiv; + PFNVERTEXATTRIBI4BVPROC VertexAttribI4bv; + PFNVERTEXATTRIBI4SVPROC VertexAttribI4sv; + PFNVERTEXATTRIBI4UBVPROC VertexAttribI4ubv; + PFNVERTEXATTRIBI4USVPROC VertexAttribI4usv; + PFNGETUNIFORMUIVPROC GetUniformuiv; + PFNBINDFRAGDATALOCATIONPROC BindFragDataLocation; + PFNGETFRAGDATALOCATIONPROC GetFragDataLocation; + PFNUNIFORM1UIPROC Uniform1ui; + PFNUNIFORM2UIPROC Uniform2ui; + PFNUNIFORM3UIPROC Uniform3ui; + PFNUNIFORM4UIPROC Uniform4ui; + PFNUNIFORM1UIVPROC Uniform1uiv; + PFNUNIFORM2UIVPROC Uniform2uiv; + PFNUNIFORM3UIVPROC Uniform3uiv; + PFNUNIFORM4UIVPROC Uniform4uiv; + PFNTEXPARAMETERIIVPROC TexParameterIiv; + PFNTEXPARAMETERIUIVPROC TexParameterIuiv; + PFNGETTEXPARAMETERIIVPROC GetTexParameterIiv; + PFNGETTEXPARAMETERIUIVPROC GetTexParameterIuiv; + PFNCLEARBUFFERIVPROC ClearBufferiv; + PFNCLEARBUFFERUIVPROC ClearBufferuiv; + PFNCLEARBUFFERFVPROC ClearBufferfv; + PFNCLEARBUFFERFIPROC ClearBufferfi; + PFNGETSTRINGIPROC GetStringi; + + // Extension: ARB_uniform_buffer_object + PFNGETUNIFORMINDICESPROC GetUniformIndices; + PFNGETACTIVEUNIFORMSIVPROC GetActiveUniformsiv; + PFNGETACTIVEUNIFORMNAMEPROC GetActiveUniformName; + PFNGETUNIFORMBLOCKINDEXPROC GetUniformBlockIndex; + PFNGETACTIVEUNIFORMBLOCKIVPROC GetActiveUniformBlockiv; + PFNGETACTIVEUNIFORMBLOCKNAMEPROC GetActiveUniformBlockName; + PFNUNIFORMBLOCKBINDINGPROC UniformBlockBinding; + + // Extension: ARB_copy_buffer + PFNCOPYBUFFERSUBDATAPROC CopyBufferSubData; + + // Extension: 3.1 + PFNDRAWARRAYSINSTANCEDPROC DrawArraysInstanced; + PFNDRAWELEMENTSINSTANCEDPROC DrawElementsInstanced; + PFNTEXBUFFERPROC TexBuffer; + PFNPRIMITIVERESTARTINDEXPROC PrimitiveRestartIndex; + + // Legacy + PFNENABLECLIENTSTATEPROC EnableClientState; + PFNDISABLECLIENTSTATEPROC DisableClientState; + PFNVERTEXPOINTERPROC VertexPointer; + PFNNORMALPOINTERPROC NormalPointer; + PFNCOLORPOINTERPROC ColorPointer; + PFNTEXCOORDPOINTERPROC TexCoordPointer; + + PFNTEXENVIPROC TexEnvi; + + PFNMATRIXMODEPROC MatrixMode; + PFNLOADIDENTITYPROC LoadIdentity; + PFNORTHOPROC Ortho; + + PFNCOLOR3DPROC Color3d; + + + // Extension: 1.1 + static void CODEGEN_FUNCPTR Switch_CullFace(GLenum mode) + { + CullFace = (PFNCULLFACEPROC)IntGetProcAddress("glCullFace"); + CullFace(mode); + } + + static void CODEGEN_FUNCPTR Switch_FrontFace(GLenum mode) + { + FrontFace = (PFNFRONTFACEPROC)IntGetProcAddress("glFrontFace"); + FrontFace(mode); + } + + static void CODEGEN_FUNCPTR Switch_Hint(GLenum target, GLenum mode) + { + Hint = (PFNHINTPROC)IntGetProcAddress("glHint"); + Hint(target, mode); + } + + static void CODEGEN_FUNCPTR Switch_LineWidth(GLfloat width) + { + LineWidth = (PFNLINEWIDTHPROC)IntGetProcAddress("glLineWidth"); + LineWidth(width); + } + + static void CODEGEN_FUNCPTR Switch_PointSize(GLfloat size) + { + PointSize = (PFNPOINTSIZEPROC)IntGetProcAddress("glPointSize"); + PointSize(size); + } + + static void CODEGEN_FUNCPTR Switch_PolygonMode(GLenum face, GLenum mode) + { + PolygonMode = (PFNPOLYGONMODEPROC)IntGetProcAddress("glPolygonMode"); + PolygonMode(face, mode); + } + + static void CODEGEN_FUNCPTR Switch_Scissor(GLint x, GLint y, GLsizei width, GLsizei height) + { + Scissor = (PFNSCISSORPROC)IntGetProcAddress("glScissor"); + Scissor(x, y, width, height); + } + + static void CODEGEN_FUNCPTR Switch_TexParameterf(GLenum target, GLenum pname, GLfloat param) + { + TexParameterf = (PFNTEXPARAMETERFPROC)IntGetProcAddress("glTexParameterf"); + TexParameterf(target, pname, param); + } + + static void CODEGEN_FUNCPTR Switch_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params) + { + TexParameterfv = (PFNTEXPARAMETERFVPROC)IntGetProcAddress("glTexParameterfv"); + TexParameterfv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_TexParameteri(GLenum target, GLenum pname, GLint param) + { + TexParameteri = (PFNTEXPARAMETERIPROC)IntGetProcAddress("glTexParameteri"); + TexParameteri(target, pname, param); + } + + static void CODEGEN_FUNCPTR Switch_TexParameteriv(GLenum target, GLenum pname, const GLint *params) + { + TexParameteriv = (PFNTEXPARAMETERIVPROC)IntGetProcAddress("glTexParameteriv"); + TexParameteriv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_TexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) + { + TexImage1D = (PFNTEXIMAGE1DPROC)IntGetProcAddress("glTexImage1D"); + TexImage1D(target, level, internalformat, width, border, format, type, pixels); + } + + static void CODEGEN_FUNCPTR Switch_TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) + { + TexImage2D = (PFNTEXIMAGE2DPROC)IntGetProcAddress("glTexImage2D"); + TexImage2D(target, level, internalformat, width, height, border, format, type, pixels); + } + + static void CODEGEN_FUNCPTR Switch_DrawBuffer(GLenum mode) + { + DrawBuffer = (PFNDRAWBUFFERPROC)IntGetProcAddress("glDrawBuffer"); + DrawBuffer(mode); + } + + static void CODEGEN_FUNCPTR Switch_Clear(GLbitfield mask) + { + Clear = (PFNCLEARPROC)IntGetProcAddress("glClear"); + Clear(mask); + } + + static void CODEGEN_FUNCPTR Switch_ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) + { + ClearColor = (PFNCLEARCOLORPROC)IntGetProcAddress("glClearColor"); + ClearColor(red, green, blue, alpha); + } + + static void CODEGEN_FUNCPTR Switch_ClearStencil(GLint s) + { + ClearStencil = (PFNCLEARSTENCILPROC)IntGetProcAddress("glClearStencil"); + ClearStencil(s); + } + + static void CODEGEN_FUNCPTR Switch_ClearDepth(GLdouble depth) + { + ClearDepth = (PFNCLEARDEPTHPROC)IntGetProcAddress("glClearDepth"); + ClearDepth(depth); + } + + static void CODEGEN_FUNCPTR Switch_StencilMask(GLuint mask) + { + StencilMask = (PFNSTENCILMASKPROC)IntGetProcAddress("glStencilMask"); + StencilMask(mask); + } + + static void CODEGEN_FUNCPTR Switch_ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) + { + ColorMask = (PFNCOLORMASKPROC)IntGetProcAddress("glColorMask"); + ColorMask(red, green, blue, alpha); + } + + static void CODEGEN_FUNCPTR Switch_DepthMask(GLboolean flag) + { + DepthMask = (PFNDEPTHMASKPROC)IntGetProcAddress("glDepthMask"); + DepthMask(flag); + } + + static void CODEGEN_FUNCPTR Switch_Disable(GLenum cap) + { + Disable = (PFNDISABLEPROC)IntGetProcAddress("glDisable"); + Disable(cap); + } + + static void CODEGEN_FUNCPTR Switch_Enable(GLenum cap) + { + Enable = (PFNENABLEPROC)IntGetProcAddress("glEnable"); + Enable(cap); + } + + static void CODEGEN_FUNCPTR Switch_Finish() + { + Finish = (PFNFINISHPROC)IntGetProcAddress("glFinish"); + Finish(); + } + + static void CODEGEN_FUNCPTR Switch_Flush() + { + Flush = (PFNFLUSHPROC)IntGetProcAddress("glFlush"); + Flush(); + } + + static void CODEGEN_FUNCPTR Switch_BlendFunc(GLenum sfactor, GLenum dfactor) + { + BlendFunc = (PFNBLENDFUNCPROC)IntGetProcAddress("glBlendFunc"); + BlendFunc(sfactor, dfactor); + } + + static void CODEGEN_FUNCPTR Switch_LogicOp(GLenum opcode) + { + LogicOp = (PFNLOGICOPPROC)IntGetProcAddress("glLogicOp"); + LogicOp(opcode); + } + + static void CODEGEN_FUNCPTR Switch_StencilFunc(GLenum func, GLint ref, GLuint mask) + { + StencilFunc = (PFNSTENCILFUNCPROC)IntGetProcAddress("glStencilFunc"); + StencilFunc(func, ref, mask); + } + + static void CODEGEN_FUNCPTR Switch_StencilOp(GLenum fail, GLenum zfail, GLenum zpass) + { + StencilOp = (PFNSTENCILOPPROC)IntGetProcAddress("glStencilOp"); + StencilOp(fail, zfail, zpass); + } + + static void CODEGEN_FUNCPTR Switch_DepthFunc(GLenum func) + { + DepthFunc = (PFNDEPTHFUNCPROC)IntGetProcAddress("glDepthFunc"); + DepthFunc(func); + } + + static void CODEGEN_FUNCPTR Switch_PixelStoref(GLenum pname, GLfloat param) + { + PixelStoref = (PFNPIXELSTOREFPROC)IntGetProcAddress("glPixelStoref"); + PixelStoref(pname, param); + } + + static void CODEGEN_FUNCPTR Switch_PixelStorei(GLenum pname, GLint param) + { + PixelStorei = (PFNPIXELSTOREIPROC)IntGetProcAddress("glPixelStorei"); + PixelStorei(pname, param); + } + + static void CODEGEN_FUNCPTR Switch_ReadBuffer(GLenum mode) + { + ReadBuffer = (PFNREADBUFFERPROC)IntGetProcAddress("glReadBuffer"); + ReadBuffer(mode); + } + + static void CODEGEN_FUNCPTR Switch_ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) + { + ReadPixels = (PFNREADPIXELSPROC)IntGetProcAddress("glReadPixels"); + ReadPixels(x, y, width, height, format, type, pixels); + } + + static void CODEGEN_FUNCPTR Switch_GetBooleanv(GLenum pname, GLboolean *params) + { + GetBooleanv = (PFNGETBOOLEANVPROC)IntGetProcAddress("glGetBooleanv"); + GetBooleanv(pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetDoublev(GLenum pname, GLdouble *params) + { + GetDoublev = (PFNGETDOUBLEVPROC)IntGetProcAddress("glGetDoublev"); + GetDoublev(pname, params); + } + + static GLenum CODEGEN_FUNCPTR Switch_GetError() + { + GetError = (PFNGETERRORPROC)IntGetProcAddress("glGetError"); + return GetError(); + } + + static void CODEGEN_FUNCPTR Switch_GetFloatv(GLenum pname, GLfloat *params) + { + GetFloatv = (PFNGETFLOATVPROC)IntGetProcAddress("glGetFloatv"); + GetFloatv(pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetIntegerv(GLenum pname, GLint *params) + { + GetIntegerv = (PFNGETINTEGERVPROC)IntGetProcAddress("glGetIntegerv"); + GetIntegerv(pname, params); + } + + static const GLubyte * CODEGEN_FUNCPTR Switch_GetString(GLenum name) + { + GetString = (PFNGETSTRINGPROC)IntGetProcAddress("glGetString"); + return GetString(name); + } + + static void CODEGEN_FUNCPTR Switch_GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) + { + GetTexImage = (PFNGETTEXIMAGEPROC)IntGetProcAddress("glGetTexImage"); + GetTexImage(target, level, format, type, pixels); + } + + static void CODEGEN_FUNCPTR Switch_GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) + { + GetTexParameterfv = (PFNGETTEXPARAMETERFVPROC)IntGetProcAddress("glGetTexParameterfv"); + GetTexParameterfv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetTexParameteriv(GLenum target, GLenum pname, GLint *params) + { + GetTexParameteriv = (PFNGETTEXPARAMETERIVPROC)IntGetProcAddress("glGetTexParameteriv"); + GetTexParameteriv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) + { + GetTexLevelParameterfv = (PFNGETTEXLEVELPARAMETERFVPROC)IntGetProcAddress("glGetTexLevelParameterfv"); + GetTexLevelParameterfv(target, level, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) + { + GetTexLevelParameteriv = (PFNGETTEXLEVELPARAMETERIVPROC)IntGetProcAddress("glGetTexLevelParameteriv"); + GetTexLevelParameteriv(target, level, pname, params); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsEnabled(GLenum cap) + { + IsEnabled = (PFNISENABLEDPROC)IntGetProcAddress("glIsEnabled"); + return IsEnabled(cap); + } + + static void CODEGEN_FUNCPTR Switch_DepthRange(GLdouble ren_near, GLdouble ren_far) + { + DepthRange = (PFNDEPTHRANGEPROC)IntGetProcAddress("glDepthRange"); + DepthRange(ren_near, ren_far); + } + + static void CODEGEN_FUNCPTR Switch_Viewport(GLint x, GLint y, GLsizei width, GLsizei height) + { + Viewport = (PFNVIEWPORTPROC)IntGetProcAddress("glViewport"); + Viewport(x, y, width, height); + } + + static void CODEGEN_FUNCPTR Switch_DrawArrays(GLenum mode, GLint first, GLsizei count) + { + DrawArrays = (PFNDRAWARRAYSPROC)IntGetProcAddress("glDrawArrays"); + DrawArrays(mode, first, count); + } + + static void CODEGEN_FUNCPTR Switch_DrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) + { + DrawElements = (PFNDRAWELEMENTSPROC)IntGetProcAddress("glDrawElements"); + DrawElements(mode, count, type, indices); + } + + static void CODEGEN_FUNCPTR Switch_GetPointerv(GLenum pname, GLvoid* *params) + { + GetPointerv = (PFNGETPOINTERVPROC)IntGetProcAddress("glGetPointerv"); + GetPointerv(pname, params); + } + + static void CODEGEN_FUNCPTR Switch_PolygonOffset(GLfloat factor, GLfloat units) + { + PolygonOffset = (PFNPOLYGONOFFSETPROC)IntGetProcAddress("glPolygonOffset"); + PolygonOffset(factor, units); + } + + static void CODEGEN_FUNCPTR Switch_CopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) + { + CopyTexImage1D = (PFNCOPYTEXIMAGE1DPROC)IntGetProcAddress("glCopyTexImage1D"); + CopyTexImage1D(target, level, internalformat, x, y, width, border); + } + + static void CODEGEN_FUNCPTR Switch_CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) + { + CopyTexImage2D = (PFNCOPYTEXIMAGE2DPROC)IntGetProcAddress("glCopyTexImage2D"); + CopyTexImage2D(target, level, internalformat, x, y, width, height, border); + } + + static void CODEGEN_FUNCPTR Switch_CopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) + { + CopyTexSubImage1D = (PFNCOPYTEXSUBIMAGE1DPROC)IntGetProcAddress("glCopyTexSubImage1D"); + CopyTexSubImage1D(target, level, xoffset, x, y, width); + } + + static void CODEGEN_FUNCPTR Switch_CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) + { + CopyTexSubImage2D = (PFNCOPYTEXSUBIMAGE2DPROC)IntGetProcAddress("glCopyTexSubImage2D"); + CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); + } + + static void CODEGEN_FUNCPTR Switch_TexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels) + { + TexSubImage1D = (PFNTEXSUBIMAGE1DPROC)IntGetProcAddress("glTexSubImage1D"); + TexSubImage1D(target, level, xoffset, width, format, type, pixels); + } + + static void CODEGEN_FUNCPTR Switch_TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) + { + TexSubImage2D = (PFNTEXSUBIMAGE2DPROC)IntGetProcAddress("glTexSubImage2D"); + TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); + } + + static void CODEGEN_FUNCPTR Switch_BindTexture(GLenum target, GLuint texture) + { + BindTexture = (PFNBINDTEXTUREPROC)IntGetProcAddress("glBindTexture"); + BindTexture(target, texture); + } + + static void CODEGEN_FUNCPTR Switch_DeleteTextures(GLsizei n, const GLuint *textures) + { + DeleteTextures = (PFNDELETETEXTURESPROC)IntGetProcAddress("glDeleteTextures"); + DeleteTextures(n, textures); + } + + static void CODEGEN_FUNCPTR Switch_GenTextures(GLsizei n, GLuint *textures) + { + GenTextures = (PFNGENTEXTURESPROC)IntGetProcAddress("glGenTextures"); + GenTextures(n, textures); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsTexture(GLuint texture) + { + IsTexture = (PFNISTEXTUREPROC)IntGetProcAddress("glIsTexture"); + return IsTexture(texture); + } + + static void CODEGEN_FUNCPTR Switch_Indexub(GLubyte c) + { + Indexub = (PFNINDEXUBPROC)IntGetProcAddress("glIndexub"); + Indexub(c); + } + + static void CODEGEN_FUNCPTR Switch_Indexubv(const GLubyte *c) + { + Indexubv = (PFNINDEXUBVPROC)IntGetProcAddress("glIndexubv"); + Indexubv(c); + } + + + // Extension: 1.2 + static void CODEGEN_FUNCPTR Switch_BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) + { + BlendColor = (PFNBLENDCOLORPROC)IntGetProcAddress("glBlendColor"); + BlendColor(red, green, blue, alpha); + } + + static void CODEGEN_FUNCPTR Switch_BlendEquation(GLenum mode) + { + BlendEquation = (PFNBLENDEQUATIONPROC)IntGetProcAddress("glBlendEquation"); + BlendEquation(mode); + } + + static void CODEGEN_FUNCPTR Switch_DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) + { + DrawRangeElements = (PFNDRAWRANGEELEMENTSPROC)IntGetProcAddress("glDrawRangeElements"); + DrawRangeElements(mode, start, end, count, type, indices); + } + + static void CODEGEN_FUNCPTR Switch_TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) + { + TexSubImage3D = (PFNTEXSUBIMAGE3DPROC)IntGetProcAddress("glTexSubImage3D"); + TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + } + + static void CODEGEN_FUNCPTR Switch_CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) + { + CopyTexSubImage3D = (PFNCOPYTEXSUBIMAGE3DPROC)IntGetProcAddress("glCopyTexSubImage3D"); + CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); + } + + + // Extension: 1.3 + static void CODEGEN_FUNCPTR Switch_ActiveTexture(GLenum texture) + { + ActiveTexture = (PFNACTIVETEXTUREPROC)IntGetProcAddress("glActiveTexture"); + ActiveTexture(texture); + } + + static void CODEGEN_FUNCPTR Switch_SampleCoverage(GLfloat value, GLboolean invert) + { + SampleCoverage = (PFNSAMPLECOVERAGEPROC)IntGetProcAddress("glSampleCoverage"); + SampleCoverage(value, invert); + } + + static void CODEGEN_FUNCPTR Switch_CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data) + { + CompressedTexImage3D = (PFNCOMPRESSEDTEXIMAGE3DPROC)IntGetProcAddress("glCompressedTexImage3D"); + CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data); + } + + static void CODEGEN_FUNCPTR Switch_CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) + { + CompressedTexImage2D = (PFNCOMPRESSEDTEXIMAGE2DPROC)IntGetProcAddress("glCompressedTexImage2D"); + CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); + } + + static void CODEGEN_FUNCPTR Switch_CompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data) + { + CompressedTexImage1D = (PFNCOMPRESSEDTEXIMAGE1DPROC)IntGetProcAddress("glCompressedTexImage1D"); + CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data); + } + + static void CODEGEN_FUNCPTR Switch_CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data) + { + CompressedTexSubImage3D = (PFNCOMPRESSEDTEXSUBIMAGE3DPROC)IntGetProcAddress("glCompressedTexSubImage3D"); + CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); + } + + static void CODEGEN_FUNCPTR Switch_CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) + { + CompressedTexSubImage2D = (PFNCOMPRESSEDTEXSUBIMAGE2DPROC)IntGetProcAddress("glCompressedTexSubImage2D"); + CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); + } + + static void CODEGEN_FUNCPTR Switch_CompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data) + { + CompressedTexSubImage1D = (PFNCOMPRESSEDTEXSUBIMAGE1DPROC)IntGetProcAddress("glCompressedTexSubImage1D"); + CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); + } + + static void CODEGEN_FUNCPTR Switch_GetCompressedTexImage(GLenum target, GLint level, GLvoid *img) + { + GetCompressedTexImage = (PFNGETCOMPRESSEDTEXIMAGEPROC)IntGetProcAddress("glGetCompressedTexImage"); + GetCompressedTexImage(target, level, img); + } + + + // Extension: 1.4 + static void CODEGEN_FUNCPTR Switch_BlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) + { + BlendFuncSeparate = (PFNBLENDFUNCSEPARATEPROC)IntGetProcAddress("glBlendFuncSeparate"); + BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); + } + + static void CODEGEN_FUNCPTR Switch_MultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount) + { + MultiDrawArrays = (PFNMULTIDRAWARRAYSPROC)IntGetProcAddress("glMultiDrawArrays"); + MultiDrawArrays(mode, first, count, drawcount); + } + + static void CODEGEN_FUNCPTR Switch_MultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount) + { + MultiDrawElements = (PFNMULTIDRAWELEMENTSPROC)IntGetProcAddress("glMultiDrawElements"); + MultiDrawElements(mode, count, type, indices, drawcount); + } + + static void CODEGEN_FUNCPTR Switch_PointParameterf(GLenum pname, GLfloat param) + { + PointParameterf = (PFNPOINTPARAMETERFPROC)IntGetProcAddress("glPointParameterf"); + PointParameterf(pname, param); + } + + static void CODEGEN_FUNCPTR Switch_PointParameterfv(GLenum pname, const GLfloat *params) + { + PointParameterfv = (PFNPOINTPARAMETERFVPROC)IntGetProcAddress("glPointParameterfv"); + PointParameterfv(pname, params); + } + + static void CODEGEN_FUNCPTR Switch_PointParameteri(GLenum pname, GLint param) + { + PointParameteri = (PFNPOINTPARAMETERIPROC)IntGetProcAddress("glPointParameteri"); + PointParameteri(pname, param); + } + + static void CODEGEN_FUNCPTR Switch_PointParameteriv(GLenum pname, const GLint *params) + { + PointParameteriv = (PFNPOINTPARAMETERIVPROC)IntGetProcAddress("glPointParameteriv"); + PointParameteriv(pname, params); + } + + + // Extension: 1.5 + static void CODEGEN_FUNCPTR Switch_GenQueries(GLsizei n, GLuint *ids) + { + GenQueries = (PFNGENQUERIESPROC)IntGetProcAddress("glGenQueries"); + GenQueries(n, ids); + } + + static void CODEGEN_FUNCPTR Switch_DeleteQueries(GLsizei n, const GLuint *ids) + { + DeleteQueries = (PFNDELETEQUERIESPROC)IntGetProcAddress("glDeleteQueries"); + DeleteQueries(n, ids); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsQuery(GLuint id) + { + IsQuery = (PFNISQUERYPROC)IntGetProcAddress("glIsQuery"); + return IsQuery(id); + } + + static void CODEGEN_FUNCPTR Switch_BeginQuery(GLenum target, GLuint id) + { + BeginQuery = (PFNBEGINQUERYPROC)IntGetProcAddress("glBeginQuery"); + BeginQuery(target, id); + } + + static void CODEGEN_FUNCPTR Switch_EndQuery(GLenum target) + { + EndQuery = (PFNENDQUERYPROC)IntGetProcAddress("glEndQuery"); + EndQuery(target); + } + + static void CODEGEN_FUNCPTR Switch_GetQueryiv(GLenum target, GLenum pname, GLint *params) + { + GetQueryiv = (PFNGETQUERYIVPROC)IntGetProcAddress("glGetQueryiv"); + GetQueryiv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetQueryObjectiv(GLuint id, GLenum pname, GLint *params) + { + GetQueryObjectiv = (PFNGETQUERYOBJECTIVPROC)IntGetProcAddress("glGetQueryObjectiv"); + GetQueryObjectiv(id, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params) + { + GetQueryObjectuiv = (PFNGETQUERYOBJECTUIVPROC)IntGetProcAddress("glGetQueryObjectuiv"); + GetQueryObjectuiv(id, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_BindBuffer(GLenum target, GLuint buffer) + { + BindBuffer = (PFNBINDBUFFERPROC)IntGetProcAddress("glBindBuffer"); + BindBuffer(target, buffer); + } + + static void CODEGEN_FUNCPTR Switch_DeleteBuffers(GLsizei n, const GLuint *buffers) + { + DeleteBuffers = (PFNDELETEBUFFERSPROC)IntGetProcAddress("glDeleteBuffers"); + DeleteBuffers(n, buffers); + } + + static void CODEGEN_FUNCPTR Switch_GenBuffers(GLsizei n, GLuint *buffers) + { + GenBuffers = (PFNGENBUFFERSPROC)IntGetProcAddress("glGenBuffers"); + GenBuffers(n, buffers); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsBuffer(GLuint buffer) + { + IsBuffer = (PFNISBUFFERPROC)IntGetProcAddress("glIsBuffer"); + return IsBuffer(buffer); + } + + static void CODEGEN_FUNCPTR Switch_BufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage) + { + BufferData = (PFNBUFFERDATAPROC)IntGetProcAddress("glBufferData"); + BufferData(target, size, data, usage); + } + + static void CODEGEN_FUNCPTR Switch_BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data) + { + BufferSubData = (PFNBUFFERSUBDATAPROC)IntGetProcAddress("glBufferSubData"); + BufferSubData(target, offset, size, data); + } + + static void CODEGEN_FUNCPTR Switch_GetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data) + { + GetBufferSubData = (PFNGETBUFFERSUBDATAPROC)IntGetProcAddress("glGetBufferSubData"); + GetBufferSubData(target, offset, size, data); + } + + static GLvoid* CODEGEN_FUNCPTR Switch_MapBuffer(GLenum target, GLenum access) + { + MapBuffer = (PFNMAPBUFFERPROC)IntGetProcAddress("glMapBuffer"); + return MapBuffer(target, access); + } + + static GLboolean CODEGEN_FUNCPTR Switch_UnmapBuffer(GLenum target) + { + UnmapBuffer = (PFNUNMAPBUFFERPROC)IntGetProcAddress("glUnmapBuffer"); + return UnmapBuffer(target); + } + + static void CODEGEN_FUNCPTR Switch_GetBufferParameteriv(GLenum target, GLenum pname, GLint *params) + { + GetBufferParameteriv = (PFNGETBUFFERPARAMETERIVPROC)IntGetProcAddress("glGetBufferParameteriv"); + GetBufferParameteriv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params) + { + GetBufferPointerv = (PFNGETBUFFERPOINTERVPROC)IntGetProcAddress("glGetBufferPointerv"); + GetBufferPointerv(target, pname, params); + } + + + // Extension: 2.0 + static void CODEGEN_FUNCPTR Switch_BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) + { + BlendEquationSeparate = (PFNBLENDEQUATIONSEPARATEPROC)IntGetProcAddress("glBlendEquationSeparate"); + BlendEquationSeparate(modeRGB, modeAlpha); + } + + static void CODEGEN_FUNCPTR Switch_DrawBuffers(GLsizei n, const GLenum *bufs) + { + DrawBuffers = (PFNDRAWBUFFERSPROC)IntGetProcAddress("glDrawBuffers"); + DrawBuffers(n, bufs); + } + + static void CODEGEN_FUNCPTR Switch_StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) + { + StencilOpSeparate = (PFNSTENCILOPSEPARATEPROC)IntGetProcAddress("glStencilOpSeparate"); + StencilOpSeparate(face, sfail, dpfail, dppass); + } + + static void CODEGEN_FUNCPTR Switch_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) + { + StencilFuncSeparate = (PFNSTENCILFUNCSEPARATEPROC)IntGetProcAddress("glStencilFuncSeparate"); + StencilFuncSeparate(face, func, ref, mask); + } + + static void CODEGEN_FUNCPTR Switch_StencilMaskSeparate(GLenum face, GLuint mask) + { + StencilMaskSeparate = (PFNSTENCILMASKSEPARATEPROC)IntGetProcAddress("glStencilMaskSeparate"); + StencilMaskSeparate(face, mask); + } + + static void CODEGEN_FUNCPTR Switch_AttachShader(GLuint program, GLuint shader) + { + AttachShader = (PFNATTACHSHADERPROC)IntGetProcAddress("glAttachShader"); + AttachShader(program, shader); + } + + static void CODEGEN_FUNCPTR Switch_BindAttribLocation(GLuint program, GLuint index, const GLchar *name) + { + BindAttribLocation = (PFNBINDATTRIBLOCATIONPROC)IntGetProcAddress("glBindAttribLocation"); + BindAttribLocation(program, index, name); + } + + static void CODEGEN_FUNCPTR Switch_CompileShader(GLuint shader) + { + CompileShader = (PFNCOMPILESHADERPROC)IntGetProcAddress("glCompileShader"); + CompileShader(shader); + } + + static GLuint CODEGEN_FUNCPTR Switch_CreateProgram() + { + CreateProgram = (PFNCREATEPROGRAMPROC)IntGetProcAddress("glCreateProgram"); + return CreateProgram(); + } + + static GLuint CODEGEN_FUNCPTR Switch_CreateShader(GLenum type) + { + CreateShader = (PFNCREATESHADERPROC)IntGetProcAddress("glCreateShader"); + return CreateShader(type); + } + + static void CODEGEN_FUNCPTR Switch_DeleteProgram(GLuint program) + { + DeleteProgram = (PFNDELETEPROGRAMPROC)IntGetProcAddress("glDeleteProgram"); + DeleteProgram(program); + } + + static void CODEGEN_FUNCPTR Switch_DeleteShader(GLuint shader) + { + DeleteShader = (PFNDELETESHADERPROC)IntGetProcAddress("glDeleteShader"); + DeleteShader(shader); + } + + static void CODEGEN_FUNCPTR Switch_DetachShader(GLuint program, GLuint shader) + { + DetachShader = (PFNDETACHSHADERPROC)IntGetProcAddress("glDetachShader"); + DetachShader(program, shader); + } + + static void CODEGEN_FUNCPTR Switch_DisableVertexAttribArray(GLuint index) + { + DisableVertexAttribArray = (PFNDISABLEVERTEXATTRIBARRAYPROC)IntGetProcAddress("glDisableVertexAttribArray"); + DisableVertexAttribArray(index); + } + + static void CODEGEN_FUNCPTR Switch_EnableVertexAttribArray(GLuint index) + { + EnableVertexAttribArray = (PFNENABLEVERTEXATTRIBARRAYPROC)IntGetProcAddress("glEnableVertexAttribArray"); + EnableVertexAttribArray(index); + } + + static void CODEGEN_FUNCPTR Switch_GetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) + { + GetActiveAttrib = (PFNGETACTIVEATTRIBPROC)IntGetProcAddress("glGetActiveAttrib"); + GetActiveAttrib(program, index, bufSize, length, size, type, name); + } + + static void CODEGEN_FUNCPTR Switch_GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name) + { + GetActiveUniform = (PFNGETACTIVEUNIFORMPROC)IntGetProcAddress("glGetActiveUniform"); + GetActiveUniform(program, index, bufSize, length, size, type, name); + } + + static void CODEGEN_FUNCPTR Switch_GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj) + { + GetAttachedShaders = (PFNGETATTACHEDSHADERSPROC)IntGetProcAddress("glGetAttachedShaders"); + GetAttachedShaders(program, maxCount, count, obj); + } + + static GLint CODEGEN_FUNCPTR Switch_GetAttribLocation(GLuint program, const GLchar *name) + { + GetAttribLocation = (PFNGETATTRIBLOCATIONPROC)IntGetProcAddress("glGetAttribLocation"); + return GetAttribLocation(program, name); + } + + static void CODEGEN_FUNCPTR Switch_GetProgramiv(GLuint program, GLenum pname, GLint *params) + { + GetProgramiv = (PFNGETPROGRAMIVPROC)IntGetProcAddress("glGetProgramiv"); + GetProgramiv(program, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog) + { + GetProgramInfoLog = (PFNGETPROGRAMINFOLOGPROC)IntGetProcAddress("glGetProgramInfoLog"); + GetProgramInfoLog(program, bufSize, length, infoLog); + } + + static void CODEGEN_FUNCPTR Switch_GetShaderiv(GLuint shader, GLenum pname, GLint *params) + { + GetShaderiv = (PFNGETSHADERIVPROC)IntGetProcAddress("glGetShaderiv"); + GetShaderiv(shader, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog) + { + GetShaderInfoLog = (PFNGETSHADERINFOLOGPROC)IntGetProcAddress("glGetShaderInfoLog"); + GetShaderInfoLog(shader, bufSize, length, infoLog); + } + + static void CODEGEN_FUNCPTR Switch_GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source) + { + GetShaderSource = (PFNGETSHADERSOURCEPROC)IntGetProcAddress("glGetShaderSource"); + GetShaderSource(shader, bufSize, length, source); + } + + static GLint CODEGEN_FUNCPTR Switch_GetUniformLocation(GLuint program, const GLchar *name) + { + GetUniformLocation = (PFNGETUNIFORMLOCATIONPROC)IntGetProcAddress("glGetUniformLocation"); + return GetUniformLocation(program, name); + } + + static void CODEGEN_FUNCPTR Switch_GetUniformfv(GLuint program, GLint location, GLfloat *params) + { + GetUniformfv = (PFNGETUNIFORMFVPROC)IntGetProcAddress("glGetUniformfv"); + GetUniformfv(program, location, params); + } + + static void CODEGEN_FUNCPTR Switch_GetUniformiv(GLuint program, GLint location, GLint *params) + { + GetUniformiv = (PFNGETUNIFORMIVPROC)IntGetProcAddress("glGetUniformiv"); + GetUniformiv(program, location, params); + } + + static void CODEGEN_FUNCPTR Switch_GetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params) + { + GetVertexAttribdv = (PFNGETVERTEXATTRIBDVPROC)IntGetProcAddress("glGetVertexAttribdv"); + GetVertexAttribdv(index, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params) + { + GetVertexAttribfv = (PFNGETVERTEXATTRIBFVPROC)IntGetProcAddress("glGetVertexAttribfv"); + GetVertexAttribfv(index, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetVertexAttribiv(GLuint index, GLenum pname, GLint *params) + { + GetVertexAttribiv = (PFNGETVERTEXATTRIBIVPROC)IntGetProcAddress("glGetVertexAttribiv"); + GetVertexAttribiv(index, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer) + { + GetVertexAttribPointerv = (PFNGETVERTEXATTRIBPOINTERVPROC)IntGetProcAddress("glGetVertexAttribPointerv"); + GetVertexAttribPointerv(index, pname, pointer); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsProgram(GLuint program) + { + IsProgram = (PFNISPROGRAMPROC)IntGetProcAddress("glIsProgram"); + return IsProgram(program); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsShader(GLuint shader) + { + IsShader = (PFNISSHADERPROC)IntGetProcAddress("glIsShader"); + return IsShader(shader); + } + + static void CODEGEN_FUNCPTR Switch_LinkProgram(GLuint program) + { + LinkProgram = (PFNLINKPROGRAMPROC)IntGetProcAddress("glLinkProgram"); + LinkProgram(program); + } + + static void CODEGEN_FUNCPTR Switch_ShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length) + { + ShaderSource = (PFNSHADERSOURCEPROC)IntGetProcAddress("glShaderSource"); + ShaderSource(shader, count, string, length); + } + + static void CODEGEN_FUNCPTR Switch_UseProgram(GLuint program) + { + UseProgram = (PFNUSEPROGRAMPROC)IntGetProcAddress("glUseProgram"); + UseProgram(program); + } + + static void CODEGEN_FUNCPTR Switch_Uniform1f(GLint location, GLfloat v0) + { + Uniform1f = (PFNUNIFORM1FPROC)IntGetProcAddress("glUniform1f"); + Uniform1f(location, v0); + } + + static void CODEGEN_FUNCPTR Switch_Uniform2f(GLint location, GLfloat v0, GLfloat v1) + { + Uniform2f = (PFNUNIFORM2FPROC)IntGetProcAddress("glUniform2f"); + Uniform2f(location, v0, v1); + } + + static void CODEGEN_FUNCPTR Switch_Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) + { + Uniform3f = (PFNUNIFORM3FPROC)IntGetProcAddress("glUniform3f"); + Uniform3f(location, v0, v1, v2); + } + + static void CODEGEN_FUNCPTR Switch_Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) + { + Uniform4f = (PFNUNIFORM4FPROC)IntGetProcAddress("glUniform4f"); + Uniform4f(location, v0, v1, v2, v3); + } + + static void CODEGEN_FUNCPTR Switch_Uniform1i(GLint location, GLint v0) + { + Uniform1i = (PFNUNIFORM1IPROC)IntGetProcAddress("glUniform1i"); + Uniform1i(location, v0); + } + + static void CODEGEN_FUNCPTR Switch_Uniform2i(GLint location, GLint v0, GLint v1) + { + Uniform2i = (PFNUNIFORM2IPROC)IntGetProcAddress("glUniform2i"); + Uniform2i(location, v0, v1); + } + + static void CODEGEN_FUNCPTR Switch_Uniform3i(GLint location, GLint v0, GLint v1, GLint v2) + { + Uniform3i = (PFNUNIFORM3IPROC)IntGetProcAddress("glUniform3i"); + Uniform3i(location, v0, v1, v2); + } + + static void CODEGEN_FUNCPTR Switch_Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) + { + Uniform4i = (PFNUNIFORM4IPROC)IntGetProcAddress("glUniform4i"); + Uniform4i(location, v0, v1, v2, v3); + } + + static void CODEGEN_FUNCPTR Switch_Uniform1fv(GLint location, GLsizei count, const GLfloat *value) + { + Uniform1fv = (PFNUNIFORM1FVPROC)IntGetProcAddress("glUniform1fv"); + Uniform1fv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform2fv(GLint location, GLsizei count, const GLfloat *value) + { + Uniform2fv = (PFNUNIFORM2FVPROC)IntGetProcAddress("glUniform2fv"); + Uniform2fv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform3fv(GLint location, GLsizei count, const GLfloat *value) + { + Uniform3fv = (PFNUNIFORM3FVPROC)IntGetProcAddress("glUniform3fv"); + Uniform3fv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform4fv(GLint location, GLsizei count, const GLfloat *value) + { + Uniform4fv = (PFNUNIFORM4FVPROC)IntGetProcAddress("glUniform4fv"); + Uniform4fv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform1iv(GLint location, GLsizei count, const GLint *value) + { + Uniform1iv = (PFNUNIFORM1IVPROC)IntGetProcAddress("glUniform1iv"); + Uniform1iv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform2iv(GLint location, GLsizei count, const GLint *value) + { + Uniform2iv = (PFNUNIFORM2IVPROC)IntGetProcAddress("glUniform2iv"); + Uniform2iv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform3iv(GLint location, GLsizei count, const GLint *value) + { + Uniform3iv = (PFNUNIFORM3IVPROC)IntGetProcAddress("glUniform3iv"); + Uniform3iv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform4iv(GLint location, GLsizei count, const GLint *value) + { + Uniform4iv = (PFNUNIFORM4IVPROC)IntGetProcAddress("glUniform4iv"); + Uniform4iv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix2fv = (PFNUNIFORMMATRIX2FVPROC)IntGetProcAddress("glUniformMatrix2fv"); + UniformMatrix2fv(location, count, transpose, value); + } + + static void CODEGEN_FUNCPTR Switch_UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix3fv = (PFNUNIFORMMATRIX3FVPROC)IntGetProcAddress("glUniformMatrix3fv"); + UniformMatrix3fv(location, count, transpose, value); + } + + static void CODEGEN_FUNCPTR Switch_UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix4fv = (PFNUNIFORMMATRIX4FVPROC)IntGetProcAddress("glUniformMatrix4fv"); + UniformMatrix4fv(location, count, transpose, value); + } + + static void CODEGEN_FUNCPTR Switch_ValidateProgram(GLuint program) + { + ValidateProgram = (PFNVALIDATEPROGRAMPROC)IntGetProcAddress("glValidateProgram"); + ValidateProgram(program); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer) + { + VertexAttribPointer = (PFNVERTEXATTRIBPOINTERPROC)IntGetProcAddress("glVertexAttribPointer"); + VertexAttribPointer(index, size, type, normalized, stride, pointer); + } + + + // Extension: 2.1 + static void CODEGEN_FUNCPTR Switch_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix2x3fv = (PFNUNIFORMMATRIX2X3FVPROC)IntGetProcAddress("glUniformMatrix2x3fv"); + UniformMatrix2x3fv(location, count, transpose, value); + } + + static void CODEGEN_FUNCPTR Switch_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix3x2fv = (PFNUNIFORMMATRIX3X2FVPROC)IntGetProcAddress("glUniformMatrix3x2fv"); + UniformMatrix3x2fv(location, count, transpose, value); + } + + static void CODEGEN_FUNCPTR Switch_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix2x4fv = (PFNUNIFORMMATRIX2X4FVPROC)IntGetProcAddress("glUniformMatrix2x4fv"); + UniformMatrix2x4fv(location, count, transpose, value); + } + + static void CODEGEN_FUNCPTR Switch_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix4x2fv = (PFNUNIFORMMATRIX4X2FVPROC)IntGetProcAddress("glUniformMatrix4x2fv"); + UniformMatrix4x2fv(location, count, transpose, value); + } + + static void CODEGEN_FUNCPTR Switch_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix3x4fv = (PFNUNIFORMMATRIX3X4FVPROC)IntGetProcAddress("glUniformMatrix3x4fv"); + UniformMatrix3x4fv(location, count, transpose, value); + } + + static void CODEGEN_FUNCPTR Switch_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value) + { + UniformMatrix4x3fv = (PFNUNIFORMMATRIX4X3FVPROC)IntGetProcAddress("glUniformMatrix4x3fv"); + UniformMatrix4x3fv(location, count, transpose, value); + } + + + // Extension: ARB_vertex_array_object + static void CODEGEN_FUNCPTR Switch_BindVertexArray(GLuint ren_array) + { + BindVertexArray = (PFNBINDVERTEXARRAYPROC)IntGetProcAddress("glBindVertexArray"); + BindVertexArray(ren_array); + } + + static void CODEGEN_FUNCPTR Switch_DeleteVertexArrays(GLsizei n, const GLuint *arrays) + { + DeleteVertexArrays = (PFNDELETEVERTEXARRAYSPROC)IntGetProcAddress("glDeleteVertexArrays"); + DeleteVertexArrays(n, arrays); + } + + static void CODEGEN_FUNCPTR Switch_GenVertexArrays(GLsizei n, GLuint *arrays) + { + GenVertexArrays = (PFNGENVERTEXARRAYSPROC)IntGetProcAddress("glGenVertexArrays"); + GenVertexArrays(n, arrays); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsVertexArray(GLuint ren_array) + { + IsVertexArray = (PFNISVERTEXARRAYPROC)IntGetProcAddress("glIsVertexArray"); + return IsVertexArray(ren_array); + } + + + // Extension: ARB_map_buffer_range + static GLvoid* CODEGEN_FUNCPTR Switch_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) + { + MapBufferRange = (PFNMAPBUFFERRANGEPROC)IntGetProcAddress("glMapBufferRange"); + return MapBufferRange(target, offset, length, access); + } + + static void CODEGEN_FUNCPTR Switch_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) + { + FlushMappedBufferRange = (PFNFLUSHMAPPEDBUFFERRANGEPROC)IntGetProcAddress("glFlushMappedBufferRange"); + FlushMappedBufferRange(target, offset, length); + } + + + // Extension: ARB_framebuffer_object + static GLboolean CODEGEN_FUNCPTR Switch_IsRenderbuffer(GLuint renderbuffer) + { + IsRenderbuffer = (PFNISRENDERBUFFERPROC)IntGetProcAddress("glIsRenderbuffer"); + return IsRenderbuffer(renderbuffer); + } + + static void CODEGEN_FUNCPTR Switch_BindRenderbuffer(GLenum target, GLuint renderbuffer) + { + BindRenderbuffer = (PFNBINDRENDERBUFFERPROC)IntGetProcAddress("glBindRenderbuffer"); + BindRenderbuffer(target, renderbuffer); + } + + static void CODEGEN_FUNCPTR Switch_DeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers) + { + DeleteRenderbuffers = (PFNDELETERENDERBUFFERSPROC)IntGetProcAddress("glDeleteRenderbuffers"); + DeleteRenderbuffers(n, renderbuffers); + } + + static void CODEGEN_FUNCPTR Switch_GenRenderbuffers(GLsizei n, GLuint *renderbuffers) + { + GenRenderbuffers = (PFNGENRENDERBUFFERSPROC)IntGetProcAddress("glGenRenderbuffers"); + GenRenderbuffers(n, renderbuffers); + } + + static void CODEGEN_FUNCPTR Switch_RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) + { + RenderbufferStorage = (PFNRENDERBUFFERSTORAGEPROC)IntGetProcAddress("glRenderbufferStorage"); + RenderbufferStorage(target, internalformat, width, height); + } + + static void CODEGEN_FUNCPTR Switch_GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params) + { + GetRenderbufferParameteriv = (PFNGETRENDERBUFFERPARAMETERIVPROC)IntGetProcAddress("glGetRenderbufferParameteriv"); + GetRenderbufferParameteriv(target, pname, params); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsFramebuffer(GLuint framebuffer) + { + IsFramebuffer = (PFNISFRAMEBUFFERPROC)IntGetProcAddress("glIsFramebuffer"); + return IsFramebuffer(framebuffer); + } + + static void CODEGEN_FUNCPTR Switch_BindFramebuffer(GLenum target, GLuint framebuffer) + { + BindFramebuffer = (PFNBINDFRAMEBUFFERPROC)IntGetProcAddress("glBindFramebuffer"); + BindFramebuffer(target, framebuffer); + } + + static void CODEGEN_FUNCPTR Switch_DeleteFramebuffers(GLsizei n, const GLuint *framebuffers) + { + DeleteFramebuffers = (PFNDELETEFRAMEBUFFERSPROC)IntGetProcAddress("glDeleteFramebuffers"); + DeleteFramebuffers(n, framebuffers); + } + + static void CODEGEN_FUNCPTR Switch_GenFramebuffers(GLsizei n, GLuint *framebuffers) + { + GenFramebuffers = (PFNGENFRAMEBUFFERSPROC)IntGetProcAddress("glGenFramebuffers"); + GenFramebuffers(n, framebuffers); + } + + static GLenum CODEGEN_FUNCPTR Switch_CheckFramebufferStatus(GLenum target) + { + CheckFramebufferStatus = (PFNCHECKFRAMEBUFFERSTATUSPROC)IntGetProcAddress("glCheckFramebufferStatus"); + return CheckFramebufferStatus(target); + } + + static void CODEGEN_FUNCPTR Switch_FramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) + { + FramebufferTexture1D = (PFNFRAMEBUFFERTEXTURE1DPROC)IntGetProcAddress("glFramebufferTexture1D"); + FramebufferTexture1D(target, attachment, textarget, texture, level); + } + + static void CODEGEN_FUNCPTR Switch_FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) + { + FramebufferTexture2D = (PFNFRAMEBUFFERTEXTURE2DPROC)IntGetProcAddress("glFramebufferTexture2D"); + FramebufferTexture2D(target, attachment, textarget, texture, level); + } + + static void CODEGEN_FUNCPTR Switch_FramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) + { + FramebufferTexture3D = (PFNFRAMEBUFFERTEXTURE3DPROC)IntGetProcAddress("glFramebufferTexture3D"); + FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); + } + + static void CODEGEN_FUNCPTR Switch_FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) + { + FramebufferRenderbuffer = (PFNFRAMEBUFFERRENDERBUFFERPROC)IntGetProcAddress("glFramebufferRenderbuffer"); + FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); + } + + static void CODEGEN_FUNCPTR Switch_GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params) + { + GetFramebufferAttachmentParameteriv = (PFNGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)IntGetProcAddress("glGetFramebufferAttachmentParameteriv"); + GetFramebufferAttachmentParameteriv(target, attachment, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GenerateMipmap(GLenum target) + { + GenerateMipmap = (PFNGENERATEMIPMAPPROC)IntGetProcAddress("glGenerateMipmap"); + GenerateMipmap(target); + } + + static void CODEGEN_FUNCPTR Switch_BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) + { + BlitFramebuffer = (PFNBLITFRAMEBUFFERPROC)IntGetProcAddress("glBlitFramebuffer"); + BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); + } + + static void CODEGEN_FUNCPTR Switch_RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) + { + RenderbufferStorageMultisample = (PFNRENDERBUFFERSTORAGEMULTISAMPLEPROC)IntGetProcAddress("glRenderbufferStorageMultisample"); + RenderbufferStorageMultisample(target, samples, internalformat, width, height); + } + + static void CODEGEN_FUNCPTR Switch_FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) + { + FramebufferTextureLayer = (PFNFRAMEBUFFERTEXTURELAYERPROC)IntGetProcAddress("glFramebufferTextureLayer"); + FramebufferTextureLayer(target, attachment, texture, level, layer); + } + + + // Extension: 3.0 + static void CODEGEN_FUNCPTR Switch_ColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) + { + ColorMaski = (PFNCOLORMASKIPROC)IntGetProcAddress("glColorMaski"); + ColorMaski(index, r, g, b, a); + } + + static void CODEGEN_FUNCPTR Switch_GetBooleani_v(GLenum target, GLuint index, GLboolean *data) + { + GetBooleani_v = (PFNGETBOOLEANI_VPROC)IntGetProcAddress("glGetBooleani_v"); + GetBooleani_v(target, index, data); + } + + static void CODEGEN_FUNCPTR Switch_GetIntegeri_v(GLenum target, GLuint index, GLint *data) + { + GetIntegeri_v = (PFNGETINTEGERI_VPROC)IntGetProcAddress("glGetIntegeri_v"); + GetIntegeri_v(target, index, data); + } + + static void CODEGEN_FUNCPTR Switch_Enablei(GLenum target, GLuint index) + { + Enablei = (PFNENABLEIPROC)IntGetProcAddress("glEnablei"); + Enablei(target, index); + } + + static void CODEGEN_FUNCPTR Switch_Disablei(GLenum target, GLuint index) + { + Disablei = (PFNDISABLEIPROC)IntGetProcAddress("glDisablei"); + Disablei(target, index); + } + + static GLboolean CODEGEN_FUNCPTR Switch_IsEnabledi(GLenum target, GLuint index) + { + IsEnabledi = (PFNISENABLEDIPROC)IntGetProcAddress("glIsEnabledi"); + return IsEnabledi(target, index); + } + + static void CODEGEN_FUNCPTR Switch_BeginTransformFeedback(GLenum primitiveMode) + { + BeginTransformFeedback = (PFNBEGINTRANSFORMFEEDBACKPROC)IntGetProcAddress("glBeginTransformFeedback"); + BeginTransformFeedback(primitiveMode); + } + + static void CODEGEN_FUNCPTR Switch_EndTransformFeedback() + { + EndTransformFeedback = (PFNENDTRANSFORMFEEDBACKPROC)IntGetProcAddress("glEndTransformFeedback"); + EndTransformFeedback(); + } + + static void CODEGEN_FUNCPTR Switch_BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) + { + BindBufferRange = (PFNBINDBUFFERRANGEPROC)IntGetProcAddress("glBindBufferRange"); + BindBufferRange(target, index, buffer, offset, size); + } + + static void CODEGEN_FUNCPTR Switch_BindBufferBase(GLenum target, GLuint index, GLuint buffer) + { + BindBufferBase = (PFNBINDBUFFERBASEPROC)IntGetProcAddress("glBindBufferBase"); + BindBufferBase(target, index, buffer); + } + + static void CODEGEN_FUNCPTR Switch_TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode) + { + TransformFeedbackVaryings = (PFNTRANSFORMFEEDBACKVARYINGSPROC)IntGetProcAddress("glTransformFeedbackVaryings"); + TransformFeedbackVaryings(program, count, varyings, bufferMode); + } + + static void CODEGEN_FUNCPTR Switch_GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name) + { + GetTransformFeedbackVarying = (PFNGETTRANSFORMFEEDBACKVARYINGPROC)IntGetProcAddress("glGetTransformFeedbackVarying"); + GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name); + } + + static void CODEGEN_FUNCPTR Switch_ClampColor(GLenum target, GLenum clamp) + { + ClampColor = (PFNCLAMPCOLORPROC)IntGetProcAddress("glClampColor"); + ClampColor(target, clamp); + } + + static void CODEGEN_FUNCPTR Switch_BeginConditionalRender(GLuint id, GLenum mode) + { + BeginConditionalRender = (PFNBEGINCONDITIONALRENDERPROC)IntGetProcAddress("glBeginConditionalRender"); + BeginConditionalRender(id, mode); + } + + static void CODEGEN_FUNCPTR Switch_EndConditionalRender() + { + EndConditionalRender = (PFNENDCONDITIONALRENDERPROC)IntGetProcAddress("glEndConditionalRender"); + EndConditionalRender(); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) + { + VertexAttribIPointer = (PFNVERTEXATTRIBIPOINTERPROC)IntGetProcAddress("glVertexAttribIPointer"); + VertexAttribIPointer(index, size, type, stride, pointer); + } + + static void CODEGEN_FUNCPTR Switch_GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params) + { + GetVertexAttribIiv = (PFNGETVERTEXATTRIBIIVPROC)IntGetProcAddress("glGetVertexAttribIiv"); + GetVertexAttribIiv(index, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params) + { + GetVertexAttribIuiv = (PFNGETVERTEXATTRIBIUIVPROC)IntGetProcAddress("glGetVertexAttribIuiv"); + GetVertexAttribIuiv(index, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI1i(GLuint index, GLint x) + { + VertexAttribI1i = (PFNVERTEXATTRIBI1IPROC)IntGetProcAddress("glVertexAttribI1i"); + VertexAttribI1i(index, x); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI2i(GLuint index, GLint x, GLint y) + { + VertexAttribI2i = (PFNVERTEXATTRIBI2IPROC)IntGetProcAddress("glVertexAttribI2i"); + VertexAttribI2i(index, x, y); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI3i(GLuint index, GLint x, GLint y, GLint z) + { + VertexAttribI3i = (PFNVERTEXATTRIBI3IPROC)IntGetProcAddress("glVertexAttribI3i"); + VertexAttribI3i(index, x, y, z); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) + { + VertexAttribI4i = (PFNVERTEXATTRIBI4IPROC)IntGetProcAddress("glVertexAttribI4i"); + VertexAttribI4i(index, x, y, z, w); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI1ui(GLuint index, GLuint x) + { + VertexAttribI1ui = (PFNVERTEXATTRIBI1UIPROC)IntGetProcAddress("glVertexAttribI1ui"); + VertexAttribI1ui(index, x); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI2ui(GLuint index, GLuint x, GLuint y) + { + VertexAttribI2ui = (PFNVERTEXATTRIBI2UIPROC)IntGetProcAddress("glVertexAttribI2ui"); + VertexAttribI2ui(index, x, y); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z) + { + VertexAttribI3ui = (PFNVERTEXATTRIBI3UIPROC)IntGetProcAddress("glVertexAttribI3ui"); + VertexAttribI3ui(index, x, y, z); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) + { + VertexAttribI4ui = (PFNVERTEXATTRIBI4UIPROC)IntGetProcAddress("glVertexAttribI4ui"); + VertexAttribI4ui(index, x, y, z, w); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI1iv(GLuint index, const GLint *v) + { + VertexAttribI1iv = (PFNVERTEXATTRIBI1IVPROC)IntGetProcAddress("glVertexAttribI1iv"); + VertexAttribI1iv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI2iv(GLuint index, const GLint *v) + { + VertexAttribI2iv = (PFNVERTEXATTRIBI2IVPROC)IntGetProcAddress("glVertexAttribI2iv"); + VertexAttribI2iv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI3iv(GLuint index, const GLint *v) + { + VertexAttribI3iv = (PFNVERTEXATTRIBI3IVPROC)IntGetProcAddress("glVertexAttribI3iv"); + VertexAttribI3iv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI4iv(GLuint index, const GLint *v) + { + VertexAttribI4iv = (PFNVERTEXATTRIBI4IVPROC)IntGetProcAddress("glVertexAttribI4iv"); + VertexAttribI4iv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI1uiv(GLuint index, const GLuint *v) + { + VertexAttribI1uiv = (PFNVERTEXATTRIBI1UIVPROC)IntGetProcAddress("glVertexAttribI1uiv"); + VertexAttribI1uiv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI2uiv(GLuint index, const GLuint *v) + { + VertexAttribI2uiv = (PFNVERTEXATTRIBI2UIVPROC)IntGetProcAddress("glVertexAttribI2uiv"); + VertexAttribI2uiv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI3uiv(GLuint index, const GLuint *v) + { + VertexAttribI3uiv = (PFNVERTEXATTRIBI3UIVPROC)IntGetProcAddress("glVertexAttribI3uiv"); + VertexAttribI3uiv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI4uiv(GLuint index, const GLuint *v) + { + VertexAttribI4uiv = (PFNVERTEXATTRIBI4UIVPROC)IntGetProcAddress("glVertexAttribI4uiv"); + VertexAttribI4uiv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI4bv(GLuint index, const GLbyte *v) + { + VertexAttribI4bv = (PFNVERTEXATTRIBI4BVPROC)IntGetProcAddress("glVertexAttribI4bv"); + VertexAttribI4bv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI4sv(GLuint index, const GLshort *v) + { + VertexAttribI4sv = (PFNVERTEXATTRIBI4SVPROC)IntGetProcAddress("glVertexAttribI4sv"); + VertexAttribI4sv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI4ubv(GLuint index, const GLubyte *v) + { + VertexAttribI4ubv = (PFNVERTEXATTRIBI4UBVPROC)IntGetProcAddress("glVertexAttribI4ubv"); + VertexAttribI4ubv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_VertexAttribI4usv(GLuint index, const GLushort *v) + { + VertexAttribI4usv = (PFNVERTEXATTRIBI4USVPROC)IntGetProcAddress("glVertexAttribI4usv"); + VertexAttribI4usv(index, v); + } + + static void CODEGEN_FUNCPTR Switch_GetUniformuiv(GLuint program, GLint location, GLuint *params) + { + GetUniformuiv = (PFNGETUNIFORMUIVPROC)IntGetProcAddress("glGetUniformuiv"); + GetUniformuiv(program, location, params); + } + + static void CODEGEN_FUNCPTR Switch_BindFragDataLocation(GLuint program, GLuint color, const GLchar *name) + { + BindFragDataLocation = (PFNBINDFRAGDATALOCATIONPROC)IntGetProcAddress("glBindFragDataLocation"); + BindFragDataLocation(program, color, name); + } + + static GLint CODEGEN_FUNCPTR Switch_GetFragDataLocation(GLuint program, const GLchar *name) + { + GetFragDataLocation = (PFNGETFRAGDATALOCATIONPROC)IntGetProcAddress("glGetFragDataLocation"); + return GetFragDataLocation(program, name); + } + + static void CODEGEN_FUNCPTR Switch_Uniform1ui(GLint location, GLuint v0) + { + Uniform1ui = (PFNUNIFORM1UIPROC)IntGetProcAddress("glUniform1ui"); + Uniform1ui(location, v0); + } + + static void CODEGEN_FUNCPTR Switch_Uniform2ui(GLint location, GLuint v0, GLuint v1) + { + Uniform2ui = (PFNUNIFORM2UIPROC)IntGetProcAddress("glUniform2ui"); + Uniform2ui(location, v0, v1); + } + + static void CODEGEN_FUNCPTR Switch_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) + { + Uniform3ui = (PFNUNIFORM3UIPROC)IntGetProcAddress("glUniform3ui"); + Uniform3ui(location, v0, v1, v2); + } + + static void CODEGEN_FUNCPTR Switch_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) + { + Uniform4ui = (PFNUNIFORM4UIPROC)IntGetProcAddress("glUniform4ui"); + Uniform4ui(location, v0, v1, v2, v3); + } + + static void CODEGEN_FUNCPTR Switch_Uniform1uiv(GLint location, GLsizei count, const GLuint *value) + { + Uniform1uiv = (PFNUNIFORM1UIVPROC)IntGetProcAddress("glUniform1uiv"); + Uniform1uiv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform2uiv(GLint location, GLsizei count, const GLuint *value) + { + Uniform2uiv = (PFNUNIFORM2UIVPROC)IntGetProcAddress("glUniform2uiv"); + Uniform2uiv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform3uiv(GLint location, GLsizei count, const GLuint *value) + { + Uniform3uiv = (PFNUNIFORM3UIVPROC)IntGetProcAddress("glUniform3uiv"); + Uniform3uiv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_Uniform4uiv(GLint location, GLsizei count, const GLuint *value) + { + Uniform4uiv = (PFNUNIFORM4UIVPROC)IntGetProcAddress("glUniform4uiv"); + Uniform4uiv(location, count, value); + } + + static void CODEGEN_FUNCPTR Switch_TexParameterIiv(GLenum target, GLenum pname, const GLint *params) + { + TexParameterIiv = (PFNTEXPARAMETERIIVPROC)IntGetProcAddress("glTexParameterIiv"); + TexParameterIiv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_TexParameterIuiv(GLenum target, GLenum pname, const GLuint *params) + { + TexParameterIuiv = (PFNTEXPARAMETERIUIVPROC)IntGetProcAddress("glTexParameterIuiv"); + TexParameterIuiv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetTexParameterIiv(GLenum target, GLenum pname, GLint *params) + { + GetTexParameterIiv = (PFNGETTEXPARAMETERIIVPROC)IntGetProcAddress("glGetTexParameterIiv"); + GetTexParameterIiv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params) + { + GetTexParameterIuiv = (PFNGETTEXPARAMETERIUIVPROC)IntGetProcAddress("glGetTexParameterIuiv"); + GetTexParameterIuiv(target, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value) + { + ClearBufferiv = (PFNCLEARBUFFERIVPROC)IntGetProcAddress("glClearBufferiv"); + ClearBufferiv(buffer, drawbuffer, value); + } + + static void CODEGEN_FUNCPTR Switch_ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value) + { + ClearBufferuiv = (PFNCLEARBUFFERUIVPROC)IntGetProcAddress("glClearBufferuiv"); + ClearBufferuiv(buffer, drawbuffer, value); + } + + static void CODEGEN_FUNCPTR Switch_ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value) + { + ClearBufferfv = (PFNCLEARBUFFERFVPROC)IntGetProcAddress("glClearBufferfv"); + ClearBufferfv(buffer, drawbuffer, value); + } + + static void CODEGEN_FUNCPTR Switch_ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) + { + ClearBufferfi = (PFNCLEARBUFFERFIPROC)IntGetProcAddress("glClearBufferfi"); + ClearBufferfi(buffer, drawbuffer, depth, stencil); + } + + static const GLubyte * CODEGEN_FUNCPTR Switch_GetStringi(GLenum name, GLuint index) + { + GetStringi = (PFNGETSTRINGIPROC)IntGetProcAddress("glGetStringi"); + return GetStringi(name, index); + } + + + // Extension: ARB_uniform_buffer_object + static void CODEGEN_FUNCPTR Switch_GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices) + { + GetUniformIndices = (PFNGETUNIFORMINDICESPROC)IntGetProcAddress("glGetUniformIndices"); + GetUniformIndices(program, uniformCount, uniformNames, uniformIndices); + } + + static void CODEGEN_FUNCPTR Switch_GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params) + { + GetActiveUniformsiv = (PFNGETACTIVEUNIFORMSIVPROC)IntGetProcAddress("glGetActiveUniformsiv"); + GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName) + { + GetActiveUniformName = (PFNGETACTIVEUNIFORMNAMEPROC)IntGetProcAddress("glGetActiveUniformName"); + GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); + } + + static GLuint CODEGEN_FUNCPTR Switch_GetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName) + { + GetUniformBlockIndex = (PFNGETUNIFORMBLOCKINDEXPROC)IntGetProcAddress("glGetUniformBlockIndex"); + return GetUniformBlockIndex(program, uniformBlockName); + } + + static void CODEGEN_FUNCPTR Switch_GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params) + { + GetActiveUniformBlockiv = (PFNGETACTIVEUNIFORMBLOCKIVPROC)IntGetProcAddress("glGetActiveUniformBlockiv"); + GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); + } + + static void CODEGEN_FUNCPTR Switch_GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName) + { + GetActiveUniformBlockName = (PFNGETACTIVEUNIFORMBLOCKNAMEPROC)IntGetProcAddress("glGetActiveUniformBlockName"); + GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); + } + + static void CODEGEN_FUNCPTR Switch_UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) + { + UniformBlockBinding = (PFNUNIFORMBLOCKBINDINGPROC)IntGetProcAddress("glUniformBlockBinding"); + UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding); + } + + + // Extension: ARB_copy_buffer + static void CODEGEN_FUNCPTR Switch_CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) + { + CopyBufferSubData = (PFNCOPYBUFFERSUBDATAPROC)IntGetProcAddress("glCopyBufferSubData"); + CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); + } + + + // Extension: 3.1 + static void CODEGEN_FUNCPTR Switch_DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount) + { + DrawArraysInstanced = (PFNDRAWARRAYSINSTANCEDPROC)IntGetProcAddress("glDrawArraysInstanced"); + DrawArraysInstanced(mode, first, count, instancecount); + } + + static void CODEGEN_FUNCPTR Switch_DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount) + { + DrawElementsInstanced = (PFNDRAWELEMENTSINSTANCEDPROC)IntGetProcAddress("glDrawElementsInstanced"); + DrawElementsInstanced(mode, count, type, indices, instancecount); + } + + static void CODEGEN_FUNCPTR Switch_TexBuffer(GLenum target, GLenum internalformat, GLuint buffer) + { + TexBuffer = (PFNTEXBUFFERPROC)IntGetProcAddress("glTexBuffer"); + TexBuffer(target, internalformat, buffer); + } + + static void CODEGEN_FUNCPTR Switch_PrimitiveRestartIndex(GLuint index) + { + PrimitiveRestartIndex = (PFNPRIMITIVERESTARTINDEXPROC)IntGetProcAddress("glPrimitiveRestartIndex"); + PrimitiveRestartIndex(index); + } + + // Legacy + static void CODEGEN_FUNCPTR Switch_EnableClientState(GLenum cap) + { + EnableClientState = (PFNENABLECLIENTSTATEPROC)IntGetProcAddress("glEnableClientState"); + EnableClientState(cap); + } + + static void CODEGEN_FUNCPTR Switch_DisableClientState(GLenum cap) + { + DisableClientState = (PFNDISABLECLIENTSTATEPROC)IntGetProcAddress("glDisableClientState"); + DisableClientState(cap); + } + + static void CODEGEN_FUNCPTR Switch_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) + { + VertexPointer = (PFNVERTEXPOINTERPROC)IntGetProcAddress("glVertexPointer"); + VertexPointer(size, type, stride, ptr); + } + + static void CODEGEN_FUNCPTR Switch_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr) + { + NormalPointer = (PFNNORMALPOINTERPROC)IntGetProcAddress("glNormalPointer"); + NormalPointer(type, stride, ptr); + } + + static void CODEGEN_FUNCPTR Switch_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) + { + ColorPointer = (PFNCOLORPOINTERPROC)IntGetProcAddress("glColorPointer"); + ColorPointer(size, type, stride, ptr); + } + + static void CODEGEN_FUNCPTR Switch_TexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr) + { + TexCoordPointer = (PFNTEXCOORDPOINTERPROC)IntGetProcAddress("glTexCoordPointer"); + TexCoordPointer(size, type, stride, ptr); + } + + static void CODEGEN_FUNCPTR Switch_TexEnvi(GLenum target, GLenum pname, GLint param) + { + TexEnvi = (PFNTEXENVIPROC)IntGetProcAddress("glTexEnvi"); + TexEnvi(target, pname, param); + } + + static void CODEGEN_FUNCPTR Switch_MatrixMode(GLenum mode) + { + MatrixMode = (PFNMATRIXMODEPROC)IntGetProcAddress("glMatrixMode"); + MatrixMode(mode); + } + + static void CODEGEN_FUNCPTR Switch_LoadIdentity(void) + { + LoadIdentity = (PFNLOADIDENTITYPROC)IntGetProcAddress("glLoadIdentity"); + LoadIdentity(); + } + + static void CODEGEN_FUNCPTR Switch_Ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val) + { + Ortho = (PFNORTHOPROC)IntGetProcAddress("glOrtho"); + Ortho(left, right, bottom, top, near_val, far_val); + } + + static void CODEGEN_FUNCPTR Switch_Color3d(GLdouble red, GLdouble green, GLdouble blue) + { + Color3d = (PFNCOLOR3DPROC)IntGetProcAddress("glColor3d"); + Color3d(red, green, blue); + } + + + + namespace + { + struct InitializeVariables + { + InitializeVariables() + { + // Extension: 1.1 + CullFace = Switch_CullFace; + FrontFace = Switch_FrontFace; + Hint = Switch_Hint; + LineWidth = Switch_LineWidth; + PointSize = Switch_PointSize; + PolygonMode = Switch_PolygonMode; + Scissor = Switch_Scissor; + TexParameterf = Switch_TexParameterf; + TexParameterfv = Switch_TexParameterfv; + TexParameteri = Switch_TexParameteri; + TexParameteriv = Switch_TexParameteriv; + TexImage1D = Switch_TexImage1D; + TexImage2D = Switch_TexImage2D; + DrawBuffer = Switch_DrawBuffer; + Clear = Switch_Clear; + ClearColor = Switch_ClearColor; + ClearStencil = Switch_ClearStencil; + ClearDepth = Switch_ClearDepth; + StencilMask = Switch_StencilMask; + ColorMask = Switch_ColorMask; + DepthMask = Switch_DepthMask; + Disable = Switch_Disable; + Enable = Switch_Enable; + Finish = Switch_Finish; + Flush = Switch_Flush; + BlendFunc = Switch_BlendFunc; + LogicOp = Switch_LogicOp; + StencilFunc = Switch_StencilFunc; + StencilOp = Switch_StencilOp; + DepthFunc = Switch_DepthFunc; + PixelStoref = Switch_PixelStoref; + PixelStorei = Switch_PixelStorei; + ReadBuffer = Switch_ReadBuffer; + ReadPixels = Switch_ReadPixels; + GetBooleanv = Switch_GetBooleanv; + GetDoublev = Switch_GetDoublev; + GetError = Switch_GetError; + GetFloatv = Switch_GetFloatv; + GetIntegerv = Switch_GetIntegerv; + GetString = Switch_GetString; + GetTexImage = Switch_GetTexImage; + GetTexParameterfv = Switch_GetTexParameterfv; + GetTexParameteriv = Switch_GetTexParameteriv; + GetTexLevelParameterfv = Switch_GetTexLevelParameterfv; + GetTexLevelParameteriv = Switch_GetTexLevelParameteriv; + IsEnabled = Switch_IsEnabled; + DepthRange = Switch_DepthRange; + Viewport = Switch_Viewport; + DrawArrays = Switch_DrawArrays; + DrawElements = Switch_DrawElements; + GetPointerv = Switch_GetPointerv; + PolygonOffset = Switch_PolygonOffset; + CopyTexImage1D = Switch_CopyTexImage1D; + CopyTexImage2D = Switch_CopyTexImage2D; + CopyTexSubImage1D = Switch_CopyTexSubImage1D; + CopyTexSubImage2D = Switch_CopyTexSubImage2D; + TexSubImage1D = Switch_TexSubImage1D; + TexSubImage2D = Switch_TexSubImage2D; + BindTexture = Switch_BindTexture; + DeleteTextures = Switch_DeleteTextures; + GenTextures = Switch_GenTextures; + IsTexture = Switch_IsTexture; + Indexub = Switch_Indexub; + Indexubv = Switch_Indexubv; + + // Extension: 1.2 + BlendColor = Switch_BlendColor; + BlendEquation = Switch_BlendEquation; + DrawRangeElements = Switch_DrawRangeElements; + TexSubImage3D = Switch_TexSubImage3D; + CopyTexSubImage3D = Switch_CopyTexSubImage3D; + + // Extension: 1.3 + ActiveTexture = Switch_ActiveTexture; + SampleCoverage = Switch_SampleCoverage; + CompressedTexImage3D = Switch_CompressedTexImage3D; + CompressedTexImage2D = Switch_CompressedTexImage2D; + CompressedTexImage1D = Switch_CompressedTexImage1D; + CompressedTexSubImage3D = Switch_CompressedTexSubImage3D; + CompressedTexSubImage2D = Switch_CompressedTexSubImage2D; + CompressedTexSubImage1D = Switch_CompressedTexSubImage1D; + GetCompressedTexImage = Switch_GetCompressedTexImage; + + // Extension: 1.4 + BlendFuncSeparate = Switch_BlendFuncSeparate; + MultiDrawArrays = Switch_MultiDrawArrays; + MultiDrawElements = Switch_MultiDrawElements; + PointParameterf = Switch_PointParameterf; + PointParameterfv = Switch_PointParameterfv; + PointParameteri = Switch_PointParameteri; + PointParameteriv = Switch_PointParameteriv; + + // Extension: 1.5 + GenQueries = Switch_GenQueries; + DeleteQueries = Switch_DeleteQueries; + IsQuery = Switch_IsQuery; + BeginQuery = Switch_BeginQuery; + EndQuery = Switch_EndQuery; + GetQueryiv = Switch_GetQueryiv; + GetQueryObjectiv = Switch_GetQueryObjectiv; + GetQueryObjectuiv = Switch_GetQueryObjectuiv; + BindBuffer = Switch_BindBuffer; + DeleteBuffers = Switch_DeleteBuffers; + GenBuffers = Switch_GenBuffers; + IsBuffer = Switch_IsBuffer; + BufferData = Switch_BufferData; + BufferSubData = Switch_BufferSubData; + GetBufferSubData = Switch_GetBufferSubData; + MapBuffer = Switch_MapBuffer; + UnmapBuffer = Switch_UnmapBuffer; + GetBufferParameteriv = Switch_GetBufferParameteriv; + GetBufferPointerv = Switch_GetBufferPointerv; + + // Extension: 2.0 + BlendEquationSeparate = Switch_BlendEquationSeparate; + DrawBuffers = Switch_DrawBuffers; + StencilOpSeparate = Switch_StencilOpSeparate; + StencilFuncSeparate = Switch_StencilFuncSeparate; + StencilMaskSeparate = Switch_StencilMaskSeparate; + AttachShader = Switch_AttachShader; + BindAttribLocation = Switch_BindAttribLocation; + CompileShader = Switch_CompileShader; + CreateProgram = Switch_CreateProgram; + CreateShader = Switch_CreateShader; + DeleteProgram = Switch_DeleteProgram; + DeleteShader = Switch_DeleteShader; + DetachShader = Switch_DetachShader; + DisableVertexAttribArray = Switch_DisableVertexAttribArray; + EnableVertexAttribArray = Switch_EnableVertexAttribArray; + GetActiveAttrib = Switch_GetActiveAttrib; + GetActiveUniform = Switch_GetActiveUniform; + GetAttachedShaders = Switch_GetAttachedShaders; + GetAttribLocation = Switch_GetAttribLocation; + GetProgramiv = Switch_GetProgramiv; + GetProgramInfoLog = Switch_GetProgramInfoLog; + GetShaderiv = Switch_GetShaderiv; + GetShaderInfoLog = Switch_GetShaderInfoLog; + GetShaderSource = Switch_GetShaderSource; + GetUniformLocation = Switch_GetUniformLocation; + GetUniformfv = Switch_GetUniformfv; + GetUniformiv = Switch_GetUniformiv; + GetVertexAttribdv = Switch_GetVertexAttribdv; + GetVertexAttribfv = Switch_GetVertexAttribfv; + GetVertexAttribiv = Switch_GetVertexAttribiv; + GetVertexAttribPointerv = Switch_GetVertexAttribPointerv; + IsProgram = Switch_IsProgram; + IsShader = Switch_IsShader; + LinkProgram = Switch_LinkProgram; + ShaderSource = Switch_ShaderSource; + UseProgram = Switch_UseProgram; + Uniform1f = Switch_Uniform1f; + Uniform2f = Switch_Uniform2f; + Uniform3f = Switch_Uniform3f; + Uniform4f = Switch_Uniform4f; + Uniform1i = Switch_Uniform1i; + Uniform2i = Switch_Uniform2i; + Uniform3i = Switch_Uniform3i; + Uniform4i = Switch_Uniform4i; + Uniform1fv = Switch_Uniform1fv; + Uniform2fv = Switch_Uniform2fv; + Uniform3fv = Switch_Uniform3fv; + Uniform4fv = Switch_Uniform4fv; + Uniform1iv = Switch_Uniform1iv; + Uniform2iv = Switch_Uniform2iv; + Uniform3iv = Switch_Uniform3iv; + Uniform4iv = Switch_Uniform4iv; + UniformMatrix2fv = Switch_UniformMatrix2fv; + UniformMatrix3fv = Switch_UniformMatrix3fv; + UniformMatrix4fv = Switch_UniformMatrix4fv; + ValidateProgram = Switch_ValidateProgram; + VertexAttribPointer = Switch_VertexAttribPointer; + + // Extension: 2.1 + UniformMatrix2x3fv = Switch_UniformMatrix2x3fv; + UniformMatrix3x2fv = Switch_UniformMatrix3x2fv; + UniformMatrix2x4fv = Switch_UniformMatrix2x4fv; + UniformMatrix4x2fv = Switch_UniformMatrix4x2fv; + UniformMatrix3x4fv = Switch_UniformMatrix3x4fv; + UniformMatrix4x3fv = Switch_UniformMatrix4x3fv; + + // Extension: ARB_vertex_array_object + BindVertexArray = Switch_BindVertexArray; + DeleteVertexArrays = Switch_DeleteVertexArrays; + GenVertexArrays = Switch_GenVertexArrays; + IsVertexArray = Switch_IsVertexArray; + + // Extension: ARB_map_buffer_range + MapBufferRange = Switch_MapBufferRange; + FlushMappedBufferRange = Switch_FlushMappedBufferRange; + + // Extension: ARB_framebuffer_object + IsRenderbuffer = Switch_IsRenderbuffer; + BindRenderbuffer = Switch_BindRenderbuffer; + DeleteRenderbuffers = Switch_DeleteRenderbuffers; + GenRenderbuffers = Switch_GenRenderbuffers; + RenderbufferStorage = Switch_RenderbufferStorage; + GetRenderbufferParameteriv = Switch_GetRenderbufferParameteriv; + IsFramebuffer = Switch_IsFramebuffer; + BindFramebuffer = Switch_BindFramebuffer; + DeleteFramebuffers = Switch_DeleteFramebuffers; + GenFramebuffers = Switch_GenFramebuffers; + CheckFramebufferStatus = Switch_CheckFramebufferStatus; + FramebufferTexture1D = Switch_FramebufferTexture1D; + FramebufferTexture2D = Switch_FramebufferTexture2D; + FramebufferTexture3D = Switch_FramebufferTexture3D; + FramebufferRenderbuffer = Switch_FramebufferRenderbuffer; + GetFramebufferAttachmentParameteriv = Switch_GetFramebufferAttachmentParameteriv; + GenerateMipmap = Switch_GenerateMipmap; + BlitFramebuffer = Switch_BlitFramebuffer; + RenderbufferStorageMultisample = Switch_RenderbufferStorageMultisample; + FramebufferTextureLayer = Switch_FramebufferTextureLayer; + + // Extension: 3.0 + ColorMaski = Switch_ColorMaski; + GetBooleani_v = Switch_GetBooleani_v; + GetIntegeri_v = Switch_GetIntegeri_v; + Enablei = Switch_Enablei; + Disablei = Switch_Disablei; + IsEnabledi = Switch_IsEnabledi; + BeginTransformFeedback = Switch_BeginTransformFeedback; + EndTransformFeedback = Switch_EndTransformFeedback; + BindBufferRange = Switch_BindBufferRange; + BindBufferBase = Switch_BindBufferBase; + TransformFeedbackVaryings = Switch_TransformFeedbackVaryings; + GetTransformFeedbackVarying = Switch_GetTransformFeedbackVarying; + ClampColor = Switch_ClampColor; + BeginConditionalRender = Switch_BeginConditionalRender; + EndConditionalRender = Switch_EndConditionalRender; + VertexAttribIPointer = Switch_VertexAttribIPointer; + GetVertexAttribIiv = Switch_GetVertexAttribIiv; + GetVertexAttribIuiv = Switch_GetVertexAttribIuiv; + VertexAttribI1i = Switch_VertexAttribI1i; + VertexAttribI2i = Switch_VertexAttribI2i; + VertexAttribI3i = Switch_VertexAttribI3i; + VertexAttribI4i = Switch_VertexAttribI4i; + VertexAttribI1ui = Switch_VertexAttribI1ui; + VertexAttribI2ui = Switch_VertexAttribI2ui; + VertexAttribI3ui = Switch_VertexAttribI3ui; + VertexAttribI4ui = Switch_VertexAttribI4ui; + VertexAttribI1iv = Switch_VertexAttribI1iv; + VertexAttribI2iv = Switch_VertexAttribI2iv; + VertexAttribI3iv = Switch_VertexAttribI3iv; + VertexAttribI4iv = Switch_VertexAttribI4iv; + VertexAttribI1uiv = Switch_VertexAttribI1uiv; + VertexAttribI2uiv = Switch_VertexAttribI2uiv; + VertexAttribI3uiv = Switch_VertexAttribI3uiv; + VertexAttribI4uiv = Switch_VertexAttribI4uiv; + VertexAttribI4bv = Switch_VertexAttribI4bv; + VertexAttribI4sv = Switch_VertexAttribI4sv; + VertexAttribI4ubv = Switch_VertexAttribI4ubv; + VertexAttribI4usv = Switch_VertexAttribI4usv; + GetUniformuiv = Switch_GetUniformuiv; + BindFragDataLocation = Switch_BindFragDataLocation; + GetFragDataLocation = Switch_GetFragDataLocation; + Uniform1ui = Switch_Uniform1ui; + Uniform2ui = Switch_Uniform2ui; + Uniform3ui = Switch_Uniform3ui; + Uniform4ui = Switch_Uniform4ui; + Uniform1uiv = Switch_Uniform1uiv; + Uniform2uiv = Switch_Uniform2uiv; + Uniform3uiv = Switch_Uniform3uiv; + Uniform4uiv = Switch_Uniform4uiv; + TexParameterIiv = Switch_TexParameterIiv; + TexParameterIuiv = Switch_TexParameterIuiv; + GetTexParameterIiv = Switch_GetTexParameterIiv; + GetTexParameterIuiv = Switch_GetTexParameterIuiv; + ClearBufferiv = Switch_ClearBufferiv; + ClearBufferuiv = Switch_ClearBufferuiv; + ClearBufferfv = Switch_ClearBufferfv; + ClearBufferfi = Switch_ClearBufferfi; + GetStringi = Switch_GetStringi; + + // Extension: ARB_uniform_buffer_object + GetUniformIndices = Switch_GetUniformIndices; + GetActiveUniformsiv = Switch_GetActiveUniformsiv; + GetActiveUniformName = Switch_GetActiveUniformName; + GetUniformBlockIndex = Switch_GetUniformBlockIndex; + GetActiveUniformBlockiv = Switch_GetActiveUniformBlockiv; + GetActiveUniformBlockName = Switch_GetActiveUniformBlockName; + UniformBlockBinding = Switch_UniformBlockBinding; + + // Extension: ARB_copy_buffer + CopyBufferSubData = Switch_CopyBufferSubData; + + // Extension: 3.1 + DrawArraysInstanced = Switch_DrawArraysInstanced; + DrawElementsInstanced = Switch_DrawElementsInstanced; + TexBuffer = Switch_TexBuffer; + PrimitiveRestartIndex = Switch_PrimitiveRestartIndex; + + // Legacy + EnableClientState = Switch_EnableClientState; + DisableClientState = Switch_DisableClientState; + VertexPointer = Switch_VertexPointer; + NormalPointer = Switch_NormalPointer; + ColorPointer = Switch_ColorPointer; + TexCoordPointer = Switch_TexCoordPointer; + + TexEnvi = Switch_TexEnvi; + + MatrixMode = Switch_MatrixMode; + LoadIdentity = Switch_LoadIdentity; + Ortho = Switch_Ortho; + + Color3d = Switch_Color3d; + + } + }; + + InitializeVariables g_initVariables; + } + + namespace sys + { + namespace + { + void ClearExtensionVariables() + { + } + + struct MapEntry + { + const char *extName; + bool *extVariable; + }; + + struct MapCompare + { + MapCompare(const char *test_) : test(test_) {} + bool operator()(const MapEntry &other) { return strcmp(test, other.extName) == 0; } + const char *test; + }; + + struct ClearEntry + { + void operator()(MapEntry &entry) { *(entry.extVariable) = false;} + }; + + MapEntry g_mappingTable[1] = + { + }; + + void LoadExtByName(const char *extensionName) + { + MapEntry *tableEnd = &g_mappingTable[0]; + MapEntry *entry = std::find_if(&g_mappingTable[0], tableEnd, MapCompare(extensionName)); + + if(entry != tableEnd) + *(entry->extVariable) = true; + } + + void ProcExtsFromExtList() + { + GLint iLoop; + GLint iNumExtensions = 0; + GetIntegerv(NUM_EXTENSIONS, &iNumExtensions); + + for(iLoop = 0; iLoop < iNumExtensions; iLoop++) + { + const char *strExtensionName = (const char *)GetStringi(EXTENSIONS, iLoop); + LoadExtByName(strExtensionName); + } + } + } + void CheckExtensions() + { + ClearExtensionVariables(); + std::for_each(&g_mappingTable[0], &g_mappingTable[0], ClearEntry()); + + ProcExtsFromExtList(); + } + + } +} + +#endif diff --git a/modules/core/src/gl_core_3_1.hpp b/modules/core/src/gl_core_3_1.hpp new file mode 100644 index 0000000000..711ebe9ab7 --- /dev/null +++ b/modules/core/src/gl_core_3_1.hpp @@ -0,0 +1,1342 @@ +#ifndef OPENGL_NOLOAD_STYLE_HPP +#define OPENGL_NOLOAD_STYLE_HPP + +#if defined(__gl_h_) || defined(__GL_H__) +#error Attempt to include auto-generated header after including gl.h +#endif +#if defined(__glext_h_) || defined(__GLEXT_H_) +#error Attempt to include auto-generated header after including glext.h +#endif +#if defined(__gl_ATI_h_) +#error Attempt to include auto-generated header after including glATI.h +#endif + +#define __gl_h_ +#define __GL_H__ +#define __glext_h_ +#define __GLEXT_H_ +#define __gl_ATI_h_ + +#ifndef APIENTRY + #if defined(__MINGW32__) + #ifndef WIN32_LEAN_AND_MEAN + #define WIN32_LEAN_AND_MEAN 1 + #endif + #ifndef NOMINMAX + #define NOMINMAX + #endif + #include + #elif (defined(_MSC_VER) && _MSC_VER >= 800) || defined(_STDCALL_SUPPORTED) || defined(__BORLANDC__) + #ifndef WIN32_LEAN_AND_MEAN + #define WIN32_LEAN_AND_MEAN 1 + #endif + #ifndef NOMINMAX + #define NOMINMAX + #endif + #include + #else + #define APIENTRY + #endif +#endif /*APIENTRY*/ + +#ifndef CODEGEN_FUNCPTR + #define CODEGEN_REMOVE_FUNCPTR + #if defined(_WIN32) + #define CODEGEN_FUNCPTR APIENTRY + #else + #define CODEGEN_FUNCPTR + #endif +#endif /*CODEGEN_FUNCPTR*/ + +#ifndef GLAPI + #define GLAPI extern +#endif + + +#ifndef GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS +#define GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS + + typedef unsigned int GLenum; + typedef unsigned char GLboolean; + typedef unsigned int GLbitfield; + typedef signed char GLbyte; + typedef short GLshort; + typedef int GLint; + typedef int GLsizei; + typedef unsigned char GLubyte; + typedef unsigned short GLushort; + typedef unsigned int GLuint; + typedef float GLfloat; + typedef float GLclampf; + typedef double GLdouble; + typedef double GLclampd; + #define GLvoid void + +#endif /*GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS*/ + +#include +#ifndef GL_VERSION_2_0 + /* GL type for program/shader text */ + typedef char GLchar; +#endif +#ifndef GL_VERSION_1_5 + /* GL types for handling large vertex buffer objects */ + typedef ptrdiff_t GLintptr; + typedef ptrdiff_t GLsizeiptr; +#endif +#ifndef GL_ARB_vertex_buffer_object + /* GL types for handling large vertex buffer objects */ + typedef ptrdiff_t GLintptrARB; + typedef ptrdiff_t GLsizeiptrARB; +#endif +#ifndef GL_ARB_shader_objects + /* GL types for program/shader text and shader object handles */ + typedef char GLcharARB; + typedef unsigned int GLhandleARB; +#endif +/* GL type for "half" precision (s10e5) float data in host memory */ +#ifndef GL_ARB_half_float_pixel + typedef unsigned short GLhalfARB; +#endif +#ifndef GL_NV_half_float + typedef unsigned short GLhalfNV; +#endif +#ifndef GLEXT_64_TYPES_DEFINED + /* This code block is duplicated in glxext.h, so must be protected */ + #define GLEXT_64_TYPES_DEFINED + /* Define int32_t, int64_t, and uint64_t types for UST/MSC */ + /* (as used in the GL_EXT_timer_query extension). */ + #if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #include + #elif defined(__sun__) || defined(__digital__) + #include + #if defined(__STDC__) + #if defined(__arch64__) || defined(_LP64) + typedef long int int64_t; + typedef unsigned long int uint64_t; + #else + typedef long long int int64_t; + typedef unsigned long long int uint64_t; + #endif /* __arch64__ */ + #endif /* __STDC__ */ + #elif defined( __VMS ) || defined(__sgi) + #include + #elif defined(__SCO__) || defined(__USLC__) + #include + #elif defined(__UNIXOS2__) || defined(__SOL64__) + typedef long int int32_t; + typedef long long int int64_t; + typedef unsigned long long int uint64_t; + #elif defined(_WIN32) && defined(__GNUC__) + #include + #elif defined(_WIN32) + typedef __int32 int32_t; + typedef __int64 int64_t; + typedef unsigned __int64 uint64_t; + #else + /* Fallback if nothing above works */ + #include + #endif +#endif +#ifndef GL_EXT_timer_query + typedef int64_t GLint64EXT; + typedef uint64_t GLuint64EXT; +#endif +#ifndef GL_ARB_sync + typedef int64_t GLint64; + typedef uint64_t GLuint64; + typedef struct __GLsync *GLsync; +#endif +#ifndef GL_ARB_cl_event + /* These incomplete types let us declare types compatible with OpenCL's cl_context and cl_event */ + struct _cl_context; + struct _cl_event; +#endif +#ifndef GL_ARB_debug_output + typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam); +#endif +#ifndef GL_AMD_debug_output + typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam); +#endif +#ifndef GL_KHR_debug + typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,GLvoid *userParam); +#endif +#ifndef GL_NV_vdpau_interop + typedef GLintptr GLvdpauSurfaceNV; +#endif + +namespace gl +{ + ///////////////////////// + // Extension Variables + namespace exts + { + } + + enum + { + // Version: 1.1 + DEPTH_BUFFER_BIT = 0x00000100, + STENCIL_BUFFER_BIT = 0x00000400, + COLOR_BUFFER_BIT = 0x00004000, + FALSE_ = 0, + TRUE_ = 1, + POINTS = 0x0000, + LINES = 0x0001, + LINE_LOOP = 0x0002, + LINE_STRIP = 0x0003, + TRIANGLES = 0x0004, + TRIANGLE_STRIP = 0x0005, + TRIANGLE_FAN = 0x0006, + QUADS = 0x0007, + NEVER = 0x0200, + LESS = 0x0201, + EQUAL = 0x0202, + LEQUAL = 0x0203, + GREATER = 0x0204, + NOTEQUAL = 0x0205, + GEQUAL = 0x0206, + ALWAYS = 0x0207, + ZERO = 0, + ONE = 1, + SRC_COLOR = 0x0300, + ONE_MINUS_SRC_COLOR = 0x0301, + SRC_ALPHA = 0x0302, + ONE_MINUS_SRC_ALPHA = 0x0303, + DST_ALPHA = 0x0304, + ONE_MINUS_DST_ALPHA = 0x0305, + DST_COLOR = 0x0306, + ONE_MINUS_DST_COLOR = 0x0307, + SRC_ALPHA_SATURATE = 0x0308, + NONE = 0, + FRONT_LEFT = 0x0400, + FRONT_RIGHT = 0x0401, + BACK_LEFT = 0x0402, + BACK_RIGHT = 0x0403, + FRONT = 0x0404, + BACK = 0x0405, + LEFT = 0x0406, + RIGHT = 0x0407, + FRONT_AND_BACK = 0x0408, + NO_ERROR_ = 0, + INVALID_ENUM = 0x0500, + INVALID_VALUE = 0x0501, + INVALID_OPERATION = 0x0502, + OUT_OF_MEMORY = 0x0505, + CW = 0x0900, + CCW = 0x0901, + POINT_SIZE = 0x0B11, + POINT_SIZE_RANGE = 0x0B12, + POINT_SIZE_GRANULARITY = 0x0B13, + LINE_SMOOTH = 0x0B20, + LINE_WIDTH = 0x0B21, + LINE_WIDTH_RANGE = 0x0B22, + LINE_WIDTH_GRANULARITY = 0x0B23, + POLYGON_MODE = 0x0B40, + POLYGON_SMOOTH = 0x0B41, + CULL_FACE = 0x0B44, + CULL_FACE_MODE = 0x0B45, + FRONT_FACE = 0x0B46, + DEPTH_RANGE = 0x0B70, + DEPTH_TEST = 0x0B71, + DEPTH_WRITEMASK = 0x0B72, + DEPTH_CLEAR_VALUE = 0x0B73, + DEPTH_FUNC = 0x0B74, + STENCIL_TEST = 0x0B90, + STENCIL_CLEAR_VALUE = 0x0B91, + STENCIL_FUNC = 0x0B92, + STENCIL_VALUE_MASK = 0x0B93, + STENCIL_FAIL = 0x0B94, + STENCIL_PASS_DEPTH_FAIL = 0x0B95, + STENCIL_PASS_DEPTH_PASS = 0x0B96, + STENCIL_REF = 0x0B97, + STENCIL_WRITEMASK = 0x0B98, + VIEWPORT = 0x0BA2, + DITHER = 0x0BD0, + BLEND_DST = 0x0BE0, + BLEND_SRC = 0x0BE1, + BLEND = 0x0BE2, + LOGIC_OP_MODE = 0x0BF0, + COLOR_LOGIC_OP = 0x0BF2, + DRAW_BUFFER = 0x0C01, + READ_BUFFER = 0x0C02, + SCISSOR_BOX = 0x0C10, + SCISSOR_TEST = 0x0C11, + COLOR_CLEAR_VALUE = 0x0C22, + COLOR_WRITEMASK = 0x0C23, + DOUBLEBUFFER = 0x0C32, + STEREO = 0x0C33, + LINE_SMOOTH_HINT = 0x0C52, + POLYGON_SMOOTH_HINT = 0x0C53, + UNPACK_SWAP_BYTES = 0x0CF0, + UNPACK_LSB_FIRST = 0x0CF1, + UNPACK_ROW_LENGTH = 0x0CF2, + UNPACK_SKIP_ROWS = 0x0CF3, + UNPACK_SKIP_PIXELS = 0x0CF4, + UNPACK_ALIGNMENT = 0x0CF5, + PACK_SWAP_BYTES = 0x0D00, + PACK_LSB_FIRST = 0x0D01, + PACK_ROW_LENGTH = 0x0D02, + PACK_SKIP_ROWS = 0x0D03, + PACK_SKIP_PIXELS = 0x0D04, + PACK_ALIGNMENT = 0x0D05, + MAX_TEXTURE_SIZE = 0x0D33, + MAX_VIEWPORT_DIMS = 0x0D3A, + SUBPIXEL_BITS = 0x0D50, + TEXTURE_1D = 0x0DE0, + TEXTURE_2D = 0x0DE1, + POLYGON_OFFSET_UNITS = 0x2A00, + POLYGON_OFFSET_POINT = 0x2A01, + POLYGON_OFFSET_LINE = 0x2A02, + POLYGON_OFFSET_FILL = 0x8037, + POLYGON_OFFSET_FACTOR = 0x8038, + TEXTURE_BINDING_1D = 0x8068, + TEXTURE_BINDING_2D = 0x8069, + TEXTURE_WIDTH = 0x1000, + TEXTURE_HEIGHT = 0x1001, + TEXTURE_INTERNAL_FORMAT = 0x1003, + TEXTURE_BORDER_COLOR = 0x1004, + TEXTURE_RED_SIZE = 0x805C, + TEXTURE_GREEN_SIZE = 0x805D, + TEXTURE_BLUE_SIZE = 0x805E, + TEXTURE_ALPHA_SIZE = 0x805F, + DONT_CARE = 0x1100, + FASTEST = 0x1101, + NICEST = 0x1102, + BYTE = 0x1400, + UNSIGNED_BYTE = 0x1401, + SHORT = 0x1402, + UNSIGNED_SHORT = 0x1403, + INT = 0x1404, + UNSIGNED_INT = 0x1405, + FLOAT = 0x1406, + DOUBLE = 0x140A, + CLEAR = 0x1500, + AND = 0x1501, + AND_REVERSE = 0x1502, + COPY = 0x1503, + AND_INVERTED = 0x1504, + NOOP = 0x1505, + XOR = 0x1506, + OR = 0x1507, + NOR = 0x1508, + EQUIV = 0x1509, + INVERT = 0x150A, + OR_REVERSE = 0x150B, + COPY_INVERTED = 0x150C, + OR_INVERTED = 0x150D, + NAND = 0x150E, + SET = 0x150F, + TEXTURE = 0x1702, + COLOR = 0x1800, + DEPTH = 0x1801, + STENCIL = 0x1802, + STENCIL_INDEX = 0x1901, + DEPTH_COMPONENT = 0x1902, + RED = 0x1903, + GREEN = 0x1904, + BLUE = 0x1905, + ALPHA = 0x1906, + RGB = 0x1907, + RGBA = 0x1908, + POINT = 0x1B00, + LINE = 0x1B01, + FILL = 0x1B02, + KEEP = 0x1E00, + REPLACE = 0x1E01, + INCR = 0x1E02, + DECR = 0x1E03, + VENDOR = 0x1F00, + RENDERER = 0x1F01, + VERSION_ = 0x1F02, + EXTENSIONS = 0x1F03, + NEAREST = 0x2600, + LINEAR = 0x2601, + NEAREST_MIPMAP_NEAREST = 0x2700, + LINEAR_MIPMAP_NEAREST = 0x2701, + NEAREST_MIPMAP_LINEAR = 0x2702, + LINEAR_MIPMAP_LINEAR = 0x2703, + TEXTURE_MAG_FILTER = 0x2800, + TEXTURE_MIN_FILTER = 0x2801, + TEXTURE_WRAP_S = 0x2802, + TEXTURE_WRAP_T = 0x2803, + PROXY_TEXTURE_1D = 0x8063, + PROXY_TEXTURE_2D = 0x8064, + REPEAT = 0x2901, + R3_G3_B2 = 0x2A10, + RGB4 = 0x804F, + RGB5 = 0x8050, + RGB8 = 0x8051, + RGB10 = 0x8052, + RGB12 = 0x8053, + RGB16 = 0x8054, + RGBA2 = 0x8055, + RGBA4 = 0x8056, + RGB5_A1 = 0x8057, + RGBA8 = 0x8058, + RGB10_A2 = 0x8059, + RGBA12 = 0x805A, + RGBA16 = 0x805B, + + // Core Extension: ARB_imaging + CONSTANT_COLOR = 0x8001, + ONE_MINUS_CONSTANT_COLOR = 0x8002, + CONSTANT_ALPHA = 0x8003, + ONE_MINUS_CONSTANT_ALPHA = 0x8004, + BLEND_COLOR = 0x8005, + FUNC_ADD = 0x8006, + MIN = 0x8007, + MAX = 0x8008, + BLEND_EQUATION = 0x8009, + FUNC_SUBTRACT = 0x800A, + FUNC_REVERSE_SUBTRACT = 0x800B, + CONVOLUTION_1D = 0x8010, + CONVOLUTION_2D = 0x8011, + SEPARABLE_2D = 0x8012, + CONVOLUTION_BORDER_MODE = 0x8013, + CONVOLUTION_FILTER_SCALE = 0x8014, + CONVOLUTION_FILTER_BIAS = 0x8015, + REDUCE = 0x8016, + CONVOLUTION_FORMAT = 0x8017, + CONVOLUTION_WIDTH = 0x8018, + CONVOLUTION_HEIGHT = 0x8019, + MAX_CONVOLUTION_WIDTH = 0x801A, + MAX_CONVOLUTION_HEIGHT = 0x801B, + POST_CONVOLUTION_RED_SCALE = 0x801C, + POST_CONVOLUTION_GREEN_SCALE = 0x801D, + POST_CONVOLUTION_BLUE_SCALE = 0x801E, + POST_CONVOLUTION_ALPHA_SCALE = 0x801F, + POST_CONVOLUTION_RED_BIAS = 0x8020, + POST_CONVOLUTION_GREEN_BIAS = 0x8021, + POST_CONVOLUTION_BLUE_BIAS = 0x8022, + POST_CONVOLUTION_ALPHA_BIAS = 0x8023, + HISTOGRAM = 0x8024, + PROXY_HISTOGRAM = 0x8025, + HISTOGRAM_WIDTH = 0x8026, + HISTOGRAM_FORMAT = 0x8027, + HISTOGRAM_RED_SIZE = 0x8028, + HISTOGRAM_GREEN_SIZE = 0x8029, + HISTOGRAM_BLUE_SIZE = 0x802A, + HISTOGRAM_ALPHA_SIZE = 0x802B, + HISTOGRAM_LUMINANCE_SIZE = 0x802C, + HISTOGRAM_SINK = 0x802D, + MINMAX = 0x802E, + MINMAX_FORMAT = 0x802F, + MINMAX_SINK = 0x8030, + TABLE_TOO_LARGE = 0x8031, + COLOR_MATRIX = 0x80B1, + COLOR_MATRIX_STACK_DEPTH = 0x80B2, + MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3, + POST_COLOR_MATRIX_RED_SCALE = 0x80B4, + POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5, + POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6, + POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7, + POST_COLOR_MATRIX_RED_BIAS = 0x80B8, + POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9, + POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA, + POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB, + COLOR_TABLE = 0x80D0, + POST_CONVOLUTION_COLOR_TABLE = 0x80D1, + POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2, + PROXY_COLOR_TABLE = 0x80D3, + PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4, + PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5, + COLOR_TABLE_SCALE = 0x80D6, + COLOR_TABLE_BIAS = 0x80D7, + COLOR_TABLE_FORMAT = 0x80D8, + COLOR_TABLE_WIDTH = 0x80D9, + COLOR_TABLE_RED_SIZE = 0x80DA, + COLOR_TABLE_GREEN_SIZE = 0x80DB, + COLOR_TABLE_BLUE_SIZE = 0x80DC, + COLOR_TABLE_ALPHA_SIZE = 0x80DD, + COLOR_TABLE_LUMINANCE_SIZE = 0x80DE, + COLOR_TABLE_INTENSITY_SIZE = 0x80DF, + CONSTANT_BORDER = 0x8151, + REPLICATE_BORDER = 0x8153, + CONVOLUTION_BORDER_COLOR = 0x8154, + + // Version: 1.2 + UNSIGNED_BYTE_3_3_2 = 0x8032, + UNSIGNED_SHORT_4_4_4_4 = 0x8033, + UNSIGNED_SHORT_5_5_5_1 = 0x8034, + UNSIGNED_INT_8_8_8_8 = 0x8035, + UNSIGNED_INT_10_10_10_2 = 0x8036, + TEXTURE_BINDING_3D = 0x806A, + PACK_SKIP_IMAGES = 0x806B, + PACK_IMAGE_HEIGHT = 0x806C, + UNPACK_SKIP_IMAGES = 0x806D, + UNPACK_IMAGE_HEIGHT = 0x806E, + TEXTURE_3D = 0x806F, + PROXY_TEXTURE_3D = 0x8070, + TEXTURE_DEPTH = 0x8071, + TEXTURE_WRAP_R = 0x8072, + MAX_3D_TEXTURE_SIZE = 0x8073, + UNSIGNED_BYTE_2_3_3_REV = 0x8362, + UNSIGNED_SHORT_5_6_5 = 0x8363, + UNSIGNED_SHORT_5_6_5_REV = 0x8364, + UNSIGNED_SHORT_4_4_4_4_REV = 0x8365, + UNSIGNED_SHORT_1_5_5_5_REV = 0x8366, + UNSIGNED_INT_8_8_8_8_REV = 0x8367, + UNSIGNED_INT_2_10_10_10_REV = 0x8368, + BGR = 0x80E0, + BGRA = 0x80E1, + MAX_ELEMENTS_VERTICES = 0x80E8, + MAX_ELEMENTS_INDICES = 0x80E9, + CLAMP_TO_EDGE = 0x812F, + TEXTURE_MIN_LOD = 0x813A, + TEXTURE_MAX_LOD = 0x813B, + TEXTURE_BASE_LEVEL = 0x813C, + TEXTURE_MAX_LEVEL = 0x813D, + SMOOTH_POINT_SIZE_RANGE = 0x0B12, + SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13, + SMOOTH_LINE_WIDTH_RANGE = 0x0B22, + SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23, + ALIASED_LINE_WIDTH_RANGE = 0x846E, + + // Version: 1.3 + TEXTURE0 = 0x84C0, + TEXTURE1 = 0x84C1, + TEXTURE2 = 0x84C2, + TEXTURE3 = 0x84C3, + TEXTURE4 = 0x84C4, + TEXTURE5 = 0x84C5, + TEXTURE6 = 0x84C6, + TEXTURE7 = 0x84C7, + TEXTURE8 = 0x84C8, + TEXTURE9 = 0x84C9, + TEXTURE10 = 0x84CA, + TEXTURE11 = 0x84CB, + TEXTURE12 = 0x84CC, + TEXTURE13 = 0x84CD, + TEXTURE14 = 0x84CE, + TEXTURE15 = 0x84CF, + TEXTURE16 = 0x84D0, + TEXTURE17 = 0x84D1, + TEXTURE18 = 0x84D2, + TEXTURE19 = 0x84D3, + TEXTURE20 = 0x84D4, + TEXTURE21 = 0x84D5, + TEXTURE22 = 0x84D6, + TEXTURE23 = 0x84D7, + TEXTURE24 = 0x84D8, + TEXTURE25 = 0x84D9, + TEXTURE26 = 0x84DA, + TEXTURE27 = 0x84DB, + TEXTURE28 = 0x84DC, + TEXTURE29 = 0x84DD, + TEXTURE30 = 0x84DE, + TEXTURE31 = 0x84DF, + ACTIVE_TEXTURE = 0x84E0, + MULTISAMPLE = 0x809D, + SAMPLE_ALPHA_TO_COVERAGE = 0x809E, + SAMPLE_ALPHA_TO_ONE = 0x809F, + SAMPLE_COVERAGE = 0x80A0, + SAMPLE_BUFFERS = 0x80A8, + SAMPLES = 0x80A9, + SAMPLE_COVERAGE_VALUE = 0x80AA, + SAMPLE_COVERAGE_INVERT = 0x80AB, + TEXTURE_CUBE_MAP = 0x8513, + TEXTURE_BINDING_CUBE_MAP = 0x8514, + TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515, + TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516, + TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517, + TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518, + TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519, + TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A, + PROXY_TEXTURE_CUBE_MAP = 0x851B, + MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C, + COMPRESSED_RGB = 0x84ED, + COMPRESSED_RGBA = 0x84EE, + TEXTURE_COMPRESSION_HINT = 0x84EF, + TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0, + TEXTURE_COMPRESSED = 0x86A1, + NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2, + COMPRESSED_TEXTURE_FORMATS = 0x86A3, + CLAMP_TO_BORDER = 0x812D, + + // Version: 1.4 + BLEND_DST_RGB = 0x80C8, + BLEND_SRC_RGB = 0x80C9, + BLEND_DST_ALPHA = 0x80CA, + BLEND_SRC_ALPHA = 0x80CB, + POINT_FADE_THRESHOLD_SIZE = 0x8128, + DEPTH_COMPONENT16 = 0x81A5, + DEPTH_COMPONENT24 = 0x81A6, + DEPTH_COMPONENT32 = 0x81A7, + MIRRORED_REPEAT = 0x8370, + MAX_TEXTURE_LOD_BIAS = 0x84FD, + TEXTURE_LOD_BIAS = 0x8501, + INCR_WRAP = 0x8507, + DECR_WRAP = 0x8508, + TEXTURE_DEPTH_SIZE = 0x884A, + TEXTURE_COMPARE_MODE = 0x884C, + TEXTURE_COMPARE_FUNC = 0x884D, + + // Version: 1.5 + BUFFER_SIZE = 0x8764, + BUFFER_USAGE = 0x8765, + QUERY_COUNTER_BITS = 0x8864, + CURRENT_QUERY = 0x8865, + QUERY_RESULT = 0x8866, + QUERY_RESULT_AVAILABLE = 0x8867, + ARRAY_BUFFER = 0x8892, + ELEMENT_ARRAY_BUFFER = 0x8893, + ARRAY_BUFFER_BINDING = 0x8894, + ELEMENT_ARRAY_BUFFER_BINDING = 0x8895, + VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F, + READ_ONLY = 0x88B8, + WRITE_ONLY = 0x88B9, + READ_WRITE = 0x88BA, + BUFFER_ACCESS = 0x88BB, + BUFFER_MAPPED = 0x88BC, + BUFFER_MAP_POINTER = 0x88BD, + STREAM_DRAW = 0x88E0, + STREAM_READ = 0x88E1, + STREAM_COPY = 0x88E2, + STATIC_DRAW = 0x88E4, + STATIC_READ = 0x88E5, + STATIC_COPY = 0x88E6, + DYNAMIC_DRAW = 0x88E8, + DYNAMIC_READ = 0x88E9, + DYNAMIC_COPY = 0x88EA, + SAMPLES_PASSED = 0x8914, + SRC1_ALPHA = 0x8589, + + // Version: 2.0 + BLEND_EQUATION_RGB = 0x8009, + VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622, + VERTEX_ATTRIB_ARRAY_SIZE = 0x8623, + VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624, + VERTEX_ATTRIB_ARRAY_TYPE = 0x8625, + CURRENT_VERTEX_ATTRIB = 0x8626, + VERTEX_PROGRAM_POINT_SIZE = 0x8642, + VERTEX_ATTRIB_ARRAY_POINTER = 0x8645, + STENCIL_BACK_FUNC = 0x8800, + STENCIL_BACK_FAIL = 0x8801, + STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802, + STENCIL_BACK_PASS_DEPTH_PASS = 0x8803, + MAX_DRAW_BUFFERS = 0x8824, + DRAW_BUFFER0 = 0x8825, + DRAW_BUFFER1 = 0x8826, + DRAW_BUFFER2 = 0x8827, + DRAW_BUFFER3 = 0x8828, + DRAW_BUFFER4 = 0x8829, + DRAW_BUFFER5 = 0x882A, + DRAW_BUFFER6 = 0x882B, + DRAW_BUFFER7 = 0x882C, + DRAW_BUFFER8 = 0x882D, + DRAW_BUFFER9 = 0x882E, + DRAW_BUFFER10 = 0x882F, + DRAW_BUFFER11 = 0x8830, + DRAW_BUFFER12 = 0x8831, + DRAW_BUFFER13 = 0x8832, + DRAW_BUFFER14 = 0x8833, + DRAW_BUFFER15 = 0x8834, + BLEND_EQUATION_ALPHA = 0x883D, + MAX_VERTEX_ATTRIBS = 0x8869, + VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A, + MAX_TEXTURE_IMAGE_UNITS = 0x8872, + FRAGMENT_SHADER = 0x8B30, + VERTEX_SHADER = 0x8B31, + MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49, + MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A, + MAX_VARYING_FLOATS = 0x8B4B, + MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C, + MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D, + SHADER_TYPE = 0x8B4F, + FLOAT_VEC2 = 0x8B50, + FLOAT_VEC3 = 0x8B51, + FLOAT_VEC4 = 0x8B52, + INT_VEC2 = 0x8B53, + INT_VEC3 = 0x8B54, + INT_VEC4 = 0x8B55, + BOOL = 0x8B56, + BOOL_VEC2 = 0x8B57, + BOOL_VEC3 = 0x8B58, + BOOL_VEC4 = 0x8B59, + FLOAT_MAT2 = 0x8B5A, + FLOAT_MAT3 = 0x8B5B, + FLOAT_MAT4 = 0x8B5C, + SAMPLER_1D = 0x8B5D, + SAMPLER_2D = 0x8B5E, + SAMPLER_3D = 0x8B5F, + SAMPLER_CUBE = 0x8B60, + SAMPLER_1D_SHADOW = 0x8B61, + SAMPLER_2D_SHADOW = 0x8B62, + DELETE_STATUS = 0x8B80, + COMPILE_STATUS = 0x8B81, + LINK_STATUS = 0x8B82, + VALIDATE_STATUS = 0x8B83, + INFO_LOG_LENGTH = 0x8B84, + ATTACHED_SHADERS = 0x8B85, + ACTIVE_UNIFORMS = 0x8B86, + ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87, + SHADER_SOURCE_LENGTH = 0x8B88, + ACTIVE_ATTRIBUTES = 0x8B89, + ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A, + FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B, + SHADING_LANGUAGE_VERSION = 0x8B8C, + CURRENT_PROGRAM = 0x8B8D, + POINT_SPRITE_COORD_ORIGIN = 0x8CA0, + LOWER_LEFT = 0x8CA1, + UPPER_LEFT = 0x8CA2, + STENCIL_BACK_REF = 0x8CA3, + STENCIL_BACK_VALUE_MASK = 0x8CA4, + STENCIL_BACK_WRITEMASK = 0x8CA5, + + // Version: 2.1 + PIXEL_PACK_BUFFER = 0x88EB, + PIXEL_UNPACK_BUFFER = 0x88EC, + PIXEL_PACK_BUFFER_BINDING = 0x88ED, + PIXEL_UNPACK_BUFFER_BINDING = 0x88EF, + FLOAT_MAT2x3 = 0x8B65, + FLOAT_MAT2x4 = 0x8B66, + FLOAT_MAT3x2 = 0x8B67, + FLOAT_MAT3x4 = 0x8B68, + FLOAT_MAT4x2 = 0x8B69, + FLOAT_MAT4x3 = 0x8B6A, + SRGB = 0x8C40, + SRGB8 = 0x8C41, + SRGB_ALPHA = 0x8C42, + SRGB8_ALPHA8 = 0x8C43, + COMPRESSED_SRGB = 0x8C48, + COMPRESSED_SRGB_ALPHA = 0x8C49, + + // Core Extension: ARB_vertex_array_object + VERTEX_ARRAY_BINDING = 0x85B5, + + // Core Extension: ARB_texture_rg + RG = 0x8227, + RG_INTEGER = 0x8228, + R8 = 0x8229, + R16 = 0x822A, + RG8 = 0x822B, + RG16 = 0x822C, + R16F = 0x822D, + R32F = 0x822E, + RG16F = 0x822F, + RG32F = 0x8230, + R8I = 0x8231, + R8UI = 0x8232, + R16I = 0x8233, + R16UI = 0x8234, + R32I = 0x8235, + R32UI = 0x8236, + RG8I = 0x8237, + RG8UI = 0x8238, + RG16I = 0x8239, + RG16UI = 0x823A, + RG32I = 0x823B, + RG32UI = 0x823C, + + // Core Extension: ARB_texture_compression_rgtc + COMPRESSED_RED_RGTC1 = 0x8DBB, + COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC, + COMPRESSED_RG_RGTC2 = 0x8DBD, + COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE, + + // Core Extension: ARB_map_buffer_range + MAP_READ_BIT = 0x0001, + MAP_WRITE_BIT = 0x0002, + MAP_INVALIDATE_RANGE_BIT = 0x0004, + MAP_INVALIDATE_BUFFER_BIT = 0x0008, + MAP_FLUSH_EXPLICIT_BIT = 0x0010, + MAP_UNSYNCHRONIZED_BIT = 0x0020, + + // Core Extension: ARB_half_float_vertex + HALF_FLOAT = 0x140B, + + // Core Extension: ARB_framebuffer_sRGB + FRAMEBUFFER_SRGB = 0x8DB9, + + // Core Extension: ARB_framebuffer_object + INVALID_FRAMEBUFFER_OPERATION = 0x0506, + FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210, + FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211, + FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212, + FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213, + FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214, + FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215, + FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216, + FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217, + FRAMEBUFFER_DEFAULT = 0x8218, + FRAMEBUFFER_UNDEFINED = 0x8219, + DEPTH_STENCIL_ATTACHMENT = 0x821A, + INDEX = 0x8222, + MAX_RENDERBUFFER_SIZE = 0x84E8, + DEPTH_STENCIL = 0x84F9, + UNSIGNED_INT_24_8 = 0x84FA, + DEPTH24_STENCIL8 = 0x88F0, + TEXTURE_STENCIL_SIZE = 0x88F1, + TEXTURE_RED_TYPE = 0x8C10, + TEXTURE_GREEN_TYPE = 0x8C11, + TEXTURE_BLUE_TYPE = 0x8C12, + TEXTURE_ALPHA_TYPE = 0x8C13, + TEXTURE_DEPTH_TYPE = 0x8C16, + UNSIGNED_NORMALIZED = 0x8C17, + FRAMEBUFFER_BINDING = 0x8CA6, + DRAW_FRAMEBUFFER_BINDING = 0x8CA6, + RENDERBUFFER_BINDING = 0x8CA7, + READ_FRAMEBUFFER = 0x8CA8, + DRAW_FRAMEBUFFER = 0x8CA9, + READ_FRAMEBUFFER_BINDING = 0x8CAA, + RENDERBUFFER_SAMPLES = 0x8CAB, + FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0, + FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1, + FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2, + FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3, + FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4, + FRAMEBUFFER_COMPLETE = 0x8CD5, + FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6, + FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7, + FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB, + FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC, + FRAMEBUFFER_UNSUPPORTED = 0x8CDD, + MAX_COLOR_ATTACHMENTS = 0x8CDF, + COLOR_ATTACHMENT0 = 0x8CE0, + COLOR_ATTACHMENT1 = 0x8CE1, + COLOR_ATTACHMENT2 = 0x8CE2, + COLOR_ATTACHMENT3 = 0x8CE3, + COLOR_ATTACHMENT4 = 0x8CE4, + COLOR_ATTACHMENT5 = 0x8CE5, + COLOR_ATTACHMENT6 = 0x8CE6, + COLOR_ATTACHMENT7 = 0x8CE7, + COLOR_ATTACHMENT8 = 0x8CE8, + COLOR_ATTACHMENT9 = 0x8CE9, + COLOR_ATTACHMENT10 = 0x8CEA, + COLOR_ATTACHMENT11 = 0x8CEB, + COLOR_ATTACHMENT12 = 0x8CEC, + COLOR_ATTACHMENT13 = 0x8CED, + COLOR_ATTACHMENT14 = 0x8CEE, + COLOR_ATTACHMENT15 = 0x8CEF, + DEPTH_ATTACHMENT = 0x8D00, + STENCIL_ATTACHMENT = 0x8D20, + FRAMEBUFFER = 0x8D40, + RENDERBUFFER = 0x8D41, + RENDERBUFFER_WIDTH = 0x8D42, + RENDERBUFFER_HEIGHT = 0x8D43, + RENDERBUFFER_INTERNAL_FORMAT = 0x8D44, + STENCIL_INDEX1 = 0x8D46, + STENCIL_INDEX4 = 0x8D47, + STENCIL_INDEX8 = 0x8D48, + STENCIL_INDEX16 = 0x8D49, + RENDERBUFFER_RED_SIZE = 0x8D50, + RENDERBUFFER_GREEN_SIZE = 0x8D51, + RENDERBUFFER_BLUE_SIZE = 0x8D52, + RENDERBUFFER_ALPHA_SIZE = 0x8D53, + RENDERBUFFER_DEPTH_SIZE = 0x8D54, + RENDERBUFFER_STENCIL_SIZE = 0x8D55, + FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56, + MAX_SAMPLES = 0x8D57, + TEXTURE_LUMINANCE_TYPE = 0x8C14, + TEXTURE_INTENSITY_TYPE = 0x8C15, + + // Core Extension: ARB_depth_buffer_float + DEPTH_COMPONENT32F = 0x8CAC, + DEPTH32F_STENCIL8 = 0x8CAD, + FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD, + + // Version: 3.0 + COMPARE_REF_TO_TEXTURE = 0x884E, + CLIP_DISTANCE0 = 0x3000, + CLIP_DISTANCE1 = 0x3001, + CLIP_DISTANCE2 = 0x3002, + CLIP_DISTANCE3 = 0x3003, + CLIP_DISTANCE4 = 0x3004, + CLIP_DISTANCE5 = 0x3005, + CLIP_DISTANCE6 = 0x3006, + CLIP_DISTANCE7 = 0x3007, + MAX_CLIP_DISTANCES = 0x0D32, + MAJOR_VERSION = 0x821B, + MINOR_VERSION = 0x821C, + NUM_EXTENSIONS = 0x821D, + CONTEXT_FLAGS = 0x821E, + COMPRESSED_RED = 0x8225, + COMPRESSED_RG = 0x8226, + CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x0001, + RGBA32F = 0x8814, + RGB32F = 0x8815, + RGBA16F = 0x881A, + RGB16F = 0x881B, + VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD, + MAX_ARRAY_TEXTURE_LAYERS = 0x88FF, + MIN_PROGRAM_TEXEL_OFFSET = 0x8904, + MAX_PROGRAM_TEXEL_OFFSET = 0x8905, + CLAMP_READ_COLOR = 0x891C, + FIXED_ONLY = 0x891D, + TEXTURE_1D_ARRAY = 0x8C18, + PROXY_TEXTURE_1D_ARRAY = 0x8C19, + TEXTURE_2D_ARRAY = 0x8C1A, + PROXY_TEXTURE_2D_ARRAY = 0x8C1B, + TEXTURE_BINDING_1D_ARRAY = 0x8C1C, + TEXTURE_BINDING_2D_ARRAY = 0x8C1D, + R11F_G11F_B10F = 0x8C3A, + UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B, + RGB9_E5 = 0x8C3D, + UNSIGNED_INT_5_9_9_9_REV = 0x8C3E, + TEXTURE_SHARED_SIZE = 0x8C3F, + TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76, + TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F, + MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80, + TRANSFORM_FEEDBACK_VARYINGS = 0x8C83, + TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84, + TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85, + PRIMITIVES_GENERATED = 0x8C87, + TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88, + RASTERIZER_DISCARD = 0x8C89, + MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A, + MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B, + INTERLEAVED_ATTRIBS = 0x8C8C, + SEPARATE_ATTRIBS = 0x8C8D, + TRANSFORM_FEEDBACK_BUFFER = 0x8C8E, + TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F, + RGBA32UI = 0x8D70, + RGB32UI = 0x8D71, + RGBA16UI = 0x8D76, + RGB16UI = 0x8D77, + RGBA8UI = 0x8D7C, + RGB8UI = 0x8D7D, + RGBA32I = 0x8D82, + RGB32I = 0x8D83, + RGBA16I = 0x8D88, + RGB16I = 0x8D89, + RGBA8I = 0x8D8E, + RGB8I = 0x8D8F, + RED_INTEGER = 0x8D94, + GREEN_INTEGER = 0x8D95, + BLUE_INTEGER = 0x8D96, + RGB_INTEGER = 0x8D98, + RGBA_INTEGER = 0x8D99, + BGR_INTEGER = 0x8D9A, + BGRA_INTEGER = 0x8D9B, + SAMPLER_1D_ARRAY = 0x8DC0, + SAMPLER_2D_ARRAY = 0x8DC1, + SAMPLER_1D_ARRAY_SHADOW = 0x8DC3, + SAMPLER_2D_ARRAY_SHADOW = 0x8DC4, + SAMPLER_CUBE_SHADOW = 0x8DC5, + UNSIGNED_INT_VEC2 = 0x8DC6, + UNSIGNED_INT_VEC3 = 0x8DC7, + UNSIGNED_INT_VEC4 = 0x8DC8, + INT_SAMPLER_1D = 0x8DC9, + INT_SAMPLER_2D = 0x8DCA, + INT_SAMPLER_3D = 0x8DCB, + INT_SAMPLER_CUBE = 0x8DCC, + INT_SAMPLER_1D_ARRAY = 0x8DCE, + INT_SAMPLER_2D_ARRAY = 0x8DCF, + UNSIGNED_INT_SAMPLER_1D = 0x8DD1, + UNSIGNED_INT_SAMPLER_2D = 0x8DD2, + UNSIGNED_INT_SAMPLER_3D = 0x8DD3, + UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4, + UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6, + UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7, + QUERY_WAIT = 0x8E13, + QUERY_NO_WAIT = 0x8E14, + QUERY_BY_REGION_WAIT = 0x8E15, + QUERY_BY_REGION_NO_WAIT = 0x8E16, + BUFFER_ACCESS_FLAGS = 0x911F, + BUFFER_MAP_LENGTH = 0x9120, + BUFFER_MAP_OFFSET = 0x9121, + + // Core Extension: ARB_uniform_buffer_object + UNIFORM_BUFFER = 0x8A11, + UNIFORM_BUFFER_BINDING = 0x8A28, + UNIFORM_BUFFER_START = 0x8A29, + UNIFORM_BUFFER_SIZE = 0x8A2A, + MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B, + MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D, + MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E, + MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F, + MAX_UNIFORM_BLOCK_SIZE = 0x8A30, + MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31, + MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33, + UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34, + ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35, + ACTIVE_UNIFORM_BLOCKS = 0x8A36, + UNIFORM_TYPE = 0x8A37, + UNIFORM_SIZE = 0x8A38, + UNIFORM_NAME_LENGTH = 0x8A39, + UNIFORM_BLOCK_INDEX = 0x8A3A, + UNIFORM_OFFSET = 0x8A3B, + UNIFORM_ARRAY_STRIDE = 0x8A3C, + UNIFORM_MATRIX_STRIDE = 0x8A3D, + UNIFORM_IS_ROW_MAJOR = 0x8A3E, + UNIFORM_BLOCK_BINDING = 0x8A3F, + UNIFORM_BLOCK_DATA_SIZE = 0x8A40, + UNIFORM_BLOCK_NAME_LENGTH = 0x8A41, + UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42, + UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43, + UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44, + UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46, + INVALID_INDEX = 0xFFFFFFFF, + MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C, + MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32, + UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45, + + // Core Extension: ARB_copy_buffer + COPY_READ_BUFFER = 0x8F36, + COPY_WRITE_BUFFER = 0x8F37, + COPY_READ_BUFFER_BINDING = 0x8F36, + COPY_WRITE_BUFFER_BINDING = 0x8F37, + + // Version: 3.1 + SAMPLER_2D_RECT = 0x8B63, + SAMPLER_2D_RECT_SHADOW = 0x8B64, + SAMPLER_BUFFER = 0x8DC2, + INT_SAMPLER_2D_RECT = 0x8DCD, + INT_SAMPLER_BUFFER = 0x8DD0, + UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5, + UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8, + TEXTURE_BUFFER = 0x8C2A, + MAX_TEXTURE_BUFFER_SIZE = 0x8C2B, + TEXTURE_BINDING_BUFFER = 0x8C2C, + TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D, + TEXTURE_RECTANGLE = 0x84F5, + TEXTURE_BINDING_RECTANGLE = 0x84F6, + PROXY_TEXTURE_RECTANGLE = 0x84F7, + MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8, + RED_SNORM = 0x8F90, + RG_SNORM = 0x8F91, + RGB_SNORM = 0x8F92, + RGBA_SNORM = 0x8F93, + R8_SNORM = 0x8F94, + RG8_SNORM = 0x8F95, + RGB8_SNORM = 0x8F96, + RGBA8_SNORM = 0x8F97, + R16_SNORM = 0x8F98, + RG16_SNORM = 0x8F99, + RGB16_SNORM = 0x8F9A, + RGBA16_SNORM = 0x8F9B, + SIGNED_NORMALIZED = 0x8F9C, + PRIMITIVE_RESTART = 0x8F9D, + PRIMITIVE_RESTART_INDEX = 0x8F9E, + + }; + + // Extension: 1.1 + extern void (CODEGEN_FUNCPTR *CullFace)(GLenum mode); + extern void (CODEGEN_FUNCPTR *FrontFace)(GLenum mode); + extern void (CODEGEN_FUNCPTR *Hint)(GLenum target, GLenum mode); + extern void (CODEGEN_FUNCPTR *LineWidth)(GLfloat width); + extern void (CODEGEN_FUNCPTR *PointSize)(GLfloat size); + extern void (CODEGEN_FUNCPTR *PolygonMode)(GLenum face, GLenum mode); + extern void (CODEGEN_FUNCPTR *Scissor)(GLint x, GLint y, GLsizei width, GLsizei height); + extern void (CODEGEN_FUNCPTR *TexParameterf)(GLenum target, GLenum pname, GLfloat param); + extern void (CODEGEN_FUNCPTR *TexParameterfv)(GLenum target, GLenum pname, const GLfloat *params); + extern void (CODEGEN_FUNCPTR *TexParameteri)(GLenum target, GLenum pname, GLint param); + extern void (CODEGEN_FUNCPTR *TexParameteriv)(GLenum target, GLenum pname, const GLint *params); + extern void (CODEGEN_FUNCPTR *TexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels); + extern void (CODEGEN_FUNCPTR *TexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels); + extern void (CODEGEN_FUNCPTR *DrawBuffer)(GLenum mode); + extern void (CODEGEN_FUNCPTR *Clear)(GLbitfield mask); + extern void (CODEGEN_FUNCPTR *ClearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + extern void (CODEGEN_FUNCPTR *ClearStencil)(GLint s); + extern void (CODEGEN_FUNCPTR *ClearDepth)(GLdouble depth); + extern void (CODEGEN_FUNCPTR *StencilMask)(GLuint mask); + extern void (CODEGEN_FUNCPTR *ColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); + extern void (CODEGEN_FUNCPTR *DepthMask)(GLboolean flag); + extern void (CODEGEN_FUNCPTR *Disable)(GLenum cap); + extern void (CODEGEN_FUNCPTR *Enable)(GLenum cap); + extern void (CODEGEN_FUNCPTR *Finish)(); + extern void (CODEGEN_FUNCPTR *Flush)(); + extern void (CODEGEN_FUNCPTR *BlendFunc)(GLenum sfactor, GLenum dfactor); + extern void (CODEGEN_FUNCPTR *LogicOp)(GLenum opcode); + extern void (CODEGEN_FUNCPTR *StencilFunc)(GLenum func, GLint ref, GLuint mask); + extern void (CODEGEN_FUNCPTR *StencilOp)(GLenum fail, GLenum zfail, GLenum zpass); + extern void (CODEGEN_FUNCPTR *DepthFunc)(GLenum func); + extern void (CODEGEN_FUNCPTR *PixelStoref)(GLenum pname, GLfloat param); + extern void (CODEGEN_FUNCPTR *PixelStorei)(GLenum pname, GLint param); + extern void (CODEGEN_FUNCPTR *ReadBuffer)(GLenum mode); + extern void (CODEGEN_FUNCPTR *ReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels); + extern void (CODEGEN_FUNCPTR *GetBooleanv)(GLenum pname, GLboolean *params); + extern void (CODEGEN_FUNCPTR *GetDoublev)(GLenum pname, GLdouble *params); + extern GLenum (CODEGEN_FUNCPTR *GetError)(); + extern void (CODEGEN_FUNCPTR *GetFloatv)(GLenum pname, GLfloat *params); + extern void (CODEGEN_FUNCPTR *GetIntegerv)(GLenum pname, GLint *params); + extern const GLubyte * (CODEGEN_FUNCPTR *GetString)(GLenum name); + extern void (CODEGEN_FUNCPTR *GetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels); + extern void (CODEGEN_FUNCPTR *GetTexParameterfv)(GLenum target, GLenum pname, GLfloat *params); + extern void (CODEGEN_FUNCPTR *GetTexParameteriv)(GLenum target, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat *params); + extern void (CODEGEN_FUNCPTR *GetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint *params); + extern GLboolean (CODEGEN_FUNCPTR *IsEnabled)(GLenum cap); + extern void (CODEGEN_FUNCPTR *DepthRange)(GLdouble ren_near, GLdouble ren_far); + extern void (CODEGEN_FUNCPTR *Viewport)(GLint x, GLint y, GLsizei width, GLsizei height); + extern void (CODEGEN_FUNCPTR *DrawArrays)(GLenum mode, GLint first, GLsizei count); + extern void (CODEGEN_FUNCPTR *DrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices); + extern void (CODEGEN_FUNCPTR *GetPointerv)(GLenum pname, GLvoid* *params); + extern void (CODEGEN_FUNCPTR *PolygonOffset)(GLfloat factor, GLfloat units); + extern void (CODEGEN_FUNCPTR *CopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); + extern void (CODEGEN_FUNCPTR *CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); + extern void (CODEGEN_FUNCPTR *CopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); + extern void (CODEGEN_FUNCPTR *CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); + extern void (CODEGEN_FUNCPTR *TexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels); + extern void (CODEGEN_FUNCPTR *TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); + extern void (CODEGEN_FUNCPTR *BindTexture)(GLenum target, GLuint texture); + extern void (CODEGEN_FUNCPTR *DeleteTextures)(GLsizei n, const GLuint *textures); + extern void (CODEGEN_FUNCPTR *GenTextures)(GLsizei n, GLuint *textures); + extern GLboolean (CODEGEN_FUNCPTR *IsTexture)(GLuint texture); + extern void (CODEGEN_FUNCPTR *Indexub)(GLubyte c); + extern void (CODEGEN_FUNCPTR *Indexubv)(const GLubyte *c); + + // Extension: 1.2 + extern void (CODEGEN_FUNCPTR *BlendColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); + extern void (CODEGEN_FUNCPTR *BlendEquation)(GLenum mode); + extern void (CODEGEN_FUNCPTR *DrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices); + extern void (CODEGEN_FUNCPTR *TexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels); + extern void (CODEGEN_FUNCPTR *CopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); + + // Extension: 1.3 + extern void (CODEGEN_FUNCPTR *ActiveTexture)(GLenum texture); + extern void (CODEGEN_FUNCPTR *SampleCoverage)(GLfloat value, GLboolean invert); + extern void (CODEGEN_FUNCPTR *CompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data); + extern void (CODEGEN_FUNCPTR *CompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data); + extern void (CODEGEN_FUNCPTR *CompressedTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data); + extern void (CODEGEN_FUNCPTR *CompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data); + extern void (CODEGEN_FUNCPTR *CompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data); + extern void (CODEGEN_FUNCPTR *CompressedTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data); + extern void (CODEGEN_FUNCPTR *GetCompressedTexImage)(GLenum target, GLint level, GLvoid *img); + + // Extension: 1.4 + extern void (CODEGEN_FUNCPTR *BlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); + extern void (CODEGEN_FUNCPTR *MultiDrawArrays)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); + extern void (CODEGEN_FUNCPTR *MultiDrawElements)(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount); + extern void (CODEGEN_FUNCPTR *PointParameterf)(GLenum pname, GLfloat param); + extern void (CODEGEN_FUNCPTR *PointParameterfv)(GLenum pname, const GLfloat *params); + extern void (CODEGEN_FUNCPTR *PointParameteri)(GLenum pname, GLint param); + extern void (CODEGEN_FUNCPTR *PointParameteriv)(GLenum pname, const GLint *params); + + // Extension: 1.5 + extern void (CODEGEN_FUNCPTR *GenQueries)(GLsizei n, GLuint *ids); + extern void (CODEGEN_FUNCPTR *DeleteQueries)(GLsizei n, const GLuint *ids); + extern GLboolean (CODEGEN_FUNCPTR *IsQuery)(GLuint id); + extern void (CODEGEN_FUNCPTR *BeginQuery)(GLenum target, GLuint id); + extern void (CODEGEN_FUNCPTR *EndQuery)(GLenum target); + extern void (CODEGEN_FUNCPTR *GetQueryiv)(GLenum target, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetQueryObjectiv)(GLuint id, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetQueryObjectuiv)(GLuint id, GLenum pname, GLuint *params); + extern void (CODEGEN_FUNCPTR *BindBuffer)(GLenum target, GLuint buffer); + extern void (CODEGEN_FUNCPTR *DeleteBuffers)(GLsizei n, const GLuint *buffers); + extern void (CODEGEN_FUNCPTR *GenBuffers)(GLsizei n, GLuint *buffers); + extern GLboolean (CODEGEN_FUNCPTR *IsBuffer)(GLuint buffer); + extern void (CODEGEN_FUNCPTR *BufferData)(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage); + extern void (CODEGEN_FUNCPTR *BufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data); + extern void (CODEGEN_FUNCPTR *GetBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data); + extern GLvoid* (CODEGEN_FUNCPTR *MapBuffer)(GLenum target, GLenum access); + extern GLboolean (CODEGEN_FUNCPTR *UnmapBuffer)(GLenum target); + extern void (CODEGEN_FUNCPTR *GetBufferParameteriv)(GLenum target, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetBufferPointerv)(GLenum target, GLenum pname, GLvoid* *params); + + // Extension: 2.0 + extern void (CODEGEN_FUNCPTR *BlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha); + extern void (CODEGEN_FUNCPTR *DrawBuffers)(GLsizei n, const GLenum *bufs); + extern void (CODEGEN_FUNCPTR *StencilOpSeparate)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); + extern void (CODEGEN_FUNCPTR *StencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask); + extern void (CODEGEN_FUNCPTR *StencilMaskSeparate)(GLenum face, GLuint mask); + extern void (CODEGEN_FUNCPTR *AttachShader)(GLuint program, GLuint shader); + extern void (CODEGEN_FUNCPTR *BindAttribLocation)(GLuint program, GLuint index, const GLchar *name); + extern void (CODEGEN_FUNCPTR *CompileShader)(GLuint shader); + extern GLuint (CODEGEN_FUNCPTR *CreateProgram)(); + extern GLuint (CODEGEN_FUNCPTR *CreateShader)(GLenum type); + extern void (CODEGEN_FUNCPTR *DeleteProgram)(GLuint program); + extern void (CODEGEN_FUNCPTR *DeleteShader)(GLuint shader); + extern void (CODEGEN_FUNCPTR *DetachShader)(GLuint program, GLuint shader); + extern void (CODEGEN_FUNCPTR *DisableVertexAttribArray)(GLuint index); + extern void (CODEGEN_FUNCPTR *EnableVertexAttribArray)(GLuint index); + extern void (CODEGEN_FUNCPTR *GetActiveAttrib)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); + extern void (CODEGEN_FUNCPTR *GetActiveUniform)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); + extern void (CODEGEN_FUNCPTR *GetAttachedShaders)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj); + extern GLint (CODEGEN_FUNCPTR *GetAttribLocation)(GLuint program, const GLchar *name); + extern void (CODEGEN_FUNCPTR *GetProgramiv)(GLuint program, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); + extern void (CODEGEN_FUNCPTR *GetShaderiv)(GLuint shader, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); + extern void (CODEGEN_FUNCPTR *GetShaderSource)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); + extern GLint (CODEGEN_FUNCPTR *GetUniformLocation)(GLuint program, const GLchar *name); + extern void (CODEGEN_FUNCPTR *GetUniformfv)(GLuint program, GLint location, GLfloat *params); + extern void (CODEGEN_FUNCPTR *GetUniformiv)(GLuint program, GLint location, GLint *params); + extern void (CODEGEN_FUNCPTR *GetVertexAttribdv)(GLuint index, GLenum pname, GLdouble *params); + extern void (CODEGEN_FUNCPTR *GetVertexAttribfv)(GLuint index, GLenum pname, GLfloat *params); + extern void (CODEGEN_FUNCPTR *GetVertexAttribiv)(GLuint index, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetVertexAttribPointerv)(GLuint index, GLenum pname, GLvoid* *pointer); + extern GLboolean (CODEGEN_FUNCPTR *IsProgram)(GLuint program); + extern GLboolean (CODEGEN_FUNCPTR *IsShader)(GLuint shader); + extern void (CODEGEN_FUNCPTR *LinkProgram)(GLuint program); + extern void (CODEGEN_FUNCPTR *ShaderSource)(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length); + extern void (CODEGEN_FUNCPTR *UseProgram)(GLuint program); + extern void (CODEGEN_FUNCPTR *Uniform1f)(GLint location, GLfloat v0); + extern void (CODEGEN_FUNCPTR *Uniform2f)(GLint location, GLfloat v0, GLfloat v1); + extern void (CODEGEN_FUNCPTR *Uniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); + extern void (CODEGEN_FUNCPTR *Uniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); + extern void (CODEGEN_FUNCPTR *Uniform1i)(GLint location, GLint v0); + extern void (CODEGEN_FUNCPTR *Uniform2i)(GLint location, GLint v0, GLint v1); + extern void (CODEGEN_FUNCPTR *Uniform3i)(GLint location, GLint v0, GLint v1, GLint v2); + extern void (CODEGEN_FUNCPTR *Uniform4i)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); + extern void (CODEGEN_FUNCPTR *Uniform1fv)(GLint location, GLsizei count, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *Uniform2fv)(GLint location, GLsizei count, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *Uniform3fv)(GLint location, GLsizei count, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *Uniform4fv)(GLint location, GLsizei count, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *Uniform1iv)(GLint location, GLsizei count, const GLint *value); + extern void (CODEGEN_FUNCPTR *Uniform2iv)(GLint location, GLsizei count, const GLint *value); + extern void (CODEGEN_FUNCPTR *Uniform3iv)(GLint location, GLsizei count, const GLint *value); + extern void (CODEGEN_FUNCPTR *Uniform4iv)(GLint location, GLsizei count, const GLint *value); + extern void (CODEGEN_FUNCPTR *UniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *UniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *UniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *ValidateProgram)(GLuint program); + extern void (CODEGEN_FUNCPTR *VertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer); + + // Extension: 2.1 + extern void (CODEGEN_FUNCPTR *UniformMatrix2x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *UniformMatrix3x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *UniformMatrix2x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *UniformMatrix4x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *UniformMatrix3x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *UniformMatrix4x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + + // Extension: ARB_vertex_array_object + extern void (CODEGEN_FUNCPTR *BindVertexArray)(GLuint ren_array); + extern void (CODEGEN_FUNCPTR *DeleteVertexArrays)(GLsizei n, const GLuint *arrays); + extern void (CODEGEN_FUNCPTR *GenVertexArrays)(GLsizei n, GLuint *arrays); + extern GLboolean (CODEGEN_FUNCPTR *IsVertexArray)(GLuint ren_array); + + // Extension: ARB_map_buffer_range + extern GLvoid* (CODEGEN_FUNCPTR *MapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); + extern void (CODEGEN_FUNCPTR *FlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length); + + // Extension: ARB_framebuffer_object + extern GLboolean (CODEGEN_FUNCPTR *IsRenderbuffer)(GLuint renderbuffer); + extern void (CODEGEN_FUNCPTR *BindRenderbuffer)(GLenum target, GLuint renderbuffer); + extern void (CODEGEN_FUNCPTR *DeleteRenderbuffers)(GLsizei n, const GLuint *renderbuffers); + extern void (CODEGEN_FUNCPTR *GenRenderbuffers)(GLsizei n, GLuint *renderbuffers); + extern void (CODEGEN_FUNCPTR *RenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); + extern void (CODEGEN_FUNCPTR *GetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint *params); + extern GLboolean (CODEGEN_FUNCPTR *IsFramebuffer)(GLuint framebuffer); + extern void (CODEGEN_FUNCPTR *BindFramebuffer)(GLenum target, GLuint framebuffer); + extern void (CODEGEN_FUNCPTR *DeleteFramebuffers)(GLsizei n, const GLuint *framebuffers); + extern void (CODEGEN_FUNCPTR *GenFramebuffers)(GLsizei n, GLuint *framebuffers); + extern GLenum (CODEGEN_FUNCPTR *CheckFramebufferStatus)(GLenum target); + extern void (CODEGEN_FUNCPTR *FramebufferTexture1D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); + extern void (CODEGEN_FUNCPTR *FramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); + extern void (CODEGEN_FUNCPTR *FramebufferTexture3D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); + extern void (CODEGEN_FUNCPTR *FramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); + extern void (CODEGEN_FUNCPTR *GetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GenerateMipmap)(GLenum target); + extern void (CODEGEN_FUNCPTR *BlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); + extern void (CODEGEN_FUNCPTR *RenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); + extern void (CODEGEN_FUNCPTR *FramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); + + // Extension: 3.0 + extern void (CODEGEN_FUNCPTR *ColorMaski)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); + extern void (CODEGEN_FUNCPTR *GetBooleani_v)(GLenum target, GLuint index, GLboolean *data); + extern void (CODEGEN_FUNCPTR *GetIntegeri_v)(GLenum target, GLuint index, GLint *data); + extern void (CODEGEN_FUNCPTR *Enablei)(GLenum target, GLuint index); + extern void (CODEGEN_FUNCPTR *Disablei)(GLenum target, GLuint index); + extern GLboolean (CODEGEN_FUNCPTR *IsEnabledi)(GLenum target, GLuint index); + extern void (CODEGEN_FUNCPTR *BeginTransformFeedback)(GLenum primitiveMode); + extern void (CODEGEN_FUNCPTR *EndTransformFeedback)(); + extern void (CODEGEN_FUNCPTR *BindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); + extern void (CODEGEN_FUNCPTR *BindBufferBase)(GLenum target, GLuint index, GLuint buffer); + extern void (CODEGEN_FUNCPTR *TransformFeedbackVaryings)(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode); + extern void (CODEGEN_FUNCPTR *GetTransformFeedbackVarying)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); + extern void (CODEGEN_FUNCPTR *ClampColor)(GLenum target, GLenum clamp); + extern void (CODEGEN_FUNCPTR *BeginConditionalRender)(GLuint id, GLenum mode); + extern void (CODEGEN_FUNCPTR *EndConditionalRender)(); + extern void (CODEGEN_FUNCPTR *VertexAttribIPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); + extern void (CODEGEN_FUNCPTR *GetVertexAttribIiv)(GLuint index, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint *params); + extern void (CODEGEN_FUNCPTR *VertexAttribI1i)(GLuint index, GLint x); + extern void (CODEGEN_FUNCPTR *VertexAttribI2i)(GLuint index, GLint x, GLint y); + extern void (CODEGEN_FUNCPTR *VertexAttribI3i)(GLuint index, GLint x, GLint y, GLint z); + extern void (CODEGEN_FUNCPTR *VertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w); + extern void (CODEGEN_FUNCPTR *VertexAttribI1ui)(GLuint index, GLuint x); + extern void (CODEGEN_FUNCPTR *VertexAttribI2ui)(GLuint index, GLuint x, GLuint y); + extern void (CODEGEN_FUNCPTR *VertexAttribI3ui)(GLuint index, GLuint x, GLuint y, GLuint z); + extern void (CODEGEN_FUNCPTR *VertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); + extern void (CODEGEN_FUNCPTR *VertexAttribI1iv)(GLuint index, const GLint *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI2iv)(GLuint index, const GLint *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI3iv)(GLuint index, const GLint *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI4iv)(GLuint index, const GLint *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI1uiv)(GLuint index, const GLuint *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI2uiv)(GLuint index, const GLuint *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI3uiv)(GLuint index, const GLuint *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI4uiv)(GLuint index, const GLuint *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI4bv)(GLuint index, const GLbyte *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI4sv)(GLuint index, const GLshort *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI4ubv)(GLuint index, const GLubyte *v); + extern void (CODEGEN_FUNCPTR *VertexAttribI4usv)(GLuint index, const GLushort *v); + extern void (CODEGEN_FUNCPTR *GetUniformuiv)(GLuint program, GLint location, GLuint *params); + extern void (CODEGEN_FUNCPTR *BindFragDataLocation)(GLuint program, GLuint color, const GLchar *name); + extern GLint (CODEGEN_FUNCPTR *GetFragDataLocation)(GLuint program, const GLchar *name); + extern void (CODEGEN_FUNCPTR *Uniform1ui)(GLint location, GLuint v0); + extern void (CODEGEN_FUNCPTR *Uniform2ui)(GLint location, GLuint v0, GLuint v1); + extern void (CODEGEN_FUNCPTR *Uniform3ui)(GLint location, GLuint v0, GLuint v1, GLuint v2); + extern void (CODEGEN_FUNCPTR *Uniform4ui)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); + extern void (CODEGEN_FUNCPTR *Uniform1uiv)(GLint location, GLsizei count, const GLuint *value); + extern void (CODEGEN_FUNCPTR *Uniform2uiv)(GLint location, GLsizei count, const GLuint *value); + extern void (CODEGEN_FUNCPTR *Uniform3uiv)(GLint location, GLsizei count, const GLuint *value); + extern void (CODEGEN_FUNCPTR *Uniform4uiv)(GLint location, GLsizei count, const GLuint *value); + extern void (CODEGEN_FUNCPTR *TexParameterIiv)(GLenum target, GLenum pname, const GLint *params); + extern void (CODEGEN_FUNCPTR *TexParameterIuiv)(GLenum target, GLenum pname, const GLuint *params); + extern void (CODEGEN_FUNCPTR *GetTexParameterIiv)(GLenum target, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetTexParameterIuiv)(GLenum target, GLenum pname, GLuint *params); + extern void (CODEGEN_FUNCPTR *ClearBufferiv)(GLenum buffer, GLint drawbuffer, const GLint *value); + extern void (CODEGEN_FUNCPTR *ClearBufferuiv)(GLenum buffer, GLint drawbuffer, const GLuint *value); + extern void (CODEGEN_FUNCPTR *ClearBufferfv)(GLenum buffer, GLint drawbuffer, const GLfloat *value); + extern void (CODEGEN_FUNCPTR *ClearBufferfi)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); + extern const GLubyte * (CODEGEN_FUNCPTR *GetStringi)(GLenum name, GLuint index); + + // Extension: ARB_uniform_buffer_object + extern void (CODEGEN_FUNCPTR *GetUniformIndices)(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices); + extern void (CODEGEN_FUNCPTR *GetActiveUniformsiv)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetActiveUniformName)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); + extern GLuint (CODEGEN_FUNCPTR *GetUniformBlockIndex)(GLuint program, const GLchar *uniformBlockName); + extern void (CODEGEN_FUNCPTR *GetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); + extern void (CODEGEN_FUNCPTR *GetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); + extern void (CODEGEN_FUNCPTR *UniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); + + // Extension: ARB_copy_buffer + extern void (CODEGEN_FUNCPTR *CopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); + + // Extension: 3.1 + extern void (CODEGEN_FUNCPTR *DrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); + extern void (CODEGEN_FUNCPTR *DrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount); + extern void (CODEGEN_FUNCPTR *TexBuffer)(GLenum target, GLenum internalformat, GLuint buffer); + extern void (CODEGEN_FUNCPTR *PrimitiveRestartIndex)(GLuint index); + + // Legacy + enum + { + VERTEX_ARRAY = 0x8074, + NORMAL_ARRAY = 0x8075, + COLOR_ARRAY = 0x8076, + TEXTURE_COORD_ARRAY = 0x8078, + + TEXTURE_ENV = 0x2300, + TEXTURE_ENV_MODE = 0x2200, + + MODELVIEW = 0x1700, + PROJECTION = 0x1701, + LIGHTING = 0x0B50 + }; + + extern void (CODEGEN_FUNCPTR *EnableClientState)(GLenum cap); + extern void (CODEGEN_FUNCPTR *DisableClientState)(GLenum cap); + extern void (CODEGEN_FUNCPTR *VertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr); + extern void (CODEGEN_FUNCPTR *NormalPointer)(GLenum type, GLsizei stride, const GLvoid *ptr); + extern void (CODEGEN_FUNCPTR *ColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr); + extern void (CODEGEN_FUNCPTR *TexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr); + + extern void (CODEGEN_FUNCPTR *TexEnvi)(GLenum target, GLenum pname, GLint param); + + extern void (CODEGEN_FUNCPTR *MatrixMode)(GLenum mode); + extern void (CODEGEN_FUNCPTR *LoadIdentity)(void); + extern void (CODEGEN_FUNCPTR *Ortho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near_val, GLdouble far_val); + + extern void (CODEGEN_FUNCPTR *Color3d)(GLdouble red, GLdouble green, GLdouble blue); + + namespace sys + { + void CheckExtensions(); + } +} +#endif //OPENGL_NOLOAD_STYLE_HPP diff --git a/modules/core/src/matrix.cpp b/modules/core/src/matrix.cpp index 42c287593f..0776ca6248 100644 --- a/modules/core/src/matrix.cpp +++ b/modules/core/src/matrix.cpp @@ -922,8 +922,8 @@ _InputArray::_InputArray(const Mat& m) : flags(MAT), obj((void*)&m) {} _InputArray::_InputArray(const vector& vec) : flags(STD_VECTOR_MAT), obj((void*)&vec) {} _InputArray::_InputArray(const double& val) : flags(FIXED_TYPE + FIXED_SIZE + MATX + CV_64F), obj((void*)&val), sz(Size(1,1)) {} _InputArray::_InputArray(const MatExpr& expr) : flags(FIXED_TYPE + FIXED_SIZE + EXPR), obj((void*)&expr) {} -_InputArray::_InputArray(const GlBuffer& buf) : flags(FIXED_TYPE + FIXED_SIZE + OPENGL_BUFFER), obj((void*)&buf) {} -_InputArray::_InputArray(const GlTexture& tex) : flags(FIXED_TYPE + FIXED_SIZE + OPENGL_TEXTURE), obj((void*)&tex) {} +_InputArray::_InputArray(const GlBuffer& buf) : flags(OPENGL_BUFFER), obj((void*)&buf) {} +_InputArray::_InputArray(const GlTexture2D &tex) : flags(OPENGL_TEXTURE2D), obj((void*)&tex) {} _InputArray::_InputArray(const gpu::GpuMat& d_mat) : flags(GPU_MAT), obj((void*)&d_mat) {} Mat _InputArray::getMat(int i) const @@ -1076,14 +1076,14 @@ GlBuffer _InputArray::getGlBuffer() const } } -GlTexture _InputArray::getGlTexture() const +GlTexture2D _InputArray::getGlTexture2D() const { int k = kind(); - CV_Assert(k == OPENGL_TEXTURE); + CV_Assert(k == OPENGL_TEXTURE2D); //if( k == OPENGL_TEXTURE ) { - const GlTexture* tex = (const GlTexture*)obj; + const GlTexture2D* tex = (const GlTexture2D*)obj; return *tex; } } @@ -1168,10 +1168,10 @@ Size _InputArray::size(int i) const return buf->size(); } - if( k == OPENGL_TEXTURE ) + if( k == OPENGL_TEXTURE2D ) { CV_Assert( i < 0 ); - const GlTexture* tex = (const GlTexture*)obj; + const GlTexture2D* tex = (const GlTexture2D*)obj; return tex->size(); } @@ -1216,9 +1216,6 @@ int _InputArray::type(int i) const if( k == OPENGL_BUFFER ) return ((const GlBuffer*)obj)->type(); - if( k == OPENGL_TEXTURE ) - return ((const GlTexture*)obj)->type(); - CV_Assert( k == GPU_MAT ); //if( k == GPU_MAT ) return ((const gpu::GpuMat*)obj)->type(); @@ -1271,8 +1268,8 @@ bool _InputArray::empty() const if( k == OPENGL_BUFFER ) return ((const GlBuffer*)obj)->empty(); - if( k == OPENGL_TEXTURE ) - return ((const GlTexture*)obj)->empty(); + if( k == OPENGL_TEXTURE2D ) + return ((const GlTexture2D*)obj)->empty(); CV_Assert( k == GPU_MAT ); //if( k == GPU_MAT ) @@ -1285,10 +1282,14 @@ _OutputArray::~_OutputArray() {} _OutputArray::_OutputArray(Mat& m) : _InputArray(m) {} _OutputArray::_OutputArray(vector& vec) : _InputArray(vec) {} _OutputArray::_OutputArray(gpu::GpuMat& d_mat) : _InputArray(d_mat) {} +_OutputArray::_OutputArray(GlBuffer& buf) : _InputArray(buf) {} +_OutputArray::_OutputArray(GlTexture2D& tex) : _InputArray(tex) {} _OutputArray::_OutputArray(const Mat& m) : _InputArray(m) {flags |= FIXED_SIZE|FIXED_TYPE;} _OutputArray::_OutputArray(const vector& vec) : _InputArray(vec) {flags |= FIXED_SIZE;} _OutputArray::_OutputArray(const gpu::GpuMat& d_mat) : _InputArray(d_mat) {flags |= FIXED_SIZE|FIXED_TYPE;} +_OutputArray::_OutputArray(const GlBuffer& buf) : _InputArray(buf) {flags |= FIXED_SIZE|FIXED_TYPE;} +_OutputArray::_OutputArray(const GlTexture2D& tex) : _InputArray(tex) {flags |= FIXED_SIZE|FIXED_TYPE;} bool _OutputArray::fixedSize() const @@ -1318,6 +1319,13 @@ void _OutputArray::create(Size _sz, int mtype, int i, bool allowTransposed, int ((gpu::GpuMat*)obj)->create(_sz, mtype); return; } + if( k == OPENGL_BUFFER && i < 0 && !allowTransposed && fixedDepthMask == 0 ) + { + CV_Assert(!fixedSize() || ((GlBuffer*)obj)->size() == _sz); + CV_Assert(!fixedType() || ((GlBuffer*)obj)->type() == mtype); + ((GlBuffer*)obj)->create(_sz, mtype); + return; + } int sizes[] = {_sz.height, _sz.width}; create(2, sizes, mtype, i, allowTransposed, fixedDepthMask); } @@ -1339,6 +1347,13 @@ void _OutputArray::create(int rows, int cols, int mtype, int i, bool allowTransp ((gpu::GpuMat*)obj)->create(rows, cols, mtype); return; } + if( k == OPENGL_BUFFER && i < 0 && !allowTransposed && fixedDepthMask == 0 ) + { + CV_Assert(!fixedSize() || ((GlBuffer*)obj)->size() == Size(cols, rows)); + CV_Assert(!fixedType() || ((GlBuffer*)obj)->type() == mtype); + ((GlBuffer*)obj)->create(rows, cols, mtype); + return; + } int sizes[] = {rows, cols}; create(2, sizes, mtype, i, allowTransposed, fixedDepthMask); } @@ -1558,6 +1573,18 @@ void _OutputArray::release() const return; } + if( k == OPENGL_BUFFER ) + { + ((GlBuffer*)obj)->release(); + return; + } + + if( k == OPENGL_TEXTURE2D ) + { + ((GlTexture2D*)obj)->release(); + return; + } + if( k == NONE ) return; @@ -1623,6 +1650,20 @@ gpu::GpuMat& _OutputArray::getGpuMatRef() const return *(gpu::GpuMat*)obj; } +GlBuffer& _OutputArray::getGlBufferRef() const +{ + int k = kind(); + CV_Assert( k == OPENGL_BUFFER ); + return *(GlBuffer*)obj; +} + +GlTexture2D& _OutputArray::getGlTexture2DRef() const +{ + int k = kind(); + CV_Assert( k == OPENGL_TEXTURE2D ); + return *(GlTexture2D*)obj; +} + static _OutputArray _none; OutputArray noArray() { return _none; } diff --git a/modules/core/src/opengl_interop.cpp b/modules/core/src/opengl_interop.cpp index 12589b7ba3..e3ac95facd 100644 --- a/modules/core/src/opengl_interop.cpp +++ b/modules/core/src/opengl_interop.cpp @@ -41,26 +41,11 @@ //M*/ #include "precomp.hpp" -#include #include "opencv2/core/opengl_interop.hpp" #include "opencv2/core/gpumat.hpp" -#if defined WIN32 || defined _WIN32 || defined WINCE -#include -#undef small -#undef min -#undef max -#undef abs -#endif - #ifdef HAVE_OPENGL - #ifdef __APPLE__ - #include - #include - #else - #include - #include - #endif + #include "gl_core_3_1.hpp" #ifdef HAVE_CUDA #include @@ -72,213 +57,258 @@ using namespace std; using namespace cv; using namespace cv::gpu; -#ifndef HAVE_OPENGL - #define throw_nogl CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support") - #define throw_nocuda CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support") -#else - #define throw_nogl CV_Error(CV_OpenGlNotSupported, "OpenGL context doesn't exist") - - #if !defined HAVE_CUDA || defined(CUDA_DISABLER) - #define throw_nocuda CV_Error(CV_GpuNotSupported, "The library is compiled without CUDA support") +namespace +{ + #ifndef HAVE_CUDA + void throw_nocuda() { CV_Error(CV_GpuNotSupported, "The library is compiled without GPU support"); } #else + void throw_nocuda() { CV_Error(CV_StsNotImplemented, "The called functionality is disabled for current build or platform"); } + #if defined(__GNUC__) #define cudaSafeCall(expr) ___cudaSafeCall(expr, __FILE__, __LINE__, __func__) #else /* defined(__CUDACC__) || defined(__MSVC__) */ #define cudaSafeCall(expr) ___cudaSafeCall(expr, __FILE__, __LINE__) #endif - namespace + void ___cudaSafeCall(cudaError_t err, const char* file, const int line, const char* func = "") { - inline void ___cudaSafeCall(cudaError_t err, const char *file, const int line, const char *func = "") - { - if (cudaSuccess != err) - cv::gpu::error(cudaGetErrorString(err), file, line, func); - } + if (cudaSuccess != err) + cv::gpu::error(cudaGetErrorString(err), file, line, func); } - #endif // HAVE_CUDA -#endif + #endif -namespace + #ifndef HAVE_OPENGL + void throw_nogl() { CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support"); } + #else + void throw_nogl() { CV_Error(CV_OpenGlApiCallError, "OpenGL context doesn't exist"); } + #endif +} + +bool cv::checkGlError(const char* file, const int line, const char* func) { - class EmptyGlFuncTab : public CvOpenGlFuncTab +#ifndef HAVE_OPENGL + (void) file; + (void) line; + (void) func; + return true; +#else + GLenum err = gl::GetError(); + + if (err != gl::NO_ERROR_) { - public: - void genBuffers(int, unsigned int*) const { throw_nogl; } - void deleteBuffers(int, const unsigned int*) const { throw_nogl; } + const char* msg; - void bufferData(unsigned int, ptrdiff_t, const void*, unsigned int) const { throw_nogl; } - void bufferSubData(unsigned int, ptrdiff_t, ptrdiff_t, const void*) const { throw_nogl; } + switch (err) + { + case gl::INVALID_ENUM: + msg = "An unacceptable value is specified for an enumerated argument"; + break; - void bindBuffer(unsigned int, unsigned int) const { throw_nogl; } + case gl::INVALID_VALUE: + msg = "A numeric argument is out of range"; + break; - void* mapBuffer(unsigned int, unsigned int) const { throw_nogl; return 0; } - void unmapBuffer(unsigned int) const { throw_nogl; } + case gl::INVALID_OPERATION: + msg = "The specified operation is not allowed in the current state"; + break; - void generateBitmapFont(const std::string&, int, int, bool, bool, int, int, int) const { throw_nogl; } + case gl::OUT_OF_MEMORY: + msg = "There is not enough memory left to execute the command"; + break; - bool isGlContextInitialized() const { return false; } - }; + default: + msg = "Unknown error"; + }; - const CvOpenGlFuncTab* g_glFuncTab = 0; + cvError(CV_OpenGlApiCallError, func, msg, file, line); -#if defined HAVE_CUDA || defined HAVE_OPENGL - const CvOpenGlFuncTab* glFuncTab() - { - static EmptyGlFuncTab empty; - return g_glFuncTab ? g_glFuncTab : ∅ + return false; } + + return true; #endif } -CvOpenGlFuncTab::~CvOpenGlFuncTab() -{ - if (g_glFuncTab == this) - g_glFuncTab = 0; -} - -void icvSetOpenGlFuncTab(const CvOpenGlFuncTab* tab) -{ - g_glFuncTab = tab; -} - #ifdef HAVE_OPENGL - #ifndef GL_DYNAMIC_DRAW - #define GL_DYNAMIC_DRAW 0x88E8 - #endif +namespace +{ + const GLenum gl_types[] = { gl::UNSIGNED_BYTE, gl::BYTE, gl::UNSIGNED_SHORT, gl::SHORT, gl::INT, gl::FLOAT, gl::DOUBLE }; +} +#endif - #ifndef GL_READ_WRITE - #define GL_READ_WRITE 0x88BA - #endif - - #ifndef GL_BGR - #define GL_BGR 0x80E0 - #endif - - #ifndef GL_BGRA - #define GL_BGRA 0x80E1 - #endif - - namespace - { - const GLenum gl_types[] = {GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_INT, GL_FLOAT, GL_DOUBLE}; - - #ifdef HAVE_CUDA - bool g_isCudaGlDeviceInitialized = false; - #endif - } -#endif // HAVE_OPENGL +//////////////////////////////////////////////////////////////////////// +// setGlDevice void cv::gpu::setGlDevice(int device) { -#if !defined HAVE_CUDA || defined(CUDA_DISABLER) - (void)device; - throw_nocuda; +#if !defined(HAVE_CUDA) || defined(CUDA_DISABLER) + (void) device; + throw_nocuda(); #else #ifndef HAVE_OPENGL - (void)device; - throw_nogl; + (void) device; + throw_nogl(); #else - if (!glFuncTab()->isGlContextInitialized()) - throw_nogl; - cudaSafeCall( cudaGLSetGLDevice(device) ); - - g_isCudaGlDeviceInitialized = true; #endif #endif } //////////////////////////////////////////////////////////////////////// -// CudaGlInterop +// CudaResource + +#if defined(HAVE_OPENGL) && defined(HAVE_CUDA) && !defined(CUDA_DISABLER) -#if defined HAVE_CUDA && defined HAVE_OPENGL namespace { - class CudaGlInterop + class CudaResource { public: - CudaGlInterop(); - ~CudaGlInterop(); + CudaResource(); + ~CudaResource(); - void registerBuffer(unsigned int buffer); + void registerBuffer(GLuint buffer); + void release(); - void copyFrom(const GpuMat& mat, cudaStream_t stream = 0); + void copyFrom(const void* src, size_t spitch, size_t width, size_t height, cudaStream_t stream = 0); + void copyTo(void* dst, size_t dpitch, size_t width, size_t height, cudaStream_t stream = 0); - GpuMat map(int rows, int cols, int type, cudaStream_t stream = 0); + void* map(cudaStream_t stream = 0); void unmap(cudaStream_t stream = 0); private: cudaGraphicsResource_t resource_; + GLuint buffer_; + + class GraphicsMapHolder; }; - inline CudaGlInterop::CudaGlInterop() : resource_(0) + CudaResource::CudaResource() : resource_(0), buffer_(0) { } - CudaGlInterop::~CudaGlInterop() + CudaResource::~CudaResource() { - if (resource_) - { - cudaGraphicsUnregisterResource(resource_); - resource_ = 0; - } + release(); } - void CudaGlInterop::registerBuffer(unsigned int buffer) + void CudaResource::registerBuffer(GLuint buffer) { - if (!g_isCudaGlDeviceInitialized) - cvError(CV_GpuApiCallError, "registerBuffer", "cuda GL device wasn't initialized, call setGlDevice", __FILE__, __LINE__); + CV_DbgAssert( buffer != 0 ); + + if (buffer_ == buffer) + return; cudaGraphicsResource_t resource; cudaSafeCall( cudaGraphicsGLRegisterBuffer(&resource, buffer, cudaGraphicsMapFlagsNone) ); + release(); + resource_ = resource; + buffer_ = buffer; } - void CudaGlInterop::copyFrom(const GpuMat& mat, cudaStream_t stream) + void CudaResource::release() { - CV_Assert(resource_ != 0); + if (resource_) + cudaGraphicsUnregisterResource(resource_); - cudaSafeCall( cudaGraphicsMapResources(1, &resource_, stream) ); + resource_ = 0; + buffer_ = 0; + } - void* dst_ptr; - size_t num_bytes; - cudaSafeCall( cudaGraphicsResourceGetMappedPointer(&dst_ptr, &num_bytes, resource_) ); + class CudaResource::GraphicsMapHolder + { + public: + GraphicsMapHolder(cudaGraphicsResource_t* resource, cudaStream_t stream); + ~GraphicsMapHolder(); - const void* src_ptr = mat.ptr(); - size_t widthBytes = mat.cols * mat.elemSize(); + void reset(); - CV_Assert(widthBytes * mat.rows <= num_bytes); + private: + cudaGraphicsResource_t* resource_; + cudaStream_t stream_; + }; + + CudaResource::GraphicsMapHolder::GraphicsMapHolder(cudaGraphicsResource_t* resource, cudaStream_t stream) : resource_(resource), stream_(stream) + { + if (resource_) + cudaSafeCall( cudaGraphicsMapResources(1, resource_, stream_) ); + } + + CudaResource::GraphicsMapHolder::~GraphicsMapHolder() + { + if (resource_) + cudaGraphicsUnmapResources(1, resource_, stream_); + } + + void CudaResource::GraphicsMapHolder::reset() + { + resource_ = 0; + } + + void CudaResource::copyFrom(const void* src, size_t spitch, size_t width, size_t height, cudaStream_t stream) + { + CV_DbgAssert( resource_ != 0 ); + + GraphicsMapHolder h(&resource_, stream); + (void) h; + + void* dst; + size_t size; + cudaSafeCall( cudaGraphicsResourceGetMappedPointer(&dst, &size, resource_) ); + + CV_DbgAssert( width * height == size ); if (stream == 0) - cudaSafeCall( cudaMemcpy2D(dst_ptr, widthBytes, src_ptr, mat.step, widthBytes, mat.rows, cudaMemcpyDeviceToDevice) ); + cudaSafeCall( cudaMemcpy2D(dst, width, src, spitch, width, height, cudaMemcpyDeviceToDevice) ); else - cudaSafeCall( cudaMemcpy2DAsync(dst_ptr, widthBytes, src_ptr, mat.step, widthBytes, mat.rows, cudaMemcpyDeviceToDevice, stream) ); - - cudaGraphicsUnmapResources(1, &resource_, stream); + cudaSafeCall( cudaMemcpy2DAsync(dst, width, src, spitch, width, height, cudaMemcpyDeviceToDevice, stream) ); } - GpuMat CudaGlInterop::map(int rows, int cols, int type, cudaStream_t stream) + void CudaResource::copyTo(void* dst, size_t dpitch, size_t width, size_t height, cudaStream_t stream) { - CV_Assert(resource_ != 0); + CV_DbgAssert( resource_ != 0 ); - cudaSafeCall( cudaGraphicsMapResources(1, &resource_, stream) ); + GraphicsMapHolder h(&resource_, stream); + (void) h; + + void* src; + size_t size; + cudaSafeCall( cudaGraphicsResourceGetMappedPointer(&src, &size, resource_) ); + + CV_DbgAssert( width * height == size ); + + if (stream == 0) + cudaSafeCall( cudaMemcpy2D(dst, dpitch, src, width, width, height, cudaMemcpyDeviceToDevice) ); + else + cudaSafeCall( cudaMemcpy2DAsync(dst, dpitch, src, width, width, height, cudaMemcpyDeviceToDevice, stream) ); + } + + void* CudaResource::map(cudaStream_t stream) + { + CV_DbgAssert( resource_ != 0 ); + + GraphicsMapHolder h(&resource_, stream); void* ptr; - size_t num_bytes; - cudaSafeCall( cudaGraphicsResourceGetMappedPointer(&ptr, &num_bytes, resource_) ); + size_t size; + cudaSafeCall( cudaGraphicsResourceGetMappedPointer(&ptr, &size, resource_) ); - CV_Assert( static_cast(cols) * CV_ELEM_SIZE(type) * rows <= num_bytes ); + h.reset(); - return GpuMat(rows, cols, type, ptr); + return ptr; } - inline void CudaGlInterop::unmap(cudaStream_t stream) + void CudaResource::unmap(cudaStream_t stream) { + CV_Assert( resource_ != 0 ); + cudaGraphicsUnmapResources(1, &resource_, stream); } } -#endif // HAVE_CUDA && HAVE_OPENGL + +#endif //////////////////////////////////////////////////////////////////////// // GlBuffer @@ -296,393 +326,457 @@ class cv::GlBuffer::Impl public: static const Ptr& empty(); - Impl(int rows, int cols, int type, unsigned int target); - Impl(const Mat& m, unsigned int target); + Impl(GLuint bufId, bool autoRelease); + Impl(GLsizeiptr size, const GLvoid* data, GLenum target); ~Impl(); - void copyFrom(const Mat& m, unsigned int target); + void bind(GLenum target) const; + + void copyFrom(GLuint srcBuf, GLsizeiptr size); + + void copyFrom(GLsizeiptr size, const GLvoid* data); + void copyTo(GLsizeiptr size, GLvoid* data) const; + + void* mapHost(); + void unmapHost(); #ifdef HAVE_CUDA - void copyFrom(const GpuMat& mat, cudaStream_t stream = 0); -#endif + void copyFrom(const void* src, size_t spitch, size_t width, size_t height, cudaStream_t stream = 0); + void copyTo(void* dst, size_t dpitch, size_t width, size_t height, cudaStream_t stream = 0) const; - void bind(unsigned int target) const; - void unbind(unsigned int target) const; - - Mat mapHost(int rows, int cols, int type, unsigned int target); - void unmapHost(unsigned int target); - -#ifdef HAVE_CUDA - GpuMat mapDevice(int rows, int cols, int type, cudaStream_t stream = 0); + void* mapDevice(cudaStream_t stream = 0); void unmapDevice(cudaStream_t stream = 0); #endif + void setAutoRelease(bool flag) { autoRelease_ = flag; } + + GLuint bufId() const { return bufId_; } + private: Impl(); - unsigned int buffer_; + GLuint bufId_; + bool autoRelease_; #ifdef HAVE_CUDA - CudaGlInterop cudaGlInterop_; + mutable CudaResource cudaResource_; #endif }; -inline const Ptr& cv::GlBuffer::Impl::empty() +const Ptr& cv::GlBuffer::Impl::empty() { static Ptr p(new Impl); return p; } -inline cv::GlBuffer::Impl::Impl() : buffer_(0) +cv::GlBuffer::Impl::Impl() : bufId_(0), autoRelease_(true) { } -cv::GlBuffer::Impl::Impl(int rows, int cols, int type, unsigned int target) : buffer_(0) +cv::GlBuffer::Impl::Impl(GLuint abufId, bool autoRelease) : bufId_(abufId), autoRelease_(autoRelease) { - if (!glFuncTab()->isGlContextInitialized()) - throw_nogl; - - CV_DbgAssert(rows > 0 && cols > 0); - CV_DbgAssert(CV_MAT_DEPTH(type) >= 0 && CV_MAT_DEPTH(type) <= CV_64F); - - glFuncTab()->genBuffers(1, &buffer_); - CV_CheckGlError(); - CV_Assert(buffer_ != 0); - - size_t size = rows * cols * CV_ELEM_SIZE(type); - - glFuncTab()->bindBuffer(target, buffer_); - CV_CheckGlError(); - - glFuncTab()->bufferData(target, size, 0, GL_DYNAMIC_DRAW); - CV_CheckGlError(); - - glFuncTab()->bindBuffer(target, 0); - -#ifdef HAVE_CUDA - if (g_isCudaGlDeviceInitialized) - cudaGlInterop_.registerBuffer(buffer_); -#endif } -cv::GlBuffer::Impl::Impl(const Mat& m, unsigned int target) : buffer_(0) +cv::GlBuffer::Impl::Impl(GLsizeiptr size, const GLvoid* data, GLenum target) : bufId_(0), autoRelease_(true) { - if (!glFuncTab()->isGlContextInitialized()) - throw_nogl; - - CV_DbgAssert(m.rows > 0 && m.cols > 0); - CV_DbgAssert(m.depth() >= 0 && m.depth() <= CV_64F); - CV_Assert(m.isContinuous()); - - glFuncTab()->genBuffers(1, &buffer_); - CV_CheckGlError(); - CV_Assert(buffer_ != 0); - - size_t size = m.rows * m.cols * m.elemSize(); - - glFuncTab()->bindBuffer(target, buffer_); + gl::GenBuffers(1, &bufId_); CV_CheckGlError(); - glFuncTab()->bufferData(target, size, m.data, GL_DYNAMIC_DRAW); + CV_Assert( bufId_ != 0 ); + + gl::BindBuffer(target, bufId_); CV_CheckGlError(); - glFuncTab()->bindBuffer(target, 0); + gl::BufferData(target, size, data, gl::DYNAMIC_DRAW); + CV_CheckGlError(); -#ifdef HAVE_CUDA - if (g_isCudaGlDeviceInitialized) - cudaGlInterop_.registerBuffer(buffer_); -#endif + gl::BindBuffer(target, 0); + CV_CheckGlError(); } cv::GlBuffer::Impl::~Impl() { - try + if (autoRelease_ && bufId_) + gl::DeleteBuffers(1, &bufId_); +} + +void cv::GlBuffer::Impl::bind(GLenum target) const +{ + gl::BindBuffer(target, bufId_); + CV_CheckGlError(); +} + +void cv::GlBuffer::Impl::copyFrom(GLuint srcBuf, GLsizeiptr size) +{ + gl::BindBuffer(gl::COPY_WRITE_BUFFER, bufId_); + CV_CheckGlError(); + + gl::BindBuffer(gl::COPY_READ_BUFFER, srcBuf); + CV_CheckGlError(); + + gl::CopyBufferSubData(gl::COPY_READ_BUFFER, gl::COPY_WRITE_BUFFER, 0, 0, size); + CV_CheckGlError(); +} + +void cv::GlBuffer::Impl::copyFrom(GLsizeiptr size, const GLvoid* data) +{ + gl::BindBuffer(gl::COPY_WRITE_BUFFER, bufId_); + CV_CheckGlError(); + + gl::BufferSubData(gl::COPY_WRITE_BUFFER, 0, size, data); + CV_CheckGlError(); +} + +void cv::GlBuffer::Impl::copyTo(GLsizeiptr size, GLvoid* data) const +{ + gl::BindBuffer(gl::COPY_READ_BUFFER, bufId_); + CV_CheckGlError(); + + gl::GetBufferSubData(gl::COPY_READ_BUFFER, 0, size, data); + CV_CheckGlError(); +} + +void* cv::GlBuffer::Impl::mapHost() +{ + gl::BindBuffer(gl::COPY_READ_BUFFER, bufId_); + CV_CheckGlError(); + + GLvoid* data = gl::MapBuffer(gl::COPY_READ_BUFFER, gl::READ_WRITE); + CV_CheckGlError(); + + return data; +} + +void cv::GlBuffer::Impl::unmapHost() +{ + gl::UnmapBuffer(gl::COPY_READ_BUFFER); +} + +#ifdef HAVE_CUDA + void cv::GlBuffer::Impl::copyFrom(const void* src, size_t spitch, size_t width, size_t height, cudaStream_t stream) { - if (buffer_) - glFuncTab()->deleteBuffers(1, &buffer_); + cudaResource_.registerBuffer(bufId_); + cudaResource_.copyFrom(src, spitch, width, height, stream); } -#ifdef _DEBUG - catch(const exception& e) + + void cv::GlBuffer::Impl::copyTo(void* dst, size_t dpitch, size_t width, size_t height, cudaStream_t stream) const { - cerr << e.what() << endl; + cudaResource_.registerBuffer(bufId_); + cudaResource_.copyTo(dst, dpitch, width, height, stream); + } + + void* cv::GlBuffer::Impl::mapDevice(cudaStream_t stream) + { + cudaResource_.registerBuffer(bufId_); + return cudaResource_.map(stream); + } + + void cv::GlBuffer::Impl::unmapDevice(cudaStream_t stream) + { + cudaResource_.unmap(stream); } #endif - catch(...) - { - } -} - -void cv::GlBuffer::Impl::copyFrom(const Mat& m, unsigned int target) -{ - CV_Assert(buffer_ != 0); - - CV_Assert(m.isContinuous()); - - bind(target); - - size_t size = m.rows * m.cols * m.elemSize(); - - glFuncTab()->bufferSubData(target, 0, size, m.data); - CV_CheckGlError(); - - unbind(target); -} - -#ifdef HAVE_CUDA - -void cv::GlBuffer::Impl::copyFrom(const GpuMat& mat, cudaStream_t stream) -{ - if (!g_isCudaGlDeviceInitialized) - cvError(CV_GpuApiCallError, "copyFrom", "cuda GL device wasn't initialized, call setGlDevice", __FILE__, __LINE__); - - CV_Assert(buffer_ != 0); - - cudaGlInterop_.copyFrom(mat, stream); -} - -#endif // HAVE_CUDA - -inline void cv::GlBuffer::Impl::bind(unsigned int target) const -{ - CV_Assert(buffer_ != 0); - - glFuncTab()->bindBuffer(target, buffer_); - CV_CheckGlError(); -} - -inline void cv::GlBuffer::Impl::unbind(unsigned int target) const -{ - glFuncTab()->bindBuffer(target, 0); -} - -inline Mat cv::GlBuffer::Impl::mapHost(int rows, int cols, int type, unsigned int target) -{ - void* ptr = glFuncTab()->mapBuffer(target, GL_READ_WRITE); - CV_CheckGlError(); - - return Mat(rows, cols, type, ptr); -} - -inline void cv::GlBuffer::Impl::unmapHost(unsigned int target) -{ - glFuncTab()->unmapBuffer(target); -} - -#ifdef HAVE_CUDA - -inline GpuMat cv::GlBuffer::Impl::mapDevice(int rows, int cols, int type, cudaStream_t stream) -{ - if (!g_isCudaGlDeviceInitialized) - cvError(CV_GpuApiCallError, "copyFrom", "cuda GL device wasn't initialized, call setGlDevice", __FILE__, __LINE__); - - CV_Assert(buffer_ != 0); - - return cudaGlInterop_.map(rows, cols, type, stream); -} - -inline void cv::GlBuffer::Impl::unmapDevice(cudaStream_t stream) -{ - if (!g_isCudaGlDeviceInitialized) - cvError(CV_GpuApiCallError, "copyFrom", "cuda GL device wasn't initialized, call setGlDevice", __FILE__, __LINE__); - - cudaGlInterop_.unmap(stream); -} - -#endif // HAVE_CUDA #endif // HAVE_OPENGL -cv::GlBuffer::GlBuffer(Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage) +cv::GlBuffer::GlBuffer() : rows_(0), cols_(0), type_(0) { #ifndef HAVE_OPENGL - (void)_usage; - throw_nogl; + throw_nogl(); #else impl_ = Impl::empty(); #endif } -cv::GlBuffer::GlBuffer(int _rows, int _cols, int _type, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage) +cv::GlBuffer::GlBuffer(int arows, int acols, int atype, unsigned int abufId, bool autoRelease) : rows_(0), cols_(0), type_(0) { #ifndef HAVE_OPENGL - (void)_rows; - (void)_cols; - (void)_type; - (void)_usage; - throw_nogl; + (void) arows; + (void) acols; + (void) atype; + (void) abufId; + (void) autoRelease; + throw_nogl(); #else - impl_ = new Impl(_rows, _cols, _type, _usage); - rows_ = _rows; - cols_ = _cols; - type_ = _type; + impl_ = new Impl(abufId, autoRelease); + rows_ = arows; + cols_ = acols; + type_ = atype; #endif } -cv::GlBuffer::GlBuffer(Size _size, int _type, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage) +cv::GlBuffer::GlBuffer(Size asize, int atype, unsigned int abufId, bool autoRelease) : rows_(0), cols_(0), type_(0) { #ifndef HAVE_OPENGL - (void)_size; - (void)_type; - (void)_usage; - throw_nogl; + (void) asize; + (void) atype; + (void) abufId; + (void) autoRelease; + throw_nogl(); #else - impl_ = new Impl(_size.height, _size.width, _type, _usage); - rows_ = _size.height; - cols_ = _size.width; - type_ = _type; + impl_ = new Impl(abufId, autoRelease); + rows_ = asize.height; + cols_ = asize.width; + type_ = atype; #endif } -cv::GlBuffer::GlBuffer(InputArray mat_, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage) +cv::GlBuffer::GlBuffer(int arows, int acols, int atype, Target target) : rows_(0), cols_(0), type_(0) +{ + create(arows, acols, atype, target); +} + +cv::GlBuffer::GlBuffer(Size asize, int atype, Target target) : rows_(0), cols_(0), type_(0) +{ + create(asize, atype, target); +} + +cv::GlBuffer::GlBuffer(InputArray arr, Target target) : rows_(0), cols_(0), type_(0) { #ifndef HAVE_OPENGL - (void)mat_; - (void)_usage; - throw_nogl; + (void) arr; + (void) target; + throw_nogl(); #else - int kind = mat_.kind(); - Size _size = mat_.size(); - int _type = mat_.type(); + const int kind = arr.kind(); - if (kind == _InputArray::GPU_MAT) + switch (kind) { - #if !defined HAVE_CUDA || defined(CUDA_DISABLER) - throw_nocuda; - #else - GpuMat d_mat = mat_.getGpuMat(); - impl_ = new Impl(d_mat.rows, d_mat.cols, d_mat.type(), _usage); - impl_->copyFrom(d_mat); - #endif + case _InputArray::OPENGL_BUFFER: + { + copyFrom(arr, target); + break; + } + + case _InputArray::OPENGL_TEXTURE2D: + { + copyFrom(arr, target); + break; + } + + case _InputArray::GPU_MAT: + { + copyFrom(arr, target); + break; + } + + default: + { + Mat mat = arr.getMat(); + CV_Assert( mat.isContinuous() ); + const GLsizeiptr asize = mat.rows * mat.cols * mat.elemSize(); + impl_ = new Impl(asize, mat.data, target); + rows_ = mat.rows; + cols_ = mat.cols; + type_ = mat.type(); + break; + } } - else - { - Mat mat = mat_.getMat(); - impl_ = new Impl(mat, _usage); - } - - rows_ = _size.height; - cols_ = _size.width; - type_ = _type; #endif } -void cv::GlBuffer::create(int _rows, int _cols, int _type, Usage _usage) +void cv::GlBuffer::create(int arows, int acols, int atype, Target target) { #ifndef HAVE_OPENGL - (void)_rows; - (void)_cols; - (void)_type; - (void)_usage; - throw_nogl; + (void) arows; + (void) acols; + (void) atype; + (void) target; + throw_nogl(); #else - if (rows_ != _rows || cols_ != _cols || type_ != _type || usage_ != _usage) + if (rows_ != arows || cols_ != acols || type_ != atype) { - impl_ = new Impl(_rows, _cols, _type, _usage); - rows_ = _rows; - cols_ = _cols; - type_ = _type; - usage_ = _usage; + const GLsizeiptr asize = arows * acols * CV_ELEM_SIZE(atype); + impl_ = new Impl(asize, 0, target); + rows_ = arows; + cols_ = acols; + type_ = atype; } #endif } void cv::GlBuffer::release() { -#ifndef HAVE_OPENGL - throw_nogl; -#else +#ifdef HAVE_OPENGL impl_ = Impl::empty(); + rows_ = 0; + cols_ = 0; + type_ = 0; #endif } -void cv::GlBuffer::copyFrom(InputArray mat_) +void cv::GlBuffer::setAutoRelease(bool flag) { #ifndef HAVE_OPENGL - (void)mat_; - throw_nogl; + (void) flag; + throw_nogl(); #else - int kind = mat_.kind(); - Size _size = mat_.size(); - int _type = mat_.type(); + impl_->setAutoRelease(flag); +#endif +} - create(_size, _type); +void cv::GlBuffer::copyFrom(InputArray arr, Target target) +{ +#ifndef HAVE_OPENGL + (void) arr; + (void) target; + throw_nogl(); +#else + const int kind = arr.kind(); + + if (kind == _InputArray::OPENGL_TEXTURE2D) + { + GlTexture2D tex = arr.getGlTexture2D(); + tex.copyTo(*this); + return; + } + + const Size asize = arr.size(); + const int atype = arr.type(); + create(asize, atype, target); switch (kind) { case _InputArray::OPENGL_BUFFER: { - GlBuffer buf = mat_.getGlBuffer(); - *this = buf; + GlBuffer buf = arr.getGlBuffer(); + impl_->copyFrom(buf.bufId(), asize.area() * CV_ELEM_SIZE(atype)); break; } + case _InputArray::GPU_MAT: { #if !defined HAVE_CUDA || defined(CUDA_DISABLER) - throw_nocuda; + throw_nocuda(); #else - GpuMat d_mat = mat_.getGpuMat(); - impl_->copyFrom(d_mat); + GpuMat dmat = arr.getGpuMat(); + impl_->copyFrom(dmat.data, dmat.step, dmat.cols * dmat.elemSize(), dmat.rows); #endif break; } + default: { - Mat mat = mat_.getMat(); - impl_->copyFrom(mat, usage_); + Mat mat = arr.getMat(); + CV_Assert( mat.isContinuous() ); + impl_->copyFrom(asize.area() * CV_ELEM_SIZE(atype), mat.data); } } #endif } -void cv::GlBuffer::bind() const +void cv::GlBuffer::copyTo(OutputArray arr, Target target) const { #ifndef HAVE_OPENGL - throw_nogl; + (void) arr; + (void) target; + throw_nogl(); #else - impl_->bind(usage_); + const int kind = arr.kind(); + + switch (kind) + { + case _InputArray::OPENGL_BUFFER: + { + arr.getGlBufferRef().copyFrom(*this, target); + break; + } + + case _InputArray::OPENGL_TEXTURE2D: + { + arr.getGlTexture2DRef().copyFrom(*this); + break; + } + + case _InputArray::GPU_MAT: + { + #if !defined HAVE_CUDA || defined(CUDA_DISABLER) + throw_nocuda(); + #else + GpuMat& dmat = arr.getGpuMatRef(); + dmat.create(rows_, cols_, type_); + impl_->copyTo(dmat.data, dmat.step, dmat.cols * dmat.elemSize(), dmat.rows); + #endif + + break; + } + + default: + { + arr.create(rows_, cols_, type_); + Mat mat = arr.getMat(); + CV_Assert( mat.isContinuous() ); + impl_->copyTo(mat.rows * mat.cols * mat.elemSize(), mat.data); + } + } #endif } -void cv::GlBuffer::unbind() const +GlBuffer cv::GlBuffer::clone(Target target) const { #ifndef HAVE_OPENGL - throw_nogl; + (void) target; + throw_nogl(); + return GlBuffer(); #else - impl_->unbind(usage_); + GlBuffer buf; + buf.copyFrom(*this, target); + return buf; +#endif +} + +void cv::GlBuffer::bind(Target target) const +{ +#ifndef HAVE_OPENGL + (void) target; + throw_nogl(); +#else + impl_->bind(target); +#endif +} + +void cv::GlBuffer::unbind(Target target) +{ +#ifndef HAVE_OPENGL + (void) target; + throw_nogl(); +#else + gl::BindBuffer(target, 0); + CV_CheckGlError(); #endif } Mat cv::GlBuffer::mapHost() { #ifndef HAVE_OPENGL - throw_nogl; + throw_nogl(); return Mat(); #else - return impl_->mapHost(rows_, cols_, type_, usage_); + return Mat(rows_, cols_, type_, impl_->mapHost()); #endif } void cv::GlBuffer::unmapHost() { #ifndef HAVE_OPENGL - throw_nogl; + throw_nogl(); #else - impl_->unmapHost(usage_); + return impl_->unmapHost(); #endif } GpuMat cv::GlBuffer::mapDevice() { #ifndef HAVE_OPENGL - throw_nogl; + throw_nogl(); return GpuMat(); #else #if !defined HAVE_CUDA || defined(CUDA_DISABLER) - throw_nocuda; + throw_nocuda(); return GpuMat(); #else - return impl_->mapDevice(rows_, cols_, type_); + return GpuMat(rows_, cols_, type_, impl_->mapDevice()); #endif #endif } @@ -690,418 +784,437 @@ GpuMat cv::GlBuffer::mapDevice() void cv::GlBuffer::unmapDevice() { #ifndef HAVE_OPENGL - throw_nogl; + throw_nogl(); #else #if !defined HAVE_CUDA || defined(CUDA_DISABLER) - throw_nocuda; + throw_nocuda(); #else impl_->unmapDevice(); #endif #endif } +unsigned int cv::GlBuffer::bufId() const +{ +#ifndef HAVE_OPENGL + throw_nogl(); + return 0; +#else + return impl_->bufId(); +#endif +} + template <> void cv::Ptr::delete_obj() { if (obj) delete obj; } ////////////////////////////////////////////////////////////////////////////////////////// -// GlTexture +// GlTexture2D #ifndef HAVE_OPENGL -class cv::GlTexture::Impl +class cv::GlTexture2D::Impl { }; #else -class cv::GlTexture::Impl +class cv::GlTexture2D::Impl { public: static const Ptr empty(); - Impl(int rows, int cols, int type); - - Impl(const Mat& mat, bool bgra); - Impl(const GlBuffer& buf, bool bgra); - + Impl(GLuint texId, bool autoRelease); + Impl(GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels); ~Impl(); - void copyFrom(const Mat& mat, bool bgra); - void copyFrom(const GlBuffer& buf, bool bgra); + void copyFrom(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); + void copyTo(GLenum format, GLenum type, GLvoid* pixels) const; void bind() const; - void unbind() const; + + void setAutoRelease(bool flag) { autoRelease_ = flag; } + + GLuint texId() const { return texId_; } private: Impl(); - GLuint tex_; + GLuint texId_; + bool autoRelease_; }; -inline const Ptr cv::GlTexture::Impl::empty() +const Ptr cv::GlTexture2D::Impl::empty() { static Ptr p(new Impl); return p; } -inline cv::GlTexture::Impl::Impl() : tex_(0) +cv::GlTexture2D::Impl::Impl() : texId_(0), autoRelease_(true) { } -cv::GlTexture::Impl::Impl(int rows, int cols, int type) : tex_(0) +cv::GlTexture2D::Impl::Impl(GLuint atexId, bool autoRelease) : texId_(atexId), autoRelease_(autoRelease) { - if (!glFuncTab()->isGlContextInitialized()) - throw_nogl; +} - int depth = CV_MAT_DEPTH(type); - int cn = CV_MAT_CN(type); - - CV_DbgAssert(rows > 0 && cols > 0); - CV_Assert(cn == 1 || cn == 3 || cn == 4); - CV_Assert(depth >= 0 && depth <= CV_32F); - - glGenTextures(1, &tex_); - CV_CheckGlError(); - CV_Assert(tex_ != 0); - - glBindTexture(GL_TEXTURE_2D, tex_); +cv::GlTexture2D::Impl::Impl(GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels) : texId_(0), autoRelease_(true) +{ + gl::GenTextures(1, &texId_); CV_CheckGlError(); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + CV_Assert(texId_ != 0); + + gl::BindTexture(gl::TEXTURE_2D, texId_); CV_CheckGlError(); - GLenum format = cn == 1 ? GL_LUMINANCE : cn == 3 ? GL_BGR : GL_BGRA; - - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + gl::PixelStorei(gl::UNPACK_ALIGNMENT, 1); CV_CheckGlError(); - glTexImage2D(GL_TEXTURE_2D, 0, cn, cols, rows, 0, format, gl_types[depth], 0); + gl::TexImage2D(gl::TEXTURE_2D, 0, internalFormat, width, height, 0, format, type, pixels); + CV_CheckGlError(); + + gl::GenerateMipmap(gl::TEXTURE_2D); CV_CheckGlError(); } -cv::GlTexture::Impl::Impl(const Mat& mat, bool bgra) : tex_(0) +cv::GlTexture2D::Impl::~Impl() { - if (!glFuncTab()->isGlContextInitialized()) - throw_nogl; + if (autoRelease_ && texId_) + gl::DeleteTextures(1, &texId_); +} - int depth = mat.depth(); - int cn = mat.channels(); - - CV_DbgAssert(mat.rows > 0 && mat.cols > 0); - CV_Assert(cn == 1 || cn == 3 || cn == 4); - CV_Assert(depth >= 0 && depth <= CV_32F); - CV_Assert(mat.isContinuous()); - - glGenTextures(1, &tex_); - CV_CheckGlError(); - CV_Assert(tex_ != 0); - - glBindTexture(GL_TEXTURE_2D, tex_); +void cv::GlTexture2D::Impl::copyFrom(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) +{ + gl::BindTexture(gl::TEXTURE_2D, texId_); CV_CheckGlError(); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + gl::PixelStorei(gl::UNPACK_ALIGNMENT, 1); CV_CheckGlError(); - GLenum format = cn == 1 ? GL_LUMINANCE : (cn == 3 ? (bgra ? GL_BGR : GL_RGB) : (bgra ? GL_BGRA : GL_RGBA)); - - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + gl::TexSubImage2D(gl::TEXTURE_2D, 0, 0, 0, width, height, format, type, pixels); CV_CheckGlError(); - glTexImage2D(GL_TEXTURE_2D, 0, cn, mat.cols, mat.rows, 0, format, gl_types[depth], mat.data); + gl::GenerateMipmap(gl::TEXTURE_2D); CV_CheckGlError(); } -cv::GlTexture::Impl::Impl(const GlBuffer& buf, bool bgra) : tex_(0) +void cv::GlTexture2D::Impl::copyTo(GLenum format, GLenum type, GLvoid* pixels) const { - if (!glFuncTab()->isGlContextInitialized()) - throw_nogl; - - int depth = buf.depth(); - int cn = buf.channels(); - - CV_DbgAssert(buf.rows() > 0 && buf.cols() > 0); - CV_Assert(cn == 1 || cn == 3 || cn == 4); - CV_Assert(depth >= 0 && depth <= CV_32F); - CV_Assert(buf.usage() == GlBuffer::TEXTURE_BUFFER); - - glGenTextures(1, &tex_); - CV_CheckGlError(); - CV_Assert(tex_ != 0); - - glBindTexture(GL_TEXTURE_2D, tex_); + gl::BindTexture(gl::TEXTURE_2D, texId_); CV_CheckGlError(); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + gl::PixelStorei(gl::PACK_ALIGNMENT, 1); CV_CheckGlError(); - GLenum format = cn == 1 ? GL_LUMINANCE : (cn == 3 ? (bgra ? GL_BGR : GL_RGB) : (bgra ? GL_BGRA : GL_RGBA)); - - buf.bind(); - - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - CV_CheckGlError(); - - glTexImage2D(GL_TEXTURE_2D, 0, cn, buf.cols(), buf.rows(), 0, format, gl_types[depth], 0); - CV_CheckGlError(); - - buf.unbind(); -} - -inline cv::GlTexture::Impl::~Impl() -{ - if (tex_) - glDeleteTextures(1, &tex_); -} - -void cv::GlTexture::Impl::copyFrom(const Mat& mat, bool bgra) -{ - CV_Assert(tex_ != 0); - - bind(); - - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - CV_CheckGlError(); - - int cn = mat.channels(); - GLenum format = cn == 1 ? GL_LUMINANCE : (cn == 3 ? (bgra ? GL_BGR : GL_RGB) : (bgra ? GL_BGRA : GL_RGBA)); - - glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, mat.cols, mat.rows, format, gl_types[mat.depth()], mat.data); - CV_CheckGlError(); - - unbind(); -} - -void cv::GlTexture::Impl::copyFrom(const GlBuffer& buf, bool bgra) -{ - CV_Assert(tex_ != 0); - CV_Assert(buf.usage() == GlBuffer::TEXTURE_BUFFER); - - bind(); - - buf.bind(); - - glPixelStorei(GL_UNPACK_ALIGNMENT, 1); - CV_CheckGlError(); - - int cn = buf.channels(); - GLenum format = cn == 1 ? GL_LUMINANCE : (cn == 3 ? (bgra ? GL_BGR : GL_RGB) : (bgra ? GL_BGRA : GL_RGBA)); - - glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, buf.cols(), buf.rows(), format, gl_types[buf.depth()], 0); - CV_CheckGlError(); - - buf.unbind(); - - unbind(); -} - -inline void cv::GlTexture::Impl::bind() const -{ - CV_Assert(tex_ != 0); - - glEnable(GL_TEXTURE_2D); - CV_CheckGlError(); - - glBindTexture(GL_TEXTURE_2D, tex_); + gl::GetTexImage(gl::TEXTURE_2D, 0, format, type, pixels); CV_CheckGlError(); } -inline void cv::GlTexture::Impl::unbind() const +void cv::GlTexture2D::Impl::bind() const { - glBindTexture(GL_TEXTURE_2D, 0); - - glDisable(GL_TEXTURE_2D); + gl::BindTexture(gl::TEXTURE_2D, texId_); + CV_CheckGlError(); } #endif // HAVE_OPENGL -cv::GlTexture::GlTexture() : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER) +cv::GlTexture2D::GlTexture2D() : rows_(0), cols_(0), format_(NONE) { #ifndef HAVE_OPENGL - throw_nogl; + throw_nogl(); #else impl_ = Impl::empty(); #endif } -cv::GlTexture::GlTexture(int _rows, int _cols, int _type) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER) +cv::GlTexture2D::GlTexture2D(int arows, int acols, Format aformat, unsigned int atexId, bool autoRelease) : rows_(0), cols_(0), format_(NONE) { #ifndef HAVE_OPENGL - (void)_rows; - (void)_cols; - (void)_type; - throw_nogl; + (void) arows; + (void) acols; + (void) aformat; + (void) atexId; + (void) autoRelease; + throw_nogl(); #else - impl_ = new Impl(_rows, _cols, _type); - rows_ = _rows; - cols_ = _cols; - type_ = _type; + impl_ = new Impl(atexId, autoRelease); + rows_ = arows; + cols_ = acols; + format_ = aformat; #endif } -cv::GlTexture::GlTexture(Size _size, int _type) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER) +cv::GlTexture2D::GlTexture2D(Size asize, Format aformat, unsigned int atexId, bool autoRelease) : rows_(0), cols_(0), format_(NONE) { #ifndef HAVE_OPENGL - (void)_size; - (void)_type; - throw_nogl; + (void) asize; + (void) aformat; + (void) atexId; + (void) autoRelease; + throw_nogl(); #else - impl_ = new Impl(_size.height, _size.width, _type); - rows_ = _size.height; - cols_ = _size.width; - type_ = _type; + impl_ = new Impl(atexId, autoRelease); + rows_ = asize.height; + cols_ = asize.width; + format_ = aformat; #endif } -cv::GlTexture::GlTexture(InputArray mat_, bool bgra) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER) +cv::GlTexture2D::GlTexture2D(int arows, int acols, Format aformat) : rows_(0), cols_(0), format_(NONE) +{ + create(arows, acols, aformat); +} + +cv::GlTexture2D::GlTexture2D(Size asize, Format aformat) : rows_(0), cols_(0), format_(NONE) +{ + create(asize, aformat); +} + +cv::GlTexture2D::GlTexture2D(InputArray arr) : rows_(0), cols_(0), format_(NONE) { #ifndef HAVE_OPENGL - (void)mat_; - (void)bgra; - throw_nogl; + (void) arr; + throw_nogl(); #else - int kind = mat_.kind(); - Size _size = mat_.size(); - int _type = mat_.type(); + const int kind = arr.kind(); + + const Size asize = arr.size(); + const int atype = arr.type(); + + const int depth = CV_MAT_DEPTH(atype); + const int cn = CV_MAT_CN(atype); + + CV_Assert( depth <= CV_32F ); + CV_Assert( cn == 1 || cn == 3 || cn == 4 ); + + const Format internalFormats[] = + { + NONE, DEPTH_COMPONENT, NONE, RGB, RGBA + }; + const GLenum srcFormats[] = + { + 0, gl::DEPTH_COMPONENT, 0, gl::BGR, gl::BGRA + }; switch (kind) { case _InputArray::OPENGL_BUFFER: { - GlBuffer buf = mat_.getGlBuffer(); - impl_ = new Impl(buf, bgra); + GlBuffer buf = arr.getGlBuffer(); + buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER); + impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], 0); + GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); break; } + case _InputArray::GPU_MAT: { #if !defined HAVE_CUDA || defined(CUDA_DISABLER) - throw_nocuda; + throw_nocuda(); #else - GpuMat d_mat = mat_.getGpuMat(); - GlBuffer buf(d_mat, GlBuffer::TEXTURE_BUFFER); - impl_ = new Impl(buf, bgra); + GpuMat dmat = arr.getGpuMat(); + GlBuffer buf(dmat, GlBuffer::PIXEL_UNPACK_BUFFER); + buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER); + impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], 0); + GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); #endif break; } + default: { - Mat mat = mat_.getMat(); - impl_ = new Impl(mat, bgra); + Mat mat = arr.getMat(); + CV_Assert( mat.isContinuous() ); + GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); + impl_ = new Impl(internalFormats[cn], asize.width, asize.height, srcFormats[cn], gl_types[depth], mat.data); break; } } - rows_ = _size.height; - cols_ = _size.width; - type_ = _type; + rows_ = asize.height; + cols_ = asize.width; + format_ = internalFormats[cn]; #endif } -void cv::GlTexture::create(int _rows, int _cols, int _type) +void cv::GlTexture2D::create(int arows, int acols, Format aformat) { #ifndef HAVE_OPENGL - (void)_rows; - (void)_cols; - (void)_type; - throw_nogl; + (void) arows; + (void) acols; + (void) aformat; + throw_nogl(); #else - if (rows_ != _rows || cols_ != _cols || type_ != _type) + if (rows_ != arows || cols_ != acols || format_ != aformat) { - impl_ = new Impl(_rows, _cols, _type); - rows_ = _rows; - cols_ = _cols; - type_ = _type; + GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); + impl_ = new Impl(aformat, acols, arows, aformat, gl::FLOAT, 0); + rows_ = arows; + cols_ = acols; + format_ = aformat; } #endif } -void cv::GlTexture::release() +void cv::GlTexture2D::release() { -#ifndef HAVE_OPENGL - throw_nogl; -#else +#ifdef HAVE_OPENGL impl_ = Impl::empty(); + rows_ = 0; + cols_ = 0; + format_ = NONE; #endif } -void cv::GlTexture::copyFrom(InputArray mat_, bool bgra) +void cv::GlTexture2D::setAutoRelease(bool flag) { #ifndef HAVE_OPENGL - (void)mat_; - (void)bgra; - throw_nogl; + (void) flag; + throw_nogl(); #else - int kind = mat_.kind(); - Size _size = mat_.size(); - int _type = mat_.type(); + impl_->setAutoRelease(flag); +#endif +} - create(_size, _type); +void cv::GlTexture2D::copyFrom(InputArray arr) +{ +#ifndef HAVE_OPENGL + (void) arr; + throw_nogl(); +#else + const int kind = arr.kind(); + + const Size asize = arr.size(); + const int atype = arr.type(); + + const int depth = CV_MAT_DEPTH(atype); + const int cn = CV_MAT_CN(atype); + + CV_Assert( depth <= CV_32F ); + CV_Assert( cn == 1 || cn == 3 || cn == 4 ); + + const Format internalFormats[] = + { + NONE, DEPTH_COMPONENT, NONE, RGB, RGBA + }; + const GLenum srcFormats[] = + { + 0, gl::DEPTH_COMPONENT, 0, gl::BGR, gl::BGRA + }; + + create(asize, internalFormats[cn]); switch(kind) { - case _InputArray::OPENGL_TEXTURE: - { - GlTexture tex = mat_.getGlTexture(); - *this = tex; - break; - } case _InputArray::OPENGL_BUFFER: { - GlBuffer buf = mat_.getGlBuffer(); - impl_->copyFrom(buf, bgra); + GlBuffer buf = arr.getGlBuffer(); + buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER); + impl_->copyFrom(asize.width, asize.height, srcFormats[cn], gl_types[depth], 0); + GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); break; } + case _InputArray::GPU_MAT: { #if !defined HAVE_CUDA || defined(CUDA_DISABLER) - throw_nocuda; + throw_nocuda(); #else - GpuMat d_mat = mat_.getGpuMat(); - buf_.copyFrom(d_mat); - impl_->copyFrom(buf_, bgra); + GpuMat dmat = arr.getGpuMat(); + GlBuffer buf(dmat, GlBuffer::PIXEL_UNPACK_BUFFER); + buf.bind(GlBuffer::PIXEL_UNPACK_BUFFER); + impl_->copyFrom(asize.width, asize.height, srcFormats[cn], gl_types[depth], 0); + GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); #endif break; } + default: { - Mat mat = mat_.getMat(); - impl_->copyFrom(mat, bgra); + Mat mat = arr.getMat(); + CV_Assert( mat.isContinuous() ); + GlBuffer::unbind(GlBuffer::PIXEL_UNPACK_BUFFER); + impl_->copyFrom(asize.width, asize.height, srcFormats[cn], gl_types[depth], mat.data); } } #endif } -void cv::GlTexture::bind() const +void cv::GlTexture2D::copyTo(OutputArray arr, int ddepth) const { #ifndef HAVE_OPENGL - throw_nogl; + (void) arr; + (void) ddepth; + throw_nogl(); +#else + const int kind = arr.kind(); + + const int cn = format_ == DEPTH_COMPONENT ? 1: format_ == RGB ? 3 : 4; + const GLenum dstFormat = format_ == DEPTH_COMPONENT ? gl::DEPTH_COMPONENT : format_ == RGB ? gl::BGR : gl::BGRA; + + switch(kind) + { + case _InputArray::OPENGL_BUFFER: + { + GlBuffer& buf = arr.getGlBufferRef(); + buf.create(rows_, cols_, CV_MAKE_TYPE(ddepth, cn), GlBuffer::PIXEL_PACK_BUFFER); + buf.bind(GlBuffer::PIXEL_PACK_BUFFER); + impl_->copyTo(dstFormat, gl_types[ddepth], 0); + GlBuffer::unbind(GlBuffer::PIXEL_PACK_BUFFER); + break; + } + + case _InputArray::GPU_MAT: + { + #if !defined HAVE_CUDA || defined(CUDA_DISABLER) + throw_nocuda(); + #else + GlBuffer buf(rows_, cols_, CV_MAKE_TYPE(ddepth, cn), GlBuffer::PIXEL_PACK_BUFFER); + buf.bind(GlBuffer::PIXEL_PACK_BUFFER); + impl_->copyTo(dstFormat, gl_types[ddepth], 0); + GlBuffer::unbind(GlBuffer::PIXEL_PACK_BUFFER); + buf.copyTo(arr); + #endif + + break; + } + + default: + { + arr.create(rows_, cols_, CV_MAKE_TYPE(ddepth, cn)); + Mat mat = arr.getMat(); + CV_Assert( mat.isContinuous() ); + GlBuffer::unbind(GlBuffer::PIXEL_PACK_BUFFER); + impl_->copyTo(dstFormat, gl_types[ddepth], mat.data); + } + } +#endif +} + +void cv::GlTexture2D::bind() const +{ +#ifndef HAVE_OPENGL + throw_nogl(); #else impl_->bind(); #endif } -void cv::GlTexture::unbind() const +unsigned int cv::GlTexture2D::texId() const { #ifndef HAVE_OPENGL - throw_nogl; + throw_nogl(); + return 0; #else - impl_->unbind(); + return impl_->texId(); #endif } -template <> void cv::Ptr::delete_obj() +template <> void cv::Ptr::delete_obj() { if (obj) delete obj; } @@ -1109,266 +1222,253 @@ template <> void cv::Ptr::delete_obj() //////////////////////////////////////////////////////////////////////// // GlArrays -void cv::GlArrays::setVertexArray(InputArray vertex) +cv::GlArrays::GlArrays() : size_(0) { - int cn = vertex.channels(); - int depth = vertex.depth(); - - CV_Assert(cn == 2 || cn == 3 || cn == 4); - CV_Assert(depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F); - - vertex_.copyFrom(vertex); } -void cv::GlArrays::setColorArray(InputArray color, bool bgra) +void cv::GlArrays::setVertexArray(InputArray vertex) { - int cn = color.channels(); + const int cn = vertex.channels(); + const int depth = vertex.depth(); - CV_Assert((cn == 3 && !bgra) || cn == 4); + CV_Assert( cn == 2 || cn == 3 || cn == 4 ); + CV_Assert( depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F ); - color_.copyFrom(color); - bgra_ = bgra; + if (vertex.kind() == _InputArray::OPENGL_BUFFER) + vertex_ = vertex.getGlBuffer(); + else + vertex_.copyFrom(vertex); + + size_ = vertex_.size().area(); +} + +void cv::GlArrays::resetVertexArray() +{ + vertex_.release(); + size_ = 0; +} + +void cv::GlArrays::setColorArray(InputArray color) +{ + const int cn = color.channels(); + + CV_Assert( cn == 3 || cn == 4 ); + + if (color.kind() == _InputArray::OPENGL_BUFFER) + color_ = color.getGlBuffer(); + else + color_.copyFrom(color); +} + +void cv::GlArrays::resetColorArray() +{ + color_.release(); } void cv::GlArrays::setNormalArray(InputArray normal) { - int cn = normal.channels(); - int depth = normal.depth(); + const int cn = normal.channels(); + const int depth = normal.depth(); - CV_Assert(cn == 3); - CV_Assert(depth == CV_8S || depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F); + CV_Assert( cn == 3 ); + CV_Assert( depth == CV_8S || depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F ); - normal_.copyFrom(normal); + if (normal.kind() == _InputArray::OPENGL_BUFFER) + normal_ = normal.getGlBuffer(); + else + normal_.copyFrom(normal); +} + +void cv::GlArrays::resetNormalArray() +{ + normal_.release(); } void cv::GlArrays::setTexCoordArray(InputArray texCoord) { - int cn = texCoord.channels(); - int depth = texCoord.depth(); + const int cn = texCoord.channels(); + const int depth = texCoord.depth(); - CV_Assert(cn >= 1 && cn <= 4); - CV_Assert(depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F); + CV_Assert( cn >= 1 && cn <= 4 ); + CV_Assert( depth == CV_16S || depth == CV_32S || depth == CV_32F || depth == CV_64F ); - texCoord_.copyFrom(texCoord); + if (texCoord.kind() == _InputArray::OPENGL_BUFFER) + texCoord_ = texCoord.getGlBuffer(); + else + texCoord_.copyFrom(texCoord); +} + +void cv::GlArrays::resetTexCoordArray() +{ + texCoord_.release(); +} + +void cv::GlArrays::release() +{ + resetVertexArray(); + resetColorArray(); + resetNormalArray(); + resetTexCoordArray(); +} + +void cv::GlArrays::setAutoRelease(bool flag) +{ + vertex_.setAutoRelease(flag); + color_.setAutoRelease(flag); + normal_.setAutoRelease(flag); + texCoord_.setAutoRelease(flag); } void cv::GlArrays::bind() const { #ifndef HAVE_OPENGL - throw_nogl; + throw_nogl(); #else - CV_DbgAssert(texCoord_.empty() || texCoord_.size().area() == vertex_.size().area()); - CV_DbgAssert(normal_.empty() || normal_.size().area() == vertex_.size().area()); - CV_DbgAssert(color_.empty() || color_.size().area() == vertex_.size().area()); + CV_Assert( texCoord_.empty() || texCoord_.size().area() == size_ ); + CV_Assert( normal_.empty() || normal_.size().area() == size_ ); + CV_Assert( color_.empty() || color_.size().area() == size_ ); - if (!texCoord_.empty()) + if (texCoord_.empty()) { - glEnableClientState(GL_TEXTURE_COORD_ARRAY); + gl::DisableClientState(gl::TEXTURE_COORD_ARRAY); CV_CheckGlError(); - - texCoord_.bind(); - - glTexCoordPointer(texCoord_.channels(), gl_types[texCoord_.depth()], 0, 0); - CV_CheckGlError(); - - texCoord_.unbind(); } - - if (!normal_.empty()) + else { - glEnableClientState(GL_NORMAL_ARRAY); + gl::EnableClientState(gl::TEXTURE_COORD_ARRAY); CV_CheckGlError(); - normal_.bind(); + texCoord_.bind(GlBuffer::ARRAY_BUFFER); - glNormalPointer(gl_types[normal_.depth()], 0, 0); - CV_CheckGlError(); - - normal_.unbind(); - } - - if (!color_.empty()) - { - glEnableClientState(GL_COLOR_ARRAY); - CV_CheckGlError(); - - color_.bind(); - - int cn = color_.channels(); - int format = cn == 3 ? cn : (bgra_ ? GL_BGRA : 4); - - glColorPointer(format, gl_types[color_.depth()], 0, 0); - CV_CheckGlError(); - - color_.unbind(); - } - - if (!vertex_.empty()) - { - glEnableClientState(GL_VERTEX_ARRAY); - CV_CheckGlError(); - - vertex_.bind(); - - glVertexPointer(vertex_.channels(), gl_types[vertex_.depth()], 0, 0); - CV_CheckGlError(); - - vertex_.unbind(); - } -#endif -} - -void cv::GlArrays::unbind() const -{ -#ifndef HAVE_OPENGL - throw_nogl; -#else - if (!texCoord_.empty()) - { - glDisableClientState(GL_TEXTURE_COORD_ARRAY); + gl::TexCoordPointer(texCoord_.channels(), gl_types[texCoord_.depth()], 0, 0); CV_CheckGlError(); } - if (!normal_.empty()) + if (normal_.empty()) { - glDisableClientState(GL_NORMAL_ARRAY); + gl::DisableClientState(gl::NORMAL_ARRAY); + CV_CheckGlError(); + } + else + { + gl::EnableClientState(gl::NORMAL_ARRAY); + CV_CheckGlError(); + + normal_.bind(GlBuffer::ARRAY_BUFFER); + + gl::NormalPointer(gl_types[normal_.depth()], 0, 0); CV_CheckGlError(); } - if (!color_.empty()) + if (color_.empty()) { - glDisableClientState(GL_COLOR_ARRAY); + gl::DisableClientState(gl::COLOR_ARRAY); + CV_CheckGlError(); + } + else + { + gl::EnableClientState(gl::COLOR_ARRAY); + CV_CheckGlError(); + + color_.bind(GlBuffer::ARRAY_BUFFER); + + const int cn = color_.channels(); + + gl::ColorPointer(cn, gl_types[color_.depth()], 0, 0); CV_CheckGlError(); } - if (!vertex_.empty()) + if (vertex_.empty()) { - glDisableClientState(GL_VERTEX_ARRAY); + gl::DisableClientState(gl::VERTEX_ARRAY); CV_CheckGlError(); } -#endif -} - -//////////////////////////////////////////////////////////////////////// -// GlFont - -cv::GlFont::GlFont(const string& _family, int _height, Weight _weight, Style _style) - : family_(_family), height_(_height), weight_(_weight), style_(_style), base_(0) -{ -#ifndef HAVE_OPENGL - throw_nogl; -#else - base_ = glGenLists(256); - CV_CheckGlError(); - - glFuncTab()->generateBitmapFont(family_, height_, weight_, (style_ & STYLE_ITALIC) != 0, (style_ & STYLE_UNDERLINE) != 0, 0, 256, base_); -#endif -} - -void cv::GlFont::draw(const char* str, size_t len) const -{ -#ifndef HAVE_OPENGL - (void)str; - (void)len; - throw_nogl; -#else - if (base_ && len > 0) + else { - glPushAttrib(GL_LIST_BIT); - glListBase(base_); + gl::EnableClientState(gl::VERTEX_ARRAY); + CV_CheckGlError(); - glCallLists(static_cast(len), GL_UNSIGNED_BYTE, str); - - glPopAttrib(); + vertex_.bind(GlBuffer::ARRAY_BUFFER); + gl::VertexPointer(vertex_.channels(), gl_types[vertex_.depth()], 0, 0); CV_CheckGlError(); } -#endif -} -namespace -{ - class FontCompare : public unary_function, bool> - { - public: - inline FontCompare(const string& family, int height, GlFont::Weight weight, GlFont::Style style) - : family_(family), height_(height), weight_(weight), style_(style) - { - } - - bool operator ()(const cv::Ptr& font) - { - return font->family() == family_ && font->height() == height_ && font->weight() == weight_ && font->style() == style_; - } - - private: - string family_; - int height_; - GlFont::Weight weight_; - GlFont::Style style_; - }; -} - -Ptr cv::GlFont::get(const std::string& family, int height, Weight weight, Style style) -{ -#ifndef HAVE_OPENGL - (void)family; - (void)height; - (void)weight; - (void)style; - throw_nogl; - return Ptr(); -#else - static vector< Ptr > fonts; - fonts.reserve(10); - - vector< Ptr >::iterator fontIt = find_if(fonts.begin(), fonts.end(), FontCompare(family, height, weight, style)); - - if (fontIt == fonts.end()) - { - fonts.push_back(new GlFont(family, height, weight, style)); - - fontIt = fonts.end() - 1; - } - - return *fontIt; + GlBuffer::unbind(GlBuffer::ARRAY_BUFFER); #endif } //////////////////////////////////////////////////////////////////////// // Rendering -void cv::render(const GlTexture& tex, Rect_ wndRect, Rect_ texRect) +void cv::render(const GlTexture2D& tex, Rect_ wndRect, Rect_ texRect) { #ifndef HAVE_OPENGL - (void)tex; - (void)wndRect; - (void)texRect; - throw_nogl; + (void) tex; + (void) wndRect; + (void) texRect; + throw_nogl(); #else if (!tex.empty()) { - tex.bind(); - - glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE); - - glBegin(GL_QUADS); - glTexCoord2d(texRect.x, texRect.y); - glVertex2d(wndRect.x, wndRect.y); - - glTexCoord2d(texRect.x, texRect.y + texRect.height); - glVertex2d(wndRect.x, (wndRect.y + wndRect.height)); - - glTexCoord2d(texRect.x + texRect.width, texRect.y + texRect.height); - glVertex2d(wndRect.x + wndRect.width, (wndRect.y + wndRect.height)); - - glTexCoord2d(texRect.x + texRect.width, texRect.y); - glVertex2d(wndRect.x + wndRect.width, wndRect.y); - glEnd(); - + gl::MatrixMode(gl::PROJECTION); + gl::LoadIdentity(); + gl::Ortho(0.0, 1.0, 1.0, 0.0, -1.0, 1.0); CV_CheckGlError(); - tex.unbind(); + gl::MatrixMode(gl::MODELVIEW); + gl::LoadIdentity(); + CV_CheckGlError(); + + gl::Disable(gl::LIGHTING); + CV_CheckGlError(); + + tex.bind(); + + gl::Enable(gl::TEXTURE_2D); + CV_CheckGlError(); + + gl::TexEnvi(gl::TEXTURE_ENV, gl::TEXTURE_ENV_MODE, gl::REPLACE); + CV_CheckGlError(); + + gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::LINEAR); + CV_CheckGlError(); + + const float vertex[] = + { + wndRect.x, wndRect.y, 0.0f, + wndRect.x, (wndRect.y + wndRect.height), 0.0f, + wndRect.x + wndRect.width, (wndRect.y + wndRect.height), 0.0f, + wndRect.x + wndRect.width, wndRect.y, 0.0f + }; + const float texCoords[] = + { + texRect.x, texRect.y, + texRect.x, texRect.y + texRect.height, + texRect.x + texRect.width, texRect.y + texRect.height, + texRect.x + texRect.width, texRect.y + }; + + GlBuffer::unbind(GlBuffer::ARRAY_BUFFER); + + gl::EnableClientState(gl::TEXTURE_COORD_ARRAY); + CV_CheckGlError(); + + gl::TexCoordPointer(2, gl::FLOAT, 0, texCoords); + CV_CheckGlError(); + + gl::DisableClientState(gl::NORMAL_ARRAY); + gl::DisableClientState(gl::COLOR_ARRAY); + CV_CheckGlError(); + + gl::EnableClientState(gl::VERTEX_ARRAY); + CV_CheckGlError(); + + gl::VertexPointer(3, gl::FLOAT, 0, vertex); + CV_CheckGlError(); + + gl::DrawArrays(cv::RenderMode::QUADS, 0, 4); + CV_CheckGlError(); } #endif } @@ -1376,222 +1476,90 @@ void cv::render(const GlTexture& tex, Rect_ wndRect, Rect_ texRe void cv::render(const GlArrays& arr, int mode, Scalar color) { #ifndef HAVE_OPENGL - (void)arr; - (void)mode; - (void)color; - throw_nogl; + (void) arr; + (void) mode; + (void) color; + throw_nogl(); #else - glColor3d(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0); - - arr.bind(); - - glDrawArrays(mode, 0, arr.size().area()); - - arr.unbind(); -#endif -} - -void cv::render(const string& str, const Ptr& font, Scalar color, Point2d pos) -{ -#ifndef HAVE_OPENGL - (void)str; - (void)font; - (void)color; - (void)pos; - throw_nogl; -#else - glPushAttrib(GL_DEPTH_BUFFER_BIT); - - GLint viewport[4]; - glGetIntegerv(GL_VIEWPORT, viewport); - - glDisable(GL_DEPTH_TEST); - - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); - - glColor3d(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0); - - glRasterPos2d(2.0 * (viewport[0] + pos.x) / viewport[2] - 1.0, 1.0 - 2.0 * (viewport[1] + pos.y + font->height()) / viewport[3]); - - font->draw(str.c_str(), str.length()); - - glPopAttrib(); -#endif -} - -//////////////////////////////////////////////////////////////////////// -// GlCamera - -cv::GlCamera::GlCamera() : - eye_(0.0, 0.0, -5.0), center_(0.0, 0.0, 0.0), up_(0.0, 1.0, 0.0), - pos_(0.0, 0.0, -5.0), yaw_(0.0), pitch_(0.0), roll_(0.0), - useLookAtParams_(false), - - scale_(1.0, 1.0, 1.0), - - projectionMatrix_(), - fov_(45.0), aspect_(0.0), - left_(0.0), right_(1.0), bottom_(1.0), top_(0.0), - zNear_(-1.0), zFar_(1.0), - perspectiveProjection_(false) -{ -} - -void cv::GlCamera::lookAt(Point3d eye, Point3d center, Point3d up) -{ - eye_ = eye; - center_ = center; - up_ = up; - useLookAtParams_ = true; -} - -void cv::GlCamera::setCameraPos(Point3d pos, double yaw, double pitch, double roll) -{ - pos_ = pos; - yaw_ = yaw; - pitch_ = pitch; - roll_ = roll; - useLookAtParams_ = false; -} - -void cv::GlCamera::setScale(Point3d scale) -{ - scale_ = scale; -} - -void cv::GlCamera::setProjectionMatrix(const Mat& projectionMatrix, bool transpose) -{ - CV_Assert(projectionMatrix.type() == CV_32F || projectionMatrix.type() == CV_64F); - CV_Assert(projectionMatrix.cols == 4 && projectionMatrix.rows == 4); - - projectionMatrix_ = transpose ? projectionMatrix.t() : projectionMatrix; -} - -void cv::GlCamera::setPerspectiveProjection(double fov, double aspect, double zNear, double zFar) -{ - fov_ = fov; - aspect_ = aspect; - zNear_ = zNear; - zFar_ = zFar; - - projectionMatrix_.release(); - perspectiveProjection_ = true; -} - -void cv::GlCamera::setOrthoProjection(double left, double right, double bottom, double top, double zNear, double zFar) -{ - left_ = left; - right_ = right; - bottom_ = bottom; - top_ = top; - zNear_ = zNear; - zFar_ = zFar; - - projectionMatrix_.release(); - perspectiveProjection_ = false; -} - -void cv::GlCamera::setupProjectionMatrix() const -{ -#ifndef HAVE_OPENGL - throw_nogl; -#else - glMatrixMode(GL_PROJECTION); - glLoadIdentity(); - - if (projectionMatrix_.empty()) + if (!arr.empty()) { - if (perspectiveProjection_) - gluPerspective(fov_, aspect_, zNear_, zFar_); - else - glOrtho(left_, right_, bottom_, top_, zNear_, zFar_); + gl::Color3d(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0); + + arr.bind(); + + gl::DrawArrays(mode, 0, arr.size()); } - else - { - if (projectionMatrix_.type() == CV_32F) - glLoadMatrixf(projectionMatrix_.ptr()); - else - glLoadMatrixd(projectionMatrix_.ptr()); - } - - CV_CheckGlError(); #endif } -void cv::GlCamera::setupModelViewMatrix() const +void cv::render(const GlArrays& arr, InputArray indices, int mode, Scalar color) { #ifndef HAVE_OPENGL - throw_nogl; + (void) arr; + (void) indices; + (void) mode; + (void) color; + throw_nogl(); #else - glMatrixMode(GL_MODELVIEW); - glLoadIdentity(); - - if (useLookAtParams_) - gluLookAt(eye_.x, eye_.y, eye_.z, center_.x, center_.y, center_.z, up_.x, up_.y, up_.z); - else + if (!arr.empty() && !indices.empty()) { - glRotated(-yaw_, 0.0, 1.0, 0.0); - glRotated(-pitch_, 1.0, 0.0, 0.0); - glRotated(-roll_, 0.0, 0.0, 1.0); - glTranslated(-pos_.x, -pos_.y, -pos_.z); - } + gl::Color3d(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0); - glScaled(scale_.x, scale_.y, scale_.z); + arr.bind(); - CV_CheckGlError(); -#endif -} + const int kind = indices.kind(); -//////////////////////////////////////////////////////////////////////// -// Error handling - -bool icvCheckGlError(const char* file, const int line, const char* func) -{ -#ifndef HAVE_OPENGL - (void)file; - (void)line; - (void)func; - return true; -#else - GLenum err = glGetError(); - - if (err != GL_NO_ERROR) - { - const char* msg; - - switch (err) + switch (kind) { - case GL_INVALID_ENUM: - msg = "An unacceptable value is specified for an enumerated argument"; - break; - case GL_INVALID_VALUE: - msg = "A numeric argument is out of range"; - break; - case GL_INVALID_OPERATION: - msg = "The specified operation is not allowed in the current state"; - break; - case GL_STACK_OVERFLOW: - msg = "This command would cause a stack overflow"; - break; - case GL_STACK_UNDERFLOW: - msg = "This command would cause a stack underflow"; - break; - case GL_OUT_OF_MEMORY: - msg = "There is not enough memory left to execute the command"; - break; + case _InputArray::OPENGL_BUFFER : + { + GlBuffer buf = indices.getGlBuffer(); + + const int depth = buf.depth(); + + CV_Assert( buf.channels() == 1 ); + CV_Assert( depth <= CV_32S ); + + GLenum type; + if (depth < CV_16U) + type = gl::UNSIGNED_BYTE; + else if (depth < CV_32S) + type = gl::UNSIGNED_SHORT; + else + type = gl::UNSIGNED_INT; + + buf.bind(GlBuffer::ELEMENT_ARRAY_BUFFER); + + gl::DrawElements(mode, buf.size().area(), type, 0); + + GlBuffer::unbind(GlBuffer::ELEMENT_ARRAY_BUFFER); + + break; + } + default: - msg = "Unknown error"; - }; + { + Mat mat = indices.getMat(); - cvError(CV_OpenGlApiCallError, func, msg, file, line); + const int depth = mat.depth(); - return false; + CV_Assert( mat.channels() == 1 ); + CV_Assert( depth <= CV_32S ); + CV_Assert( mat.isContinuous() ); + + GLenum type; + if (depth < CV_16U) + type = gl::UNSIGNED_BYTE; + else if (depth < CV_32S) + type = gl::UNSIGNED_SHORT; + else + type = gl::UNSIGNED_INT; + + GlBuffer::unbind(GlBuffer::ELEMENT_ARRAY_BUFFER); + + gl::DrawElements(mode, mat.size().area(), type, mat.data); + } + } } - - return true; #endif } diff --git a/modules/gpu/test/test_opengl.cpp b/modules/gpu/test/test_opengl.cpp new file mode 100644 index 0000000000..bbb10e1e32 --- /dev/null +++ b/modules/gpu/test/test_opengl.cpp @@ -0,0 +1,625 @@ +/*M/////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// Intel License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2000, Intel Corporation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of Intel Corporation may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +//M*/ + +#include "test_precomp.hpp" + +#if defined(HAVE_CUDA) && defined(HAVE_OPENGL) + +///////////////////////////////////////////// +// GlBuffer + +PARAM_TEST_CASE(GlBuffer, cv::Size, MatType) +{ + cv::Size size; + int type; + + virtual void SetUp() + { + size = GET_PARAM(0); + type = GET_PARAM(1); + } +}; + +TEST_P(GlBuffer, Constructor1) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::GlBuffer buf(size.height, size.width, type); + + EXPECT_EQ(size.height, buf.rows()); + EXPECT_EQ(size.width, buf.cols()); + EXPECT_EQ(type, buf.type()); + + buf.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlBuffer, Constructor2) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::GlBuffer buf(size, type); + + EXPECT_EQ(size.height, buf.rows()); + EXPECT_EQ(size.width, buf.cols()); + EXPECT_EQ(type, buf.type()); + + buf.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlBuffer, ConstructorFromMat) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type); + + cv::GlBuffer buf(gold); + + cv::Mat bufData; + buf.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 0); + + buf.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlBuffer, ConstructorFromGpuMat) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type); + cv::gpu::GpuMat d_gold(gold); + + cv::GlBuffer buf(d_gold); + + cv::Mat bufData; + buf.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 0); + + buf.release(); + d_gold.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlBuffer, ConstructorFromGlBuffer) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::GlBuffer buf_gold(size, type); + cv::GlBuffer buf(buf_gold); + + EXPECT_EQ(buf_gold.bufId(), buf.bufId()); + EXPECT_EQ(buf_gold.rows(), buf.rows()); + EXPECT_EQ(buf_gold.cols(), buf.cols()); + EXPECT_EQ(buf_gold.type(), buf.type()); + + buf.release(); + buf_gold.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlBuffer, ConstructorFromGlTexture2D) +{ + const int depth = CV_MAT_DEPTH(type); + const int cn = CV_MAT_CN(type); + + if (depth != CV_32F || cn == 2) + return; + + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type, 0, 1.0); + cv::GlTexture2D tex_gold(gold); + + cv::GlBuffer buf(tex_gold); + + cv::Mat bufData; + buf.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 1e-2); + + buf.release(); + tex_gold.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlBuffer, Create) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::GlBuffer buf; + buf.create(size.height, size.width, type); + + EXPECT_EQ(size.height, buf.rows()); + EXPECT_EQ(size.width, buf.cols()); + EXPECT_EQ(type, buf.type()); + + buf.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlBuffer, CopyFromMat) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type); + + cv::GlBuffer buf; + buf.copyFrom(gold); + + cv::Mat bufData; + buf.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 0); + + buf.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlBuffer, CopyFromGpuMat) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type); + cv::gpu::GpuMat d_gold(gold); + + cv::GlBuffer buf; + buf.copyFrom(d_gold); + + cv::Mat bufData; + buf.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 0); + + buf.release(); + d_gold.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlBuffer, CopyFromGlBuffer) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type); + cv::GlBuffer buf_gold(gold); + + cv::GlBuffer buf; + buf.copyFrom(buf_gold); + + EXPECT_NE(buf_gold.bufId(), buf.bufId()); + + cv::Mat bufData; + buf.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 0); + + buf.release(); + buf_gold.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlBuffer, CopyFromGlTexture2D) +{ + const int depth = CV_MAT_DEPTH(type); + const int cn = CV_MAT_CN(type); + + if (depth != CV_32F || cn == 2) + return; + + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type, 0, 1.0); + cv::GlTexture2D tex_gold(gold); + + cv::GlBuffer buf; + buf.copyFrom(tex_gold); + + cv::Mat bufData; + buf.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 1e-2); + + buf.release(); + tex_gold.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlBuffer, CopyToGpuMat) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type); + + cv::GlBuffer buf(gold); + cv::gpu::GpuMat dst; + buf.copyTo(dst); + + EXPECT_MAT_NEAR(gold, dst, 0); + + dst.release(); + buf.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlBuffer, CopyToGlBuffer) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type); + cv::GlBuffer buf(gold); + + cv::GlBuffer dst; + buf.copyTo(dst); + + EXPECT_NE(buf.bufId(), dst.bufId()); + + cv::Mat bufData; + dst.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 0); + + dst.release(); + buf.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlBuffer, CopyToGlTexture2D) +{ + const int depth = CV_MAT_DEPTH(type); + const int cn = CV_MAT_CN(type); + + if (depth != CV_32F || cn == 2) + return; + + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type, 0, 1.0); + cv::GlBuffer buf(gold); + + cv::GlTexture2D tex; + buf.copyTo(tex); + + cv::Mat texData; + tex.copyTo(texData); + + EXPECT_MAT_NEAR(gold, texData, 1e-2); + + tex.release(); + buf.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlBuffer, Clone) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type); + cv::GlBuffer buf(gold); + + cv::GlBuffer dst = buf.clone(); + + EXPECT_NE(buf.bufId(), dst.bufId()); + + cv::Mat bufData; + dst.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 0); + + dst.release(); + buf.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlBuffer, MapHost) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type); + cv::GlBuffer buf(gold); + + cv::Mat dst = buf.mapHost(); + + EXPECT_MAT_NEAR(gold, dst, 0); + + buf.unmapHost(); + + buf.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlBuffer, MapDevice) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type); + cv::GlBuffer buf(gold); + + cv::gpu::GpuMat dst = buf.mapDevice(); + + EXPECT_MAT_NEAR(gold, dst, 0); + + buf.unmapDevice(); + + buf.release(); + cv::destroyAllWindows(); +} + +INSTANTIATE_TEST_CASE_P(OpenGL, GlBuffer, testing::Combine(DIFFERENT_SIZES, ALL_TYPES)); + +///////////////////////////////////////////// +// GlTexture2D + +PARAM_TEST_CASE(GlTexture2D, cv::Size, MatType) +{ + cv::Size size; + int type; + int depth; + int cn; + cv::GlTexture2D::Format format; + + virtual void SetUp() + { + size = GET_PARAM(0); + type = GET_PARAM(1); + + depth = CV_MAT_DEPTH(type); + cn = CV_MAT_CN(type); + format = cn == 1 ? cv::GlTexture2D::DEPTH_COMPONENT : cn == 3 ? cv::GlTexture2D::RGB : cn == 4 ? cv::GlTexture2D::RGBA : cv::GlTexture2D::NONE; + } +}; + +TEST_P(GlTexture2D, Constructor1) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::GlTexture2D tex(size.height, size.width, format); + + EXPECT_EQ(size.height, tex.rows()); + EXPECT_EQ(size.width, tex.cols()); + EXPECT_EQ(format, tex.format()); + + tex.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlTexture2D, Constructor2) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::GlTexture2D tex(size, format); + + EXPECT_EQ(size.height, tex.rows()); + EXPECT_EQ(size.width, tex.cols()); + EXPECT_EQ(format, tex.format()); + + tex.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlTexture2D, ConstructorFromMat) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + + cv::GlTexture2D tex(gold); + + cv::Mat texData; + tex.copyTo(texData, depth); + + EXPECT_MAT_NEAR(gold, texData, 1e-2); + + tex.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlTexture2D, ConstructorFromGpuMat) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + cv::gpu::GpuMat d_gold(gold); + + cv::GlTexture2D tex(d_gold); + + cv::Mat texData; + tex.copyTo(texData, depth); + + EXPECT_MAT_NEAR(gold, texData, 1e-2); + + tex.release(); + d_gold.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlTexture2D, ConstructorFromGlBuffer) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + cv::GlBuffer buf_gold(gold); + + cv::GlTexture2D tex(buf_gold); + + cv::Mat texData; + tex.copyTo(texData, depth); + + EXPECT_MAT_NEAR(gold, texData, 1e-2); + + tex.release(); + buf_gold.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlTexture2D, ConstructorFromGlTexture2D) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::GlTexture2D tex_gold(size, format); + cv::GlTexture2D tex(tex_gold); + + EXPECT_EQ(tex_gold.texId(), tex.texId()); + EXPECT_EQ(tex_gold.rows(), tex.rows()); + EXPECT_EQ(tex_gold.cols(), tex.cols()); + EXPECT_EQ(tex_gold.format(), tex.format()); + + tex.release(); + tex_gold.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlTexture2D, Create) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::GlTexture2D tex; + tex.create(size.height, size.width, format); + + EXPECT_EQ(size.height, tex.rows()); + EXPECT_EQ(size.width, tex.cols()); + EXPECT_EQ(format, tex.format()); + + tex.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlTexture2D, CopyFromMat) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + + cv::GlTexture2D tex; + tex.copyFrom(gold); + + cv::Mat texData; + tex.copyTo(texData, depth); + + EXPECT_MAT_NEAR(gold, texData, 1e-2); + + tex.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlTexture2D, CopyFromGpuMat) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + cv::gpu::GpuMat d_gold(gold); + + cv::GlTexture2D tex; + tex.copyFrom(d_gold); + + cv::Mat texData; + tex.copyTo(texData, depth); + + EXPECT_MAT_NEAR(gold, texData, 1e-2); + + tex.release(); + d_gold.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlTexture2D, CopyFromGlBuffer) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + cv::GlBuffer buf_gold(gold); + + cv::GlTexture2D tex; + tex.copyFrom(buf_gold); + + cv::Mat texData; + tex.copyTo(texData, depth); + + EXPECT_MAT_NEAR(gold, texData, 1e-2); + + tex.release(); + buf_gold.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlTexture2D, CopyToGpuMat) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + + cv::GlTexture2D tex(gold); + cv::gpu::GpuMat dst; + tex.copyTo(dst, depth); + + EXPECT_MAT_NEAR(gold, dst, 1e-2); + + dst.release(); + tex.release(); + cv::destroyAllWindows(); +} + +TEST_P(GlTexture2D, CopyToGlBuffer) +{ + cv::namedWindow("test", cv::WINDOW_OPENGL); + + cv::Mat gold = randomMat(size, type, 0, depth == CV_8U ? 255 : 1); + + cv::GlTexture2D tex(gold); + + cv::GlBuffer dst; + tex.copyTo(dst, depth); + + cv::Mat bufData; + dst.copyTo(bufData); + + EXPECT_MAT_NEAR(gold, bufData, 1e-2); + + dst.release(); + tex.release(); + cv::destroyAllWindows(); +} + +INSTANTIATE_TEST_CASE_P(OpenGL, GlTexture2D, testing::Combine(DIFFERENT_SIZES, testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_32FC1, CV_32FC3, CV_32FC4))); + +#endif diff --git a/modules/gpu/test/test_precomp.hpp b/modules/gpu/test/test_precomp.hpp index b75f8edd88..7eb53d5f3d 100644 --- a/modules/gpu/test/test_precomp.hpp +++ b/modules/gpu/test/test_precomp.hpp @@ -69,6 +69,7 @@ #include #include "opencv2/core/core.hpp" + #include "opencv2/core/opengl_interop.hpp" #include "opencv2/highgui/highgui.hpp" #include "opencv2/calib3d/calib3d.hpp" #include "opencv2/imgproc/imgproc.hpp" diff --git a/modules/highgui/include/opencv2/highgui/highgui.hpp b/modules/highgui/include/opencv2/highgui/highgui.hpp index 57aef6314d..43cf13dc13 100644 --- a/modules/highgui/include/opencv2/highgui/highgui.hpp +++ b/modules/highgui/include/opencv2/highgui/highgui.hpp @@ -125,16 +125,13 @@ CV_EXPORTS_W void setTrackbarPos(const string& trackbarname, const string& winna // OpenGL support -typedef void (*OpenGlDrawCallback)(void* userdata); +typedef void (CV_CDECL *OpenGlDrawCallback)(void* userdata); CV_EXPORTS void setOpenGlDrawCallback(const string& winname, OpenGlDrawCallback onOpenGlDraw, void* userdata = 0); CV_EXPORTS void setOpenGlContext(const string& winname); CV_EXPORTS void updateWindow(const string& winname); -CV_EXPORTS void pointCloudShow(const string& winname, const GlCamera& camera, const GlArrays& arr); -CV_EXPORTS void pointCloudShow(const string& winname, const GlCamera& camera, InputArray points, InputArray colors = noArray()); - //Only for Qt CV_EXPORTS CvFont fontQt(const string& nameFont, int pointSize=-1, diff --git a/modules/highgui/src/precomp.hpp b/modules/highgui/src/precomp.hpp index 0cef4e77ae..9572e30100 100644 --- a/modules/highgui/src/precomp.hpp +++ b/modules/highgui/src/precomp.hpp @@ -206,9 +206,6 @@ void cvSetRatioWindow_QT(const char* name,double prop_value); double cvGetOpenGlProp_QT(const char* name); #endif -// OpenGL -typedef void (CV_CDECL *CvOpenGlCleanCallback)(void* userdata); -void icvSetOpenGlCleanCallback(const char* window_name, CvOpenGlCleanCallback callback, void* userdata); /*namespace cv diff --git a/modules/highgui/src/window.cpp b/modules/highgui/src/window.cpp index e6b3b1f7ab..05cb5ef2e4 100644 --- a/modules/highgui/src/window.cpp +++ b/modules/highgui/src/window.cpp @@ -40,6 +40,7 @@ //M*/ #include "precomp.hpp" +#include #include "opencv2/core/opengl_interop.hpp" // in later times, use this file as a dispatcher to implementations like cvcap.cpp @@ -240,94 +241,15 @@ void cv::updateWindow(const string& windowName) #ifdef HAVE_OPENGL namespace { - const int CV_TEXTURE_MAGIC_VAL = 0x00287653; - const int CV_POINT_CLOUD_MAGIC_VAL = 0x00287654; - - struct GlObjBase - { - int flag; - GlObjBase* next; - GlObjBase* prev; - std::string winname; - - virtual ~GlObjBase() {} - }; - - GlObjBase* g_glObjs = 0; - - GlObjBase* findGlObjByName(const std::string& winname) - { - GlObjBase* obj = g_glObjs; - - while(obj && obj->winname != winname) - obj = obj->next; - - return obj; - } - - void addGlObj(GlObjBase* glObj) - { - glObj->next = g_glObjs; - glObj->prev = 0; - if (g_glObjs) - g_glObjs->prev = glObj; - g_glObjs = glObj; - } - - void removeGlObj(GlObjBase* glObj) - { - if (glObj->prev) - glObj->prev->next = glObj->next; - else - g_glObjs = glObj->next; - - if (glObj->next) - glObj->next->prev = glObj->prev; - - delete glObj; - } - - struct GlObjTex : GlObjBase - { - cv::GlTexture tex; - }; + std::map wndTexs; + std::map ownWndTexs; + std::map ownWndBufs; void CV_CDECL glDrawTextureCallback(void* userdata) { - GlObjTex* texObj = static_cast(userdata); + cv::GlTexture2D* texObj = static_cast(userdata); - CV_DbgAssert(texObj->flag == CV_TEXTURE_MAGIC_VAL); - - static cv::GlCamera glCamera; - - glCamera.setupProjectionMatrix(); - - cv::render(texObj->tex); - } - - struct GlObjPointCloud : GlObjBase - { - cv::GlArrays arr; - cv::GlCamera camera; - }; - - void CV_CDECL glDrawPointCloudCallback(void* userdata) - { - GlObjPointCloud* pointCloudObj = static_cast(userdata); - - CV_DbgAssert(pointCloudObj->flag == CV_POINT_CLOUD_MAGIC_VAL); - - pointCloudObj->camera.setupProjectionMatrix(); - pointCloudObj->camera.setupModelViewMatrix(); - - cv::render(pointCloudObj->arr); - } - - void CV_CDECL glCleanCallback(void* userdata) - { - GlObjBase* glObj = static_cast(userdata); - - removeGlObj(glObj); + cv::render(*texObj); } } #endif // HAVE_OPENGL @@ -339,7 +261,8 @@ void cv::imshow( const string& winname, InputArray _img ) CvMat c_img = img; cvShowImage(winname.c_str(), &c_img); #else - double useGl = getWindowProperty(winname, WND_PROP_OPENGL); + const double useGl = getWindowProperty(winname, WND_PROP_OPENGL); + if (useGl <= 0) { Mat img = _img.getMat(); @@ -348,7 +271,7 @@ void cv::imshow( const string& winname, InputArray _img ) } else { - double autoSize = getWindowProperty(winname, WND_PROP_AUTOSIZE); + const double autoSize = getWindowProperty(winname, WND_PROP_AUTOSIZE); if (autoSize > 0) { @@ -358,145 +281,44 @@ void cv::imshow( const string& winname, InputArray _img ) setOpenGlContext(winname); - GlObjBase* glObj = findGlObjByName(winname); - - if (glObj && glObj->flag != CV_TEXTURE_MAGIC_VAL) + if (_img.kind() == _InputArray::OPENGL_TEXTURE2D) { - icvSetOpenGlCleanCallback(winname.c_str(), 0, 0); - glObj = 0; - } + cv::GlTexture2D& tex = wndTexs[winname]; - if (glObj) - { - GlObjTex* texObj = static_cast(glObj); - texObj->tex.copyFrom(_img); + tex = _img.getGlTexture2D(); + + tex.setAutoRelease(false); + + setOpenGlDrawCallback(winname, glDrawTextureCallback, &tex); } else { - GlObjTex* texObj = new GlObjTex; - texObj->tex.copyFrom(_img); + cv::GlTexture2D& tex = ownWndTexs[winname]; - glObj = texObj; - glObj->flag = CV_TEXTURE_MAGIC_VAL; - glObj->winname = winname; + if (_img.kind() == _InputArray::GPU_MAT) + { + cv::GlBuffer& buf = ownWndBufs[winname]; + buf.copyFrom(_img); + buf.setAutoRelease(false); - addGlObj(glObj); + tex.copyFrom(buf); + tex.setAutoRelease(false); + } + else + { + tex.copyFrom(_img); + } - icvSetOpenGlCleanCallback(winname.c_str(), glCleanCallback, glObj); + tex.setAutoRelease(false); + + setOpenGlDrawCallback(winname, glDrawTextureCallback, &tex); } - setOpenGlDrawCallback(winname, glDrawTextureCallback, glObj); - updateWindow(winname); } #endif } -void cv::pointCloudShow(const string& winname, const GlCamera& camera, const GlArrays& arr) -{ -#ifndef HAVE_OPENGL - CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support"); - (void)winname; - (void)camera; - (void)arr; -#else - namedWindow(winname, WINDOW_OPENGL); - - setOpenGlContext(winname); - - GlObjBase* glObj = findGlObjByName(winname); - - if (glObj && glObj->flag != CV_POINT_CLOUD_MAGIC_VAL) - { - icvSetOpenGlCleanCallback(winname.c_str(), 0, 0); - glObj = 0; - } - - if (glObj) - { - GlObjPointCloud* pointCloudObj = static_cast(glObj); - pointCloudObj->arr = arr; - pointCloudObj->camera = camera; - } - else - { - GlObjPointCloud* pointCloudObj = new GlObjPointCloud; - pointCloudObj->arr = arr; - pointCloudObj->camera = camera; - - glObj = pointCloudObj; - glObj->flag = CV_POINT_CLOUD_MAGIC_VAL; - glObj->winname = winname; - - addGlObj(glObj); - - icvSetOpenGlCleanCallback(winname.c_str(), glCleanCallback, glObj); - } - - setOpenGlDrawCallback(winname, glDrawPointCloudCallback, glObj); - - updateWindow(winname); -#endif -} - -void cv::pointCloudShow(const std::string& winname, const cv::GlCamera& camera, InputArray points, InputArray colors) -{ -#ifndef HAVE_OPENGL - (void)winname; - (void)camera; - (void)points; - (void)colors; - CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support"); -#else - namedWindow(winname, WINDOW_OPENGL); - - setOpenGlContext(winname); - - GlObjBase* glObj = findGlObjByName(winname); - - if (glObj && glObj->flag != CV_POINT_CLOUD_MAGIC_VAL) - { - icvSetOpenGlCleanCallback(winname.c_str(), 0, 0); - glObj = 0; - } - - if (glObj) - { - GlObjPointCloud* pointCloudObj = static_cast(glObj); - - pointCloudObj->arr.setVertexArray(points); - if (colors.empty()) - pointCloudObj->arr.resetColorArray(); - else - pointCloudObj->arr.setColorArray(colors); - - pointCloudObj->camera = camera; - } - else - { - GlObjPointCloud* pointCloudObj = new GlObjPointCloud; - - pointCloudObj->arr.setVertexArray(points); - if (!colors.empty()) - pointCloudObj->arr.setColorArray(colors); - - pointCloudObj->camera = camera; - - glObj = pointCloudObj; - glObj->flag = CV_POINT_CLOUD_MAGIC_VAL; - glObj->winname = winname; - - addGlObj(glObj); - - icvSetOpenGlCleanCallback(winname.c_str(), glCleanCallback, glObj); - } - - setOpenGlDrawCallback(winname, glDrawPointCloudCallback, glObj); - - updateWindow(winname); -#endif -} - // Without OpenGL #ifndef HAVE_OPENGL @@ -516,11 +338,6 @@ CV_IMPL void cvUpdateWindow(const char*) CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support"); } -void icvSetOpenGlCleanCallback(const char*, CvOpenGlCleanCallback, void*) -{ - CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support"); -} - #endif // !HAVE_OPENGL #if defined (HAVE_QT) diff --git a/modules/highgui/src/window_QT.cpp b/modules/highgui/src/window_QT.cpp index d617e71f9f..2514c2b0ce 100644 --- a/modules/highgui/src/window_QT.cpp +++ b/modules/highgui/src/window_QT.cpp @@ -685,20 +685,6 @@ CV_IMPL void cvSetOpenGlDrawCallback(const char* window_name, CvOpenGlDrawCallba } -void icvSetOpenGlCleanCallback(const char* window_name, CvOpenGlCleanCallback callback, void* userdata) -{ - if (!guiMainThread) - CV_Error( CV_StsNullPtr, "NULL guiReceiver (please create a window)" ); - - QMetaObject::invokeMethod(guiMainThread, - "setOpenGlCleanCallback", - Qt::AutoConnection, - Q_ARG(QString, QString(window_name)), - Q_ARG(void*, (void*)callback), - Q_ARG(void*, userdata)); -} - - CV_IMPL void cvSetOpenGlContext(const char* window_name) { if (!guiMainThread) @@ -1175,14 +1161,6 @@ void GuiReceiver::setOpenGlDrawCallback(QString name, void* callback, void* user w->setOpenGlDrawCallback((CvOpenGlDrawCallback) callback, userdata); } -void GuiReceiver::setOpenGlCleanCallback(QString name, void* callback, void* userdata) -{ - QPointer w = icvFindWindowByName(name); - - if (w) - w->setOpenGlCleanCallback((CvOpenGlCleanCallback) callback, userdata); -} - void GuiReceiver::setOpenGlContext(QString name) { QPointer w = icvFindWindowByName(name); @@ -1828,12 +1806,6 @@ void CvWindow::setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void* userda } -void CvWindow::setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata) -{ - myView->setOpenGlCleanCallback(callback, userdata); -} - - void CvWindow::makeCurrentOpenGlContext() { myView->makeCurrentOpenGlContext(); @@ -2420,12 +2392,6 @@ void DefaultViewPort::setOpenGlDrawCallback(CvOpenGlDrawCallback /*callback*/, v } -void DefaultViewPort::setOpenGlCleanCallback(CvOpenGlCleanCallback /*callback*/, void* /*userdata*/) -{ - CV_Error(CV_OpenGlNotSupported, "Window doesn't support OpenGL"); -} - - void DefaultViewPort::makeCurrentOpenGlContext() { CV_Error(CV_OpenGlNotSupported, "Window doesn't support OpenGL"); @@ -3074,19 +3040,10 @@ OpenGlViewPort::OpenGlViewPort(QWidget* _parent) : QGLWidget(_parent), size(-1, glDrawCallback = 0; glDrawData = 0; - - glCleanCallback = 0; - glCleanData = 0; - - glFuncTab = 0; } OpenGlViewPort::~OpenGlViewPort() { - if (glFuncTab) - delete glFuncTab; - - setOpenGlCleanCallback(0, 0); } QWidget* OpenGlViewPort::getWidget() @@ -3131,21 +3088,9 @@ void OpenGlViewPort::setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void* glDrawData = userdata; } -void OpenGlViewPort::setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata) -{ - makeCurrentOpenGlContext(); - - if (glCleanCallback) - glCleanCallback(glCleanData); - - glCleanCallback = callback; - glCleanData = userdata; -} - void OpenGlViewPort::makeCurrentOpenGlContext() { makeCurrent(); - icvSetOpenGlFuncTab(glFuncTab); } void OpenGlViewPort::updateGl() @@ -3153,255 +3098,9 @@ void OpenGlViewPort::updateGl() QGLWidget::updateGL(); } -#ifndef APIENTRY - #define APIENTRY -#endif - -#ifndef APIENTRYP - #define APIENTRYP APIENTRY * -#endif - -#ifndef GL_VERSION_1_5 - /* GL types for handling large vertex buffer objects */ - typedef ptrdiff_t GLintptr; - typedef ptrdiff_t GLsizeiptr; -#endif - -typedef void (APIENTRYP PFNGLGENBUFFERSPROC ) (GLsizei n, GLuint *buffers); -typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers); - -typedef void (APIENTRYP PFNGLBUFFERDATAPROC ) (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage); -typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); - -typedef void (APIENTRYP PFNGLBINDBUFFERPROC ) (GLenum target, GLuint buffer); - -typedef GLvoid* (APIENTRYP PFNGLMAPBUFFERPROC) (GLenum target, GLenum access); -typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC) (GLenum target); - -class GlFuncTab_QT : public CvOpenGlFuncTab -{ -public: -#ifdef Q_WS_WIN - GlFuncTab_QT(HDC hDC); -#else - GlFuncTab_QT(); -#endif - - void genBuffers(int n, unsigned int* buffers) const; - void deleteBuffers(int n, const unsigned int* buffers) const; - - void bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const; - void bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const; - - void bindBuffer(unsigned int target, unsigned int buffer) const; - - void* mapBuffer(unsigned int target, unsigned int access) const; - void unmapBuffer(unsigned int target) const; - - void generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool underline, int start, int count, int base) const; - - bool isGlContextInitialized() const; - - PFNGLGENBUFFERSPROC glGenBuffersExt; - PFNGLDELETEBUFFERSPROC glDeleteBuffersExt; - - PFNGLBUFFERDATAPROC glBufferDataExt; - PFNGLBUFFERSUBDATAPROC glBufferSubDataExt; - - PFNGLBINDBUFFERPROC glBindBufferExt; - - PFNGLMAPBUFFERPROC glMapBufferExt; - PFNGLUNMAPBUFFERPROC glUnmapBufferExt; - - bool initialized; - -#ifdef Q_WS_WIN - HDC hDC; -#endif -}; - -#ifdef Q_WS_WIN - GlFuncTab_QT::GlFuncTab_QT(HDC hDC_) : hDC(hDC_) -#else - GlFuncTab_QT::GlFuncTab_QT() -#endif -{ - glGenBuffersExt = 0; - glDeleteBuffersExt = 0; - - glBufferDataExt = 0; - glBufferSubDataExt = 0; - - glBindBufferExt = 0; - - glMapBufferExt = 0; - glUnmapBufferExt = 0; - - initialized = false; -} - -void GlFuncTab_QT::genBuffers(int n, unsigned int* buffers) const -{ - CV_FUNCNAME( "GlFuncTab_QT::genBuffers" ); - - __BEGIN__; - - if (!glGenBuffersExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glGenBuffersExt(n, buffers); - CV_CheckGlError(); - - __END__; -} - -void GlFuncTab_QT::deleteBuffers(int n, const unsigned int* buffers) const -{ - CV_FUNCNAME( "GlFuncTab_QT::deleteBuffers" ); - - __BEGIN__; - - if (!glDeleteBuffersExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glDeleteBuffersExt(n, buffers); - CV_CheckGlError(); - - __END__; -} - -void GlFuncTab_QT::bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const -{ - CV_FUNCNAME( "GlFuncTab_QT::bufferData" ); - - __BEGIN__; - - if (!glBufferDataExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBufferDataExt(target, size, data, usage); - CV_CheckGlError(); - - __END__; -} - -void GlFuncTab_QT::bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const -{ - CV_FUNCNAME( "GlFuncTab_QT::bufferSubData" ); - - __BEGIN__; - - if (!glBufferSubDataExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBufferSubDataExt(target, offset, size, data); - CV_CheckGlError(); - - __END__; -} - -void GlFuncTab_QT::bindBuffer(unsigned int target, unsigned int buffer) const -{ - CV_FUNCNAME( "GlFuncTab_QT::bindBuffer" ); - - __BEGIN__; - - if (!glBindBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBindBufferExt(target, buffer); - CV_CheckGlError(); - - __END__; -} - -void* GlFuncTab_QT::mapBuffer(unsigned int target, unsigned int access) const -{ - CV_FUNCNAME( "GlFuncTab_QT::mapBuffer" ); - - void* res = 0; - - __BEGIN__; - - if (!glMapBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - res = glMapBufferExt(target, access); - CV_CheckGlError(); - - __END__; - - return res; -} - -void GlFuncTab_QT::unmapBuffer(unsigned int target) const -{ - CV_FUNCNAME( "GlFuncTab_QT::unmapBuffer" ); - - __BEGIN__; - - if (!glUnmapBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glUnmapBufferExt(target); - CV_CheckGlError(); - - __END__; -} - -void GlFuncTab_QT::generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool /*underline*/, int start, int count, int base) const -{ -#ifdef Q_WS_WIN - CV_FUNCNAME( "GlFuncTab_QT::generateBitmapFont" ); -#endif - - QFont font(QString(family.c_str()), height, weight, italic); - - __BEGIN__; - -#ifndef Q_WS_WIN - font.setStyleStrategy(QFont::OpenGLCompatible); - if (font.handle()) - glXUseXFont(font.handle(), start, count, base); -#else - SelectObject(hDC, font.handle()); - if (!wglUseFontBitmaps(hDC, start, count, base)) - CV_ERROR(CV_OpenGlApiCallError, "Can't create font"); -#endif - - __END__; -} - -bool GlFuncTab_QT::isGlContextInitialized() const -{ - return initialized; -} - void OpenGlViewPort::initializeGL() { glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); - -#ifdef Q_WS_WIN - std::auto_ptr qglFuncTab(new GlFuncTab_QT(getDC())); -#else - std::auto_ptr qglFuncTab(new GlFuncTab_QT); -#endif - - // Load extensions - - qglFuncTab->glGenBuffersExt = (PFNGLGENBUFFERSPROC)context()->getProcAddress("glGenBuffers"); - qglFuncTab->glDeleteBuffersExt = (PFNGLDELETEBUFFERSPROC)context()->getProcAddress("glDeleteBuffers"); - qglFuncTab->glBufferDataExt = (PFNGLBUFFERDATAPROC)context()->getProcAddress("glBufferData"); - qglFuncTab->glBufferSubDataExt = (PFNGLBUFFERSUBDATAPROC)context()->getProcAddress("glBufferSubData"); - qglFuncTab->glBindBufferExt = (PFNGLBINDBUFFERPROC)context()->getProcAddress("glBindBuffer"); - qglFuncTab->glMapBufferExt = (PFNGLMAPBUFFERPROC)context()->getProcAddress("glMapBuffer"); - qglFuncTab->glUnmapBufferExt = (PFNGLUNMAPBUFFERPROC)context()->getProcAddress("glUnmapBuffer"); - - qglFuncTab->initialized = true; - - glFuncTab = qglFuncTab.release(); - - icvSetOpenGlFuncTab(glFuncTab); } void OpenGlViewPort::resizeGL(int w, int h) @@ -3411,14 +3110,10 @@ void OpenGlViewPort::resizeGL(int w, int h) void OpenGlViewPort::paintGL() { - icvSetOpenGlFuncTab(glFuncTab); - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); if (glDrawCallback) glDrawCallback(glDrawData); - - CV_CheckGlError(); } void OpenGlViewPort::mousePressEvent(QMouseEvent* evnt) diff --git a/modules/highgui/src/window_QT.h b/modules/highgui/src/window_QT.h index 64faee0f41..1b07442dc9 100644 --- a/modules/highgui/src/window_QT.h +++ b/modules/highgui/src/window_QT.h @@ -141,7 +141,6 @@ public slots: void enablePropertiesButtonEachWindow(); void setOpenGlDrawCallback(QString name, void* callback, void* userdata); - void setOpenGlCleanCallback(QString name, void* callback, void* userdata); void setOpenGlContext(QString name); void updateWindow(QString name); double isOpenGl(QString name); @@ -312,7 +311,6 @@ public: static void addSlider2(CvWindow* w, QString name, int* value, int count, CvTrackbarCallback2 on_change CV_DEFAULT(NULL), void* userdata CV_DEFAULT(0)); void setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void* userdata); - void setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata); void makeCurrentOpenGlContext(); void updateGl(); bool isOpenGl(); @@ -397,7 +395,6 @@ public: virtual void startDisplayInfo(QString text, int delayms) = 0; virtual void setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void* userdata) = 0; - virtual void setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata) = 0; virtual void makeCurrentOpenGlContext() = 0; virtual void updateGl() = 0; @@ -429,7 +426,6 @@ public: void startDisplayInfo(QString text, int delayms); void setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void* userdata); - void setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata); void makeCurrentOpenGlContext(); void updateGl(); @@ -456,11 +452,6 @@ private: CvOpenGlDrawCallback glDrawCallback; void* glDrawData; - CvOpenGlCleanCallback glCleanCallback; - void* glCleanData; - - CvOpenGlFuncTab* glFuncTab; - void icvmouseHandler(QMouseEvent* event, type_mouse_event category, int& cv_event, int& flags); void icvmouseProcessing(QPointF pt, int cv_event, int flags); }; @@ -491,7 +482,6 @@ public: void startDisplayInfo(QString text, int delayms); void setOpenGlDrawCallback(CvOpenGlDrawCallback callback, void* userdata); - void setOpenGlCleanCallback(CvOpenGlCleanCallback callback, void* userdata); void makeCurrentOpenGlContext(); void updateGl(); diff --git a/modules/highgui/src/window_gtk.cpp b/modules/highgui/src/window_gtk.cpp index 99b16d93c1..3ee3d0c480 100644 --- a/modules/highgui/src/window_gtk.cpp +++ b/modules/highgui/src/window_gtk.cpp @@ -417,9 +417,6 @@ typedef struct CvWindow CvOpenGlDrawCallback glDrawCallback; void* glDrawData; - - CvOpenGlCleanCallback glCleanCallback; - void* glCleanData; #endif } CvWindow; @@ -692,238 +689,6 @@ double cvGetOpenGlProp_GTK(const char* name) namespace { - class GlFuncTab_GTK : public CvOpenGlFuncTab - { - public: - GlFuncTab_GTK(); - - void genBuffers(int n, unsigned int* buffers) const; - void deleteBuffers(int n, const unsigned int* buffers) const; - - void bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const; - void bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const; - - void bindBuffer(unsigned int target, unsigned int buffer) const; - - void* mapBuffer(unsigned int target, unsigned int access) const; - void unmapBuffer(unsigned int target) const; - - void generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool underline, int start, int count, int base) const; - - bool isGlContextInitialized() const; - - PFNGLGENBUFFERSPROC glGenBuffersExt; - PFNGLDELETEBUFFERSPROC glDeleteBuffersExt; - - PFNGLBUFFERDATAPROC glBufferDataExt; - PFNGLBUFFERSUBDATAPROC glBufferSubDataExt; - - PFNGLBINDBUFFERPROC glBindBufferExt; - - PFNGLMAPBUFFERPROC glMapBufferExt; - PFNGLUNMAPBUFFERPROC glUnmapBufferExt; - - bool initialized; - }; - - GlFuncTab_GTK::GlFuncTab_GTK() - { - glGenBuffersExt = 0; - glDeleteBuffersExt = 0; - - glBufferDataExt = 0; - glBufferSubDataExt = 0; - - glBindBufferExt = 0; - - glMapBufferExt = 0; - glUnmapBufferExt = 0; - - initialized = false; - } - - void GlFuncTab_GTK::genBuffers(int n, unsigned int* buffers) const - { - CV_FUNCNAME( "GlFuncTab_GTK::genBuffers" ); - - __BEGIN__; - - if (!glGenBuffersExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glGenBuffersExt(n, buffers); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_GTK::deleteBuffers(int n, const unsigned int* buffers) const - { - CV_FUNCNAME( "GlFuncTab_GTK::deleteBuffers" ); - - __BEGIN__; - - if (!glDeleteBuffersExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glDeleteBuffersExt(n, buffers); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_GTK::bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const - { - CV_FUNCNAME( "GlFuncTab_GTK::bufferData" ); - - __BEGIN__; - - if (!glBufferDataExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBufferDataExt(target, size, data, usage); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_GTK::bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const - { - CV_FUNCNAME( "GlFuncTab_GTK::bufferSubData" ); - - __BEGIN__; - - if (!glBufferSubDataExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBufferSubDataExt(target, offset, size, data); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_GTK::bindBuffer(unsigned int target, unsigned int buffer) const - { - CV_FUNCNAME( "GlFuncTab_GTK::bindBuffer" ); - - __BEGIN__; - - if (!glBindBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBindBufferExt(target, buffer); - CV_CheckGlError(); - - __END__; - } - - void* GlFuncTab_GTK::mapBuffer(unsigned int target, unsigned int access) const - { - CV_FUNCNAME( "GlFuncTab_GTK::mapBuffer" ); - - void* res = 0; - - __BEGIN__; - - if (!glMapBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - res = glMapBufferExt(target, access); - CV_CheckGlError(); - - __END__; - - return res; - } - - void GlFuncTab_GTK::unmapBuffer(unsigned int target) const - { - CV_FUNCNAME( "GlFuncTab_GTK::unmapBuffer" ); - - __BEGIN__; - - if (!glUnmapBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glUnmapBufferExt(target); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_GTK::generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool /*underline*/, int start, int count, int base) const - { - PangoFontDescription* fontDecr; - PangoFont* pangoFont; - - CV_FUNCNAME( "GlFuncTab_GTK::generateBitmapFont" ); - - __BEGIN__; - - fontDecr = pango_font_description_new(); - - pango_font_description_set_size(fontDecr, height); - - pango_font_description_set_family_static(fontDecr, family.c_str()); - - pango_font_description_set_weight(fontDecr, static_cast(weight)); - - pango_font_description_set_style(fontDecr, italic ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL); - - pangoFont = gdk_gl_font_use_pango_font(fontDecr, start, count, base); - - pango_font_description_free(fontDecr); - - if (!pangoFont) - CV_ERROR(CV_OpenGlApiCallError, "Can't create font"); - - __END__; - } - - bool GlFuncTab_GTK::isGlContextInitialized() const - { - return initialized; - } - - void initGl() - { - static GlFuncTab_GTK glFuncTab; - static bool first = true; - - if (first) - { - // Load extensions - GdkGLProc func; - - func = gdk_gl_get_proc_address("glGenBuffers"); - glFuncTab.glGenBuffersExt = (PFNGLGENBUFFERSPROC)func; - - func = gdk_gl_get_proc_address("glDeleteBuffers"); - glFuncTab.glDeleteBuffersExt = (PFNGLDELETEBUFFERSPROC)func; - - func = gdk_gl_get_proc_address("glBufferData"); - glFuncTab.glBufferDataExt = (PFNGLBUFFERDATAPROC)func; - - func = gdk_gl_get_proc_address("glBufferSubData"); - glFuncTab.glBufferSubDataExt = (PFNGLBUFFERSUBDATAPROC)func; - - func = gdk_gl_get_proc_address("glBindBuffer"); - glFuncTab.glBindBufferExt = (PFNGLBINDBUFFERPROC)func; - - func = gdk_gl_get_proc_address("glMapBuffer"); - glFuncTab.glMapBufferExt = (PFNGLMAPBUFFERPROC)func; - - func = gdk_gl_get_proc_address("glUnmapBuffer"); - glFuncTab.glUnmapBufferExt = (PFNGLUNMAPBUFFERPROC)func; - - glFuncTab.initialized = true; - - icvSetOpenGlFuncTab(&glFuncTab); - - first = false; - } - } - void createGlContext(CvWindow* window) { GdkGLConfig* glconfig; @@ -932,8 +697,6 @@ namespace __BEGIN__; - window->useGl = false; - // Try double-buffered visual glconfig = gdk_gl_config_new_by_mode((GdkGLConfigMode)(GDK_GL_MODE_RGB | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE)); if (!glconfig) @@ -943,24 +706,11 @@ namespace if (!gtk_widget_set_gl_capability(window->widget, glconfig, NULL, TRUE, GDK_GL_RGBA_TYPE)) CV_ERROR( CV_OpenGlApiCallError, "Can't Create A GL Device Context" ); - initGl(); - window->useGl = true; __END__; } - void releaseGlContext(CvWindow* window) - { - //CV_FUNCNAME( "releaseGlContext" ); - - //__BEGIN__; - - window->useGl = false; - - //__END__; - } - void drawGl(CvWindow* window) { CV_FUNCNAME( "drawGl" ); @@ -980,8 +730,6 @@ namespace if (window->glDrawCallback) window->glDrawCallback(window->glDrawData); - CV_CheckGlError(); - if (gdk_gl_drawable_is_double_buffered (gldrawable)) gdk_gl_drawable_swap_buffers(gldrawable); else @@ -1101,9 +849,6 @@ CV_IMPL int cvNamedWindow( const char* name, int flags ) window->glDrawCallback = 0; window->glDrawData = 0; - - window->glCleanCallback = 0; - window->glCleanData = 0; #endif // @@ -1233,40 +978,6 @@ CV_IMPL void cvSetOpenGlDrawCallback(const char* name, CvOpenGlDrawCallback call __END__; } -void icvSetOpenGlCleanCallback(const char* name, CvOpenGlCleanCallback callback, void* userdata) -{ - CvWindow* window; - GdkGLContext* glcontext; - GdkGLDrawable* gldrawable; - - CV_FUNCNAME( "icvSetOpenGlCleanCallback" ); - - __BEGIN__; - - if (!name) - CV_ERROR(CV_StsNullPtr, "NULL name string"); - - window = icvFindWindowByName(name); - if (!window) - EXIT; - - if (!window->useGl) - CV_ERROR( CV_OpenGlNotSupported, "Window doesn't support OpenGL" ); - - glcontext = gtk_widget_get_gl_context(window->widget); - gldrawable = gtk_widget_get_gl_drawable(window->widget); - - gdk_gl_drawable_make_current(gldrawable, glcontext); - - if (window->glCleanCallback) - window->glCleanCallback(window->glCleanData); - - window->glCleanCallback = callback; - window->glCleanData = userdata; - - __END__; -} - #endif // HAVE_OPENGL @@ -1276,25 +987,6 @@ static void icvDeleteWindow( CvWindow* window ) { CvTrackbar* trackbar; -#ifdef HAVE_OPENGL - if (window->useGl) - { - GdkGLContext* glcontext = gtk_widget_get_gl_context(window->widget); - GdkGLDrawable* gldrawable = gtk_widget_get_gl_drawable(window->widget); - - gdk_gl_drawable_make_current(gldrawable, glcontext); - - if (window->glCleanCallback) - { - window->glCleanCallback(window->glCleanData); - window->glCleanCallback = 0; - window->glCleanData = 0; - } - - releaseGlContext(window); - } -#endif - if( window->prev ) window->prev->next = window->next; else diff --git a/modules/highgui/src/window_w32.cpp b/modules/highgui/src/window_w32.cpp index 348420afdb..094819740d 100644 --- a/modules/highgui/src/window_w32.cpp +++ b/modules/highgui/src/window_w32.cpp @@ -192,11 +192,6 @@ typedef struct CvWindow CvOpenGlDrawCallback glDrawCallback; void* glDrawData; - - CvOpenGlCleanCallback glCleanCallback; - void* glCleanData; - - CvOpenGlFuncTab* glFuncTab; #endif } CvWindow; @@ -580,272 +575,8 @@ double cvGetOpenGlProp_W32(const char* name) #ifdef HAVE_OPENGL -#ifndef APIENTRY - #define APIENTRY -#endif - -#ifndef APIENTRYP - #define APIENTRYP APIENTRY * -#endif - -#ifndef GL_VERSION_1_5 - /* GL types for handling large vertex buffer objects */ - typedef ptrdiff_t GLintptr; - typedef ptrdiff_t GLsizeiptr; -#endif - namespace { - typedef void (APIENTRYP PFNGLGENBUFFERSPROC ) (GLsizei n, GLuint *buffers); - typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers); - - typedef void (APIENTRYP PFNGLBUFFERDATAPROC ) (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage); - typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); - - typedef void (APIENTRYP PFNGLBINDBUFFERPROC ) (GLenum target, GLuint buffer); - - typedef GLvoid* (APIENTRYP PFNGLMAPBUFFERPROC) (GLenum target, GLenum access); - typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC) (GLenum target); - - class GlFuncTab_W32 : public CvOpenGlFuncTab - { - public: - GlFuncTab_W32(HDC hDC); - - void genBuffers(int n, unsigned int* buffers) const; - void deleteBuffers(int n, const unsigned int* buffers) const; - - void bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const; - void bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const; - - void bindBuffer(unsigned int target, unsigned int buffer) const; - - void* mapBuffer(unsigned int target, unsigned int access) const; - void unmapBuffer(unsigned int target) const; - - void generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool underline, int start, int count, int base) const; - - bool isGlContextInitialized() const; - - PFNGLGENBUFFERSPROC glGenBuffersExt; - PFNGLDELETEBUFFERSPROC glDeleteBuffersExt; - - PFNGLBUFFERDATAPROC glBufferDataExt; - PFNGLBUFFERSUBDATAPROC glBufferSubDataExt; - - PFNGLBINDBUFFERPROC glBindBufferExt; - - PFNGLMAPBUFFERPROC glMapBufferExt; - PFNGLUNMAPBUFFERPROC glUnmapBufferExt; - - bool initialized; - - HDC hDC; - }; - - GlFuncTab_W32::GlFuncTab_W32(HDC hDC_) - { - glGenBuffersExt = 0; - glDeleteBuffersExt = 0; - - glBufferDataExt = 0; - glBufferSubDataExt = 0; - - glBindBufferExt = 0; - - glMapBufferExt = 0; - glUnmapBufferExt = 0; - - initialized = false; - - hDC = hDC_; - } - - void GlFuncTab_W32::genBuffers(int n, unsigned int* buffers) const - { - CV_FUNCNAME( "GlFuncTab_W32::genBuffers" ); - - __BEGIN__; - - if (!glGenBuffersExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glGenBuffersExt(n, buffers); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_W32::deleteBuffers(int n, const unsigned int* buffers) const - { - CV_FUNCNAME( "GlFuncTab_W32::deleteBuffers" ); - - __BEGIN__; - - if (!glDeleteBuffersExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glDeleteBuffersExt(n, buffers); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_W32::bufferData(unsigned int target, ptrdiff_t size, const void* data, unsigned int usage) const - { - CV_FUNCNAME( "GlFuncTab_W32::bufferData" ); - - __BEGIN__; - - if (!glBufferDataExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBufferDataExt(target, size, data, usage); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_W32::bufferSubData(unsigned int target, ptrdiff_t offset, ptrdiff_t size, const void* data) const - { - CV_FUNCNAME( "GlFuncTab_W32::bufferSubData" ); - - __BEGIN__; - - if (!glBufferSubDataExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBufferSubDataExt(target, offset, size, data); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_W32::bindBuffer(unsigned int target, unsigned int buffer) const - { - CV_FUNCNAME( "GlFuncTab_W32::bindBuffer" ); - - __BEGIN__; - - if (!glBindBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glBindBufferExt(target, buffer); - CV_CheckGlError(); - - __END__; - } - - void* GlFuncTab_W32::mapBuffer(unsigned int target, unsigned int access) const - { - CV_FUNCNAME( "GlFuncTab_W32::mapBuffer" ); - - void* res = 0; - - __BEGIN__; - - if (!glMapBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - res = glMapBufferExt(target, access); - CV_CheckGlError(); - - __END__; - - return res; - } - - void GlFuncTab_W32::unmapBuffer(unsigned int target) const - { - CV_FUNCNAME( "GlFuncTab_W32::unmapBuffer" ); - - __BEGIN__; - - if (!glUnmapBufferExt) - CV_ERROR(CV_OpenGlApiCallError, "Current OpenGL implementation doesn't support required extension"); - - glUnmapBufferExt(target); - CV_CheckGlError(); - - __END__; - } - - void GlFuncTab_W32::generateBitmapFont(const std::string& family, int height, int weight, bool italic, bool underline, int start, int count, int base) const - { - HFONT font; - - CV_FUNCNAME( "GlFuncTab_W32::generateBitmapFont" ); - - __BEGIN__; - - font = CreateFont - ( - -height, // height - 0, // cell width - 0, // Angle of Escapement - 0, // Orientation Angle - weight, // font weight - italic ? TRUE : FALSE, // Italic - underline ? TRUE : FALSE, // Underline - FALSE, // StrikeOut - ANSI_CHARSET, // CharSet - OUT_TT_PRECIS, // OutPrecision - CLIP_DEFAULT_PRECIS, // ClipPrecision - ANTIALIASED_QUALITY, // Quality - FF_DONTCARE | DEFAULT_PITCH, // PitchAndFamily - family.c_str() // FaceName - ); - - SelectObject(hDC, font); - - if (!wglUseFontBitmaps(hDC, start, count, base)) - CV_ERROR(CV_OpenGlApiCallError, "Can't create font"); - - __END__; - } - - bool GlFuncTab_W32::isGlContextInitialized() const - { - return initialized; - } - - void initGl(CvWindow* window) - { - glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); - - std::auto_ptr glFuncTab(new GlFuncTab_W32(window->dc)); - - // Load extensions - PROC func; - - func = wglGetProcAddress("glGenBuffers"); - glFuncTab->glGenBuffersExt = (PFNGLGENBUFFERSPROC)func; - - func = wglGetProcAddress("glDeleteBuffers"); - glFuncTab->glDeleteBuffersExt = (PFNGLDELETEBUFFERSPROC)func; - - func = wglGetProcAddress("glBufferData"); - glFuncTab->glBufferDataExt = (PFNGLBUFFERDATAPROC)func; - - func = wglGetProcAddress("glBufferSubData"); - glFuncTab->glBufferSubDataExt = (PFNGLBUFFERSUBDATAPROC)func; - - func = wglGetProcAddress("glBindBuffer"); - glFuncTab->glBindBufferExt = (PFNGLBINDBUFFERPROC)func; - - func = wglGetProcAddress("glMapBuffer"); - glFuncTab->glMapBufferExt = (PFNGLMAPBUFFERPROC)func; - - func = wglGetProcAddress("glUnmapBuffer"); - glFuncTab->glUnmapBufferExt = (PFNGLUNMAPBUFFERPROC)func; - - glFuncTab->initialized = true; - - window->glFuncTab = glFuncTab.release(); - - icvSetOpenGlFuncTab(window->glFuncTab); - } - void createGlContext(HWND hWnd, HDC& hGLDC, HGLRC& hGLRC, bool& useGl) { CV_FUNCNAME( "createGlContext" ); @@ -907,8 +638,6 @@ namespace __BEGIN__; - delete window->glFuncTab; - if (window->hGLRC) { wglDeleteContext(window->hGLRC); @@ -940,8 +669,6 @@ namespace if (window->glDrawCallback) window->glDrawCallback(window->glDrawData); - CV_CheckGlError(); - if (!SwapBuffers(window->dc)) CV_ERROR( CV_OpenGlApiCallError, "Can't swap OpenGL buffers" ); @@ -1042,7 +769,6 @@ CV_IMPL int cvNamedWindow( const char* name, int flags ) #ifndef HAVE_OPENGL window->dc = CreateCompatibleDC(0); #else - window->glFuncTab = 0; if (!useGl) { window->dc = CreateCompatibleDC(0); @@ -1054,14 +780,10 @@ CV_IMPL int cvNamedWindow( const char* name, int flags ) window->dc = hGLDC; window->hGLRC = hGLRC; window->useGl = true; - initGl(window); } window->glDrawCallback = 0; window->glDrawData = 0; - - window->glCleanCallback = 0; - window->glCleanData = 0; #endif window->last_key = 0; @@ -1112,8 +834,6 @@ CV_IMPL void cvSetOpenGlContext(const char* name) if (!wglMakeCurrent(window->dc, window->hGLRC)) CV_ERROR( CV_OpenGlApiCallError, "Can't Activate The GL Rendering Context" ); - icvSetOpenGlFuncTab(window->glFuncTab); - __END__; } @@ -1161,30 +881,6 @@ CV_IMPL void cvSetOpenGlDrawCallback(const char* name, CvOpenGlDrawCallback call __END__; } -void icvSetOpenGlCleanCallback(const char* name, CvOpenGlCleanCallback callback, void* userdata) -{ - CV_FUNCNAME( "icvSetOpenGlCleanCallback" ); - - __BEGIN__; - - CvWindow* window; - - if (!name) - CV_ERROR(CV_StsNullPtr, "NULL name string"); - - window = icvFindWindowByName(name); - if (!window) - EXIT; - - if (window->glCleanCallback) - window->glCleanCallback(window->glCleanData); - - window->glCleanCallback = callback; - window->glCleanData = userdata; - - __END__; -} - #endif // HAVE_OPENGL static void icvRemoveWindow( CvWindow* window ) @@ -1194,18 +890,7 @@ static void icvRemoveWindow( CvWindow* window ) #ifdef HAVE_OPENGL if (window->useGl) - { - wglMakeCurrent(window->dc, window->hGLRC); - - if (window->glCleanCallback) - { - window->glCleanCallback(window->glCleanData); - window->glCleanCallback = 0; - window->glCleanData = 0; - } - releaseGlContext(window); - } #endif if( window->frame ) diff --git a/samples/cpp/point_cloud.cpp b/samples/cpp/point_cloud.cpp deleted file mode 100644 index 3672de1420..0000000000 --- a/samples/cpp/point_cloud.cpp +++ /dev/null @@ -1,357 +0,0 @@ -#include -#include -#include -#include -#include "opencv2/core/core.hpp" -#include "opencv2/core/opengl_interop.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/imgproc/imgproc.hpp" -#include "opencv2/calib3d/calib3d.hpp" -#include "opencv2/contrib/contrib.hpp" - -using namespace std; -using namespace cv; -using namespace cv::gpu; - -class PointCloudRenderer -{ -public: - PointCloudRenderer(const Mat& points, const Mat& img, double scale); - - void onMouseEvent(int event, int x, int y, int flags); - void draw(); - void update(int key, double aspect); - - int fov_; - -private: - int mouse_dx_; - int mouse_dy_; - - double yaw_; - double pitch_; - Point3d pos_; - - TickMeter tm_; - static const int step_; - int frame_; - - GlCamera camera_; - GlArrays pointCloud_; - string fps_; -}; - -bool stop = false; - -static void mouseCallback(int event, int x, int y, int flags, void* userdata) -{ - if (stop) - return; - - PointCloudRenderer* renderer = static_cast(userdata); - renderer->onMouseEvent(event, x, y, flags); -} - -static void openGlDrawCallback(void* userdata) -{ - if (stop) - return; - - PointCloudRenderer* renderer = static_cast(userdata); - renderer->draw(); -} - -int main(int argc, const char* argv[]) -{ - const char* keys = - "{ l left | | left image file name }" - "{ r right | | right image file name }" - "{ i intrinsic | | intrinsic camera parameters file name }" - "{ e extrinsic | | extrinsic camera parameters file name }" - "{ d ndisp | 256 | number of disparities }" - "{ s scale | 1.0 | scale factor for point cloud }" - "{ h help | | print help message }"; - - CommandLineParser cmd(argc, argv, keys); - - if (cmd.has("help")) - { - cmd.printMessage(); - return 0; - } - - string left = cmd.get("left"); - string right = cmd.get("right"); - string intrinsic = cmd.get("intrinsic"); - string extrinsic = cmd.get("extrinsic"); - int ndisp = cmd.get("ndisp"); - double scale = cmd.get("scale"); - - if (!cmd.check()) - { - cmd.printErrors(); - return 0; - } - - - if (left.empty() || right.empty()) - { - cout << "Missed input images" << endl; - cout << "Avaible options:" << endl; - cmd.printMessage(); - return 0; - } - - if (intrinsic.empty() ^ extrinsic.empty()) - { - cout << "Boss camera parameters must be specified" << endl; - cout << "Avaible options:" << endl; - cmd.printMessage(); - return 0; - } - - Mat imgLeftColor = imread(left, IMREAD_COLOR); - Mat imgRightColor = imread(right, IMREAD_COLOR); - - if (imgLeftColor.empty()) - { - cout << "Can't load image " << left << endl; - return -1; - } - - if (imgRightColor.empty()) - { - cout << "Can't load image " << right << endl; - return -1; - } - - Mat Q = Mat::eye(4, 4, CV_32F); - if (!intrinsic.empty() && !extrinsic.empty()) - { - FileStorage fs; - - // reading intrinsic parameters - fs.open(intrinsic, CV_STORAGE_READ); - if (!fs.isOpened()) - { - cout << "Failed to open file " << intrinsic << endl; - return -1; - } - - Mat M1, D1, M2, D2; - fs["M1"] >> M1; - fs["D1"] >> D1; - fs["M2"] >> M2; - fs["D2"] >> D2; - - // reading extrinsic parameters - fs.open(extrinsic, CV_STORAGE_READ); - if (!fs.isOpened()) - { - cout << "Failed to open file " << extrinsic << endl; - return -1; - } - - Mat R, T, R1, P1, R2, P2; - fs["R"] >> R; - fs["T"] >> T; - - Size img_size = imgLeftColor.size(); - - Rect roi1, roi2; - stereoRectify(M1, D1, M2, D2, img_size, R, T, R1, R2, P1, P2, Q, CALIB_ZERO_DISPARITY, -1, img_size, &roi1, &roi2); - - Mat map11, map12, map21, map22; - initUndistortRectifyMap(M1, D1, R1, P1, img_size, CV_16SC2, map11, map12); - initUndistortRectifyMap(M2, D2, R2, P2, img_size, CV_16SC2, map21, map22); - - Mat img1r, img2r; - remap(imgLeftColor, img1r, map11, map12, INTER_LINEAR); - remap(imgRightColor, img2r, map21, map22, INTER_LINEAR); - - imgLeftColor = img1r(roi1); - imgRightColor = img2r(roi2); - } - - Mat imgLeftGray, imgRightGray; - cvtColor(imgLeftColor, imgLeftGray, COLOR_BGR2GRAY); - cvtColor(imgRightColor, imgRightGray, COLOR_BGR2GRAY); - - cvtColor(imgLeftColor, imgLeftColor, COLOR_BGR2RGB); - - Mat disp, points; - - StereoBM bm(0, ndisp); - - bm(imgLeftGray, imgRightGray, disp); - disp.convertTo(disp, CV_8U, 1.0 / 16.0); - - disp = disp(Range(21, disp.rows - 21), Range(ndisp, disp.cols - 21)).clone(); - imgLeftColor = imgLeftColor(Range(21, imgLeftColor.rows - 21), Range(ndisp, imgLeftColor.cols - 21)).clone(); - - reprojectImageTo3D(disp, points, Q); - - const string windowName = "OpenGL Sample"; - - namedWindow(windowName, WINDOW_OPENGL); - resizeWindow(windowName, 400, 400); - - PointCloudRenderer renderer(points, imgLeftColor, scale); - - createTrackbar("Fov", windowName, &renderer.fov_, 100); - setMouseCallback(windowName, mouseCallback, &renderer); - setOpenGlDrawCallback(windowName, openGlDrawCallback, &renderer); - - for(;;) - { - int key = waitKey(10); - - if (key >= 0) - key = key & 0xff; - - if (key == 27) - { - stop = true; - break; - } - - double aspect = getWindowProperty(windowName, WND_PROP_ASPECT_RATIO); - - key = tolower(key); - - renderer.update(key, aspect); - - updateWindow(windowName); - } - - return 0; -} - -const int PointCloudRenderer::step_ = 20; - -PointCloudRenderer::PointCloudRenderer(const Mat& points, const Mat& img, double scale) -{ - mouse_dx_ = 0; - mouse_dy_ = 0; - - fov_ = 0; - yaw_ = 0.0; - pitch_ = 0.0; - - frame_ = 0; - - camera_.setScale(Point3d(scale, scale, scale)); - - pointCloud_.setVertexArray(points); - pointCloud_.setColorArray(img, false); - - tm_.start(); -} - -inline int clamp(int val, int minVal, int maxVal) -{ - return max(min(val, maxVal), minVal); -} - -void PointCloudRenderer::onMouseEvent(int event, int x, int y, int /*flags*/) -{ - static int oldx = x; - static int oldy = y; - static bool moving = false; - - if (event == EVENT_LBUTTONDOWN) - { - oldx = x; - oldy = y; - moving = true; - } - else if (event == EVENT_LBUTTONUP) - { - moving = false; - } - - if (moving) - { - mouse_dx_ = oldx - x; - mouse_dy_ = oldy - y; - } - else - { - mouse_dx_ = 0; - mouse_dy_ = 0; - } - - const int mouseClamp = 300; - mouse_dx_ = clamp(mouse_dx_, -mouseClamp, mouseClamp); - mouse_dy_ = clamp(mouse_dy_, -mouseClamp, mouseClamp); -} - -static Point3d rotate(Point3d v, double yaw, double pitch) -{ - Point3d t1; - t1.x = v.x * cos(-yaw / 180.0 * CV_PI) - v.z * sin(-yaw / 180.0 * CV_PI); - t1.y = v.y; - t1.z = v.x * sin(-yaw / 180.0 * CV_PI) + v.z * cos(-yaw / 180.0 * CV_PI); - - Point3d t2; - t2.x = t1.x; - t2.y = t1.y * cos(pitch / 180.0 * CV_PI) - t1.z * sin(pitch / 180.0 * CV_PI); - t2.z = t1.y * sin(pitch / 180.0 * CV_PI) + t1.z * cos(pitch / 180.0 * CV_PI); - - return t2; -} - -void PointCloudRenderer::update(int key, double aspect) -{ - const Point3d dirVec(0.0, 0.0, -1.0); - const Point3d upVec(0.0, 1.0, 0.0); - const Point3d leftVec(-1.0, 0.0, 0.0); - - const double posStep = 0.1; - - const double mouseStep = 0.001; - - camera_.setPerspectiveProjection(30.0 + fov_ / 100.0 * 40.0, aspect, 0.1, 1000.0); - - yaw_ += mouse_dx_ * mouseStep; - pitch_ += mouse_dy_ * mouseStep; - - if (key == 'w') - pos_ += posStep * rotate(dirVec, yaw_, pitch_); - else if (key == 's') - pos_ -= posStep * rotate(dirVec, yaw_, pitch_); - else if (key == 'a') - pos_ += posStep * rotate(leftVec, yaw_, pitch_); - else if (key == 'd') - pos_ -= posStep * rotate(leftVec, yaw_, pitch_); - else if (key == 'q') - pos_ += posStep * rotate(upVec, yaw_, pitch_); - else if (key == 'e') - pos_ -= posStep * rotate(upVec, yaw_, pitch_); - - camera_.setCameraPos(pos_, yaw_, pitch_, 0.0); - - tm_.stop(); - - if (frame_++ >= step_) - { - ostringstream ostr; - ostr << "FPS: " << step_ / tm_.getTimeSec(); - fps_ = ostr.str(); - - frame_ = 0; - tm_.reset(); - } - - tm_.start(); -} - -void PointCloudRenderer::draw() -{ - camera_.setupProjectionMatrix(); - camera_.setupModelViewMatrix(); - - render(pointCloud_); - - render(fps_, GlFont::get("Courier New", 16), Scalar::all(255), Point2d(3.0, 0.0)); -} diff --git a/samples/gpu/brox_optical_flow.cpp b/samples/gpu/brox_optical_flow.cpp index b25e38a9f0..143d0b4853 100644 --- a/samples/gpu/brox_optical_flow.cpp +++ b/samples/gpu/brox_optical_flow.cpp @@ -4,7 +4,6 @@ #include "cvconfig.h" #include "opencv2/core/core.hpp" -#include "opencv2/core/opengl_interop.hpp" #include "opencv2/highgui/highgui.hpp" #include "opencv2/gpu/gpu.hpp" @@ -14,12 +13,6 @@ using namespace cv::gpu; void getFlowField(const Mat& u, const Mat& v, Mat& flowField); -#ifdef HAVE_OPENGL - -void needleMapDraw(void* userdata); - -#endif - int main(int argc, const char* argv[]) { try @@ -79,12 +72,8 @@ int main(int argc, const char* argv[]) namedWindow("Forward flow"); namedWindow("Backward flow"); - namedWindow("Needle Map", WINDOW_OPENGL); - namedWindow("Interpolated frame"); - setGlDevice(); - cout << "Press:" << endl; cout << "\tESC to quit" << endl; cout << "\t'a' to move to the previous frame" << endl; @@ -123,14 +112,6 @@ int main(int argc, const char* argv[]) Mat flowFieldBackward; getFlowField(Mat(d_bu), Mat(d_bv), flowFieldBackward); -#ifdef HAVE_OPENGL - cout << "Create Optical Flow Needle Map..." << endl; - - GpuMat d_vertex, d_colors; - - createOpticalFlowNeedleMap(d_fu, d_fv, d_vertex, d_colors); -#endif - cout << "Interpolating..." << endl; // first frame color components @@ -195,14 +176,6 @@ int main(int argc, const char* argv[]) imshow("Forward flow", flowFieldForward); imshow("Backward flow", flowFieldBackward); -#ifdef HAVE_OPENGL - GlArrays arr; - arr.setVertexArray(d_vertex); - arr.setColorArray(d_colors, false); - - setOpenGlDrawCallback("Needle Map", needleMapDraw, &arr); -#endif - int currentFrame = 0; imshow("Interpolated frame", frames[currentFrame]); @@ -292,21 +265,3 @@ void getFlowField(const Mat& u, const Mat& v, Mat& flowField) } } } - -#ifdef HAVE_OPENGL - -void needleMapDraw(void* userdata) -{ - const GlArrays* arr = static_cast(userdata); - - GlCamera camera; - camera.setOrthoProjection(0.0, 1.0, 1.0, 0.0, 0.0, 1.0); - camera.lookAt(Point3d(0.0, 0.0, 1.0), Point3d(0.0, 0.0, 0.0), Point3d(0.0, 1.0, 0.0)); - - camera.setupProjectionMatrix(); - camera.setupModelViewMatrix(); - - render(*arr, RenderMode::TRIANGLES); -} - -#endif diff --git a/samples/gpu/highgui_gpu.cpp b/samples/gpu/highgui_gpu.cpp deleted file mode 100644 index 368a6f6084..0000000000 --- a/samples/gpu/highgui_gpu.cpp +++ /dev/null @@ -1,135 +0,0 @@ -#include -#include - -#include "opencv2/core/core.hpp" -#include "opencv2/core/gpumat.hpp" -#include "opencv2/core/opengl_interop.hpp" -#include "opencv2/gpu/gpu.hpp" -#include "opencv2/highgui/highgui.hpp" -#include "opencv2/contrib/contrib.hpp" - -using namespace std; -using namespace cv; -using namespace cv::gpu; - -struct Timer -{ - Timer(const string& msg_) - { - msg = msg_; - - tm.reset(); - tm.start(); - } - - ~Timer() - { - tm.stop(); - cout << msg << " " << tm.getTimeMilli() << " ms\n"; - } - - string msg; - TickMeter tm; -}; - -int main(int argc, char* argv[]) -{ - if (argc < 2) - { - cout << "Usage: " << argv[0] << " image" << endl; - return -1; - } - - try - { - bool haveCuda = getCudaEnabledDeviceCount() > 0; - - const string openGlMatWnd = "OpenGL Mat"; - const string openGlBufferWnd = "OpenGL GlBuffer"; - const string openGlTextureWnd = "OpenGL GlTexture"; - const string openGlGpuMatWnd = "OpenGL GpuMat"; - const string matWnd = "Mat"; - - namedWindow(openGlMatWnd, WINDOW_OPENGL | WINDOW_AUTOSIZE); - namedWindow(openGlBufferWnd, WINDOW_OPENGL | WINDOW_AUTOSIZE); - namedWindow(openGlTextureWnd, WINDOW_OPENGL | WINDOW_AUTOSIZE); - if (haveCuda) - namedWindow(openGlGpuMatWnd, WINDOW_OPENGL | WINDOW_AUTOSIZE); - namedWindow("Mat", WINDOW_AUTOSIZE); - - Mat img = imread(argv[1]); - - if (haveCuda) - setGlDevice(); - - setOpenGlContext(openGlBufferWnd); - GlBuffer buf(img, GlBuffer::TEXTURE_BUFFER); - - setOpenGlContext(openGlTextureWnd); - GlTexture tex(img); - - GpuMat d_img; - if (haveCuda) - d_img.upload(img); - - cout << "=== First call\n\n"; - - { - Timer t("OpenGL Mat "); - imshow(openGlMatWnd, img); - } - { - Timer t("OpenGL GlBuffer "); - imshow(openGlBufferWnd, buf); - } - { - Timer t("OpenGL GlTexture"); - imshow(openGlTextureWnd, tex); - } - if (haveCuda) - { - Timer t("OpenGL GpuMat "); - imshow(openGlGpuMatWnd, d_img); - } - { - Timer t("Mat "); - imshow(matWnd, img); - } - - waitKey(); - - cout << "\n=== Second call\n\n"; - - { - Timer t("OpenGL Mat "); - imshow(openGlMatWnd, img); - } - { - Timer t("OpenGL GlBuffer "); - imshow(openGlBufferWnd, buf); - } - { - Timer t("OpenGL GlTexture"); - imshow(openGlTextureWnd, tex); - } - if (haveCuda) - { - Timer t("OpenGL GpuMat "); - imshow(openGlGpuMatWnd, d_img); - } - { - Timer t("Mat "); - imshow(matWnd, img); - } - - cout << "\n"; - - waitKey(); - } - catch(const exception& e) - { - cout << e.what() << endl; - } - - return 0; -} diff --git a/samples/gpu/opengl.cpp b/samples/gpu/opengl.cpp new file mode 100644 index 0000000000..acd59e2942 --- /dev/null +++ b/samples/gpu/opengl.cpp @@ -0,0 +1,128 @@ +#include +#include "cvconfig.h" + +#ifndef HAVE_OPENGL +int main() +{ + std::cerr << "Library was built without OpenGL support" << std::endl; + return -1; +} +#else + +#ifdef WIN32 + #define WIN32_LEAN_AND_MEAN 1 + #define NOMINMAX 1 + #include +#endif + +#if defined(__APPLE__) + #include + #include +#else + #include + #include +#endif + +#include "opencv2/core/core.hpp" +#include "opencv2/core/opengl_interop.hpp" +#include "opencv2/core/gpumat.hpp" +#include "opencv2/highgui/highgui.hpp" + +using namespace std; +using namespace cv; +using namespace cv::gpu; + +const int win_width = 800; +const int win_height = 640; + +struct DrawData +{ + GlArrays arr; + GlTexture2D tex; + GlBuffer indices; +}; + +void CV_CDECL draw(void* userdata); + +void CV_CDECL draw(void* userdata) +{ + static double angle = 0.0; + + DrawData* data = static_cast(userdata); + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + gluPerspective(45.0, (double)win_width / win_height, 0.1, 100.0); + + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + gluLookAt(0, 0, 4, 0, 0, 0, 0, 1, 0); + glRotated(angle, 0, 1, 0); + + glEnable(GL_TEXTURE_2D); + data->tex.bind(); + + glDisable(GL_CULL_FACE); + glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST); + + render(data->arr, data->indices, RenderMode::TRIANGLES); + + angle += 0.3; +} + +int main(int argc, char* argv[]) +{ + if (argc < 2) + { + cout << "Usage: " << argv[0] << " image" << endl; + return -1; + } + + Mat img = imread(argv[1]); + if (img.empty()) + { + cerr << "Can't open image " << argv[1] << endl; + return -1; + } + + namedWindow("OpenGL", WINDOW_OPENGL); + resizeWindow("OpenGL", win_width, win_height); + + Mat_ vertex(1, 4); + vertex << Vec2f(-1, 1), Vec2f(-1, -1), Vec2f(1, -1), Vec2f(1, 1); + + Mat_ texCoords(1, 4); + texCoords << Vec2f(0, 0), Vec2f(0, 1), Vec2f(1, 1), Vec2f(1, 0); + + Mat_ indices(1, 6); + indices << 0, 1, 2, 2, 3, 0; + + DrawData data; + + data.arr.setVertexArray(vertex); + data.arr.setTexCoordArray(texCoords); + data.arr.setAutoRelease(false); + + data.indices.copyFrom(indices); + data.indices.setAutoRelease(false); + + data.tex.copyFrom(img); + data.tex.setAutoRelease(false); + + setOpenGlDrawCallback("OpenGL", draw, &data); + + for (;;) + { + updateWindow("OpenGL"); + int key = waitKey(10); + if ((key & 0xff) == 27) + break; + } + + setOpenGlDrawCallback("OpenGL", 0, 0); + destroyAllWindows(); + + return 0; +} + +#endif diff --git a/samples/gpu/pyrlk_optical_flow.cpp b/samples/gpu/pyrlk_optical_flow.cpp index 8792b94956..c2e765da13 100644 --- a/samples/gpu/pyrlk_optical_flow.cpp +++ b/samples/gpu/pyrlk_optical_flow.cpp @@ -3,7 +3,6 @@ #include "cvconfig.h" #include "opencv2/core/core.hpp" -#include "opencv2/core/opengl_interop.hpp" #include "opencv2/imgproc/imgproc.hpp" #include "opencv2/highgui/highgui.hpp" #include "opencv2/video/video.hpp" @@ -66,40 +65,6 @@ static void drawArrows(Mat& frame, const vector& prevPts, const vector< } } -#ifdef HAVE_OPENGL - -struct DrawData -{ - GlTexture tex; - GlArrays arr; -}; - -static void drawCallback(void* userdata) -{ - DrawData* data = static_cast(userdata); - - if (data->tex.empty() || data->arr.empty()) - return; - - static GlCamera camera; - static bool init_camera = true; - - if (init_camera) - { - camera.setOrthoProjection(0.0, 1.0, 1.0, 0.0, 0.0, 1.0); - camera.lookAt(Point3d(0.0, 0.0, 1.0), Point3d(0.0, 0.0, 0.0), Point3d(0.0, 1.0, 0.0)); - init_camera = false; - } - - camera.setupProjectionMatrix(); - camera.setupModelViewMatrix(); - - render(data->tex); - render(data->arr, RenderMode::TRIANGLES); -} - -#endif - template inline T clamp (T x, T a, T b) { return ((x) > (a) ? ((x) < (b) ? (x) : (b)) : (a)); @@ -199,12 +164,6 @@ int main(int argc, const char* argv[]) namedWindow("PyrLK [Sparse]", WINDOW_NORMAL); namedWindow("PyrLK [Dense] Flow Field", WINDOW_NORMAL); - #ifdef HAVE_OPENGL - namedWindow("PyrLK [Dense]", WINDOW_OPENGL); - - setGlDevice(); - #endif - cout << "Image size : " << frame0.cols << " x " << frame0.rows << endl; cout << "Points count : " << points << endl; @@ -270,21 +229,6 @@ int main(int argc, const char* argv[]) imshow("PyrLK [Dense] Flow Field", flowField); - #ifdef HAVE_OPENGL - setOpenGlContext("PyrLK [Dense]"); - - GpuMat d_vertex, d_colors; - createOpticalFlowNeedleMap(d_u, d_v, d_vertex, d_colors); - - DrawData drawData; - - drawData.tex.copyFrom(d_frame0Gray); - drawData.arr.setVertexArray(d_vertex); - drawData.arr.setColorArray(d_colors, false); - - setOpenGlDrawCallback("PyrLK [Dense]", drawCallback, &drawData); - #endif - waitKey(); return 0; diff --git a/samples/gpu/stereo_multi.cpp b/samples/gpu/stereo_multi.cpp index c7fa5539bb..d424bf90b4 100644 --- a/samples/gpu/stereo_multi.cpp +++ b/samples/gpu/stereo_multi.cpp @@ -47,7 +47,7 @@ GpuMat d_result[2]; // CPU result Mat result; -void printHelp() +static void printHelp() { std::cout << "Usage: stereo_multi_gpu --left --right \n"; }