refactored opengl functionality

* removed OpenGLFuncTab, now extensions are loaded internally
* renamed GlTexture -> GlTexture2D
* added support of GlBuffer and GlTexture2D to InputArray/OutputArray
* added ELEMENT_ARRAY_BUFFER and PIXEL_PACK_BUFFER targets
* added copyFrom/copyTo method for GlBuffer and GlTexture2D
* removed GlFont
* removed pointCloudShow
* removed OpenGLCleanCallback

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<Mat>& 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<typename _Tp, int m, int n> _OutputArray(Matx<_Tp, m, n>& matx);
     template<typename _Tp> _OutputArray(_Tp* vec, int n);
     _OutputArray(gpu::GpuMat& d_mat);
+    _OutputArray(GlBuffer& buf);
+    _OutputArray(GlTexture2D& tex);
 
     _OutputArray(const Mat& m);
     template<typename _Tp> _OutputArray(const vector<_Tp>& vec);
@@ -1395,12 +1397,16 @@ public:
     template<typename _Tp, int m, int n> _OutputArray(const Matx<_Tp, m, n>& matx);
     template<typename _Tp> _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;

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__

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> impl_;
     int rows_;
     int cols_;
     int type_;
-    Usage usage_;
-
-    Ptr<Impl> impl_;
 };
 
 template <> CV_EXPORTS void Ptr<GlBuffer::Impl>::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> impl_;
     int rows_;
     int cols_;
-    int type_;
-
-    Ptr<Impl> impl_;
-    GlBuffer buf_;
+    Format format_;
 };
 
-template <> CV_EXPORTS void Ptr<GlTexture::Impl>::delete_obj();
+template <> CV_EXPORTS void Ptr<GlTexture2D::Impl>::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<GlFont> 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_<double> wndRect = Rect_<double>(0.0, 0.0, 1.0, 1.0),
     Rect_<double> texRect = Rect_<double>(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<GlFont>& 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

modules/core/src/matrix.cpp

@@ -922,8 +922,8 @@ _InputArray::_InputArray(const Mat& m) : flags(MAT), obj((void*)&m) {}
 _InputArray::_InputArray(const vector<Mat>& 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<Mat>& 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<Mat>& 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; }