vispy 0.15.0__cp313-cp313-macosx_10_13_x86_64.whl

vispy/gloo/gl/glplus.py

@@ -0,0 +1,168 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+"""This module provides a namespace for additional desktop OpenGL functions.
+
+The functions in this module are copied from PyOpenGL, but any deprecated
+functions are omitted, as well as any functions that are in our ES 2.0 API.
+
+"""
+
+from OpenGL import GL as _GL
+from . import _pyopengl2
+from . import _constants
+
+
+def _inject():
+    """Inject functions and constants from PyOpenGL but leave out the
+    names that are deprecated or that we provide in our API.
+    """
+    # Get namespaces
+    NS = globals()
+    GLNS = _GL.__dict__
+
+    # Get names that we use in our API
+    used_names = []
+    used_names.extend([names[0] for names in _pyopengl2._functions_to_import])
+    used_names.extend([name for name in _pyopengl2._used_functions])
+    NS['_used_names'] = used_names
+    #
+    used_constants = set(_constants.__dict__)
+    # Count
+    injected_constants = 0
+    injected_functions = 0
+
+    for name in dir(_GL):
+
+        if name.startswith('GL_'):
+            # todo: find list of deprecated constants
+            if name not in used_constants:
+                NS[name] = GLNS[name]
+                injected_constants += 1
+
+        elif name.startswith('gl'):
+            # Functions
+            if (name + ',') in _deprecated_functions:
+                pass  # Function is deprecated
+            elif name in used_names:
+                pass  # Function is in our GL ES 2.0 API
+            else:
+                NS[name] = GLNS[name]
+                injected_functions += 1
+
+    # print('injected %i constants and %i functions in glplus' % 
+    #      (injected_constants, injected_functions))
+
+
+# List of deprecated functions, obtained by parsing gl.spec
+_deprecated_functions = """
+    glAccum, glAlphaFunc, glAreTexturesResident, glArrayElement, glBegin, 
+    glBitmap, glCallList, glCallLists, glClearAccum, glClearIndex, 
+    glClientActiveTexture, glClipPlane, glColor3b, glColor3bv, glColor3d, 
+    glColor3dv, glColor3f, glColor3fv, glColor3i, glColor3iv, glColor3s, 
+    glColor3sv, glColor3ub, glColor3ubv, glColor3ui, glColor3uiv, glColor3us, 
+    glColor3usv, glColor4b, glColor4bv, glColor4d, glColor4dv, glColor4f, 
+    glColor4fv, glColor4i, glColor4iv, glColor4s, glColor4sv, glColor4ub, 
+    glColor4ubv, glColor4ui, glColor4uiv, glColor4us, glColor4usv, 
+    glColorMaterial, glColorPointer, glColorSubTable, glColorTable, 
+    glColorTableParameterfv, glColorTableParameteriv, glConvolutionFilter1D, 
+    glConvolutionFilter2D, glConvolutionParameterf, glConvolutionParameterfv, 
+    glConvolutionParameteri, glConvolutionParameteriv, glCopyColorSubTable, 
+    glCopyColorTable, glCopyConvolutionFilter1D, glCopyConvolutionFilter2D, 
+    glCopyPixels, glDeleteLists, glDisableClientState, glDrawPixels, 
+    glEdgeFlag, glEdgeFlagPointer, glEdgeFlagv, glEnableClientState, glEnd, 
+    glEndList, glEvalCoord1d, glEvalCoord1dv, glEvalCoord1f, glEvalCoord1fv, 
+    glEvalCoord2d, glEvalCoord2dv, glEvalCoord2f, glEvalCoord2fv, 
+    glEvalMesh1, glEvalMesh2, glEvalPoint1, glEvalPoint2, glFeedbackBuffer, 
+    glFogCoordPointer, glFogCoordd, glFogCoorddv, glFogCoordf, glFogCoordfv, 
+    glFogf, glFogfv, glFogi, glFogiv, glFrustum, glGenLists, glGetClipPlane, 
+    glGetColorTable, glGetColorTableParameterfv, glGetColorTableParameteriv, 
+    glGetConvolutionFilter, glGetConvolutionParameterfv, 
+    glGetConvolutionParameteriv, glGetHistogram, glGetHistogramParameterfv, 
+    glGetHistogramParameteriv, glGetLightfv, glGetLightiv, glGetMapdv, 
+    glGetMapfv, glGetMapiv, glGetMaterialfv, glGetMaterialiv, glGetMinmax, 
+    glGetMinmaxParameterfv, glGetMinmaxParameteriv, glGetPixelMapfv, 
+    glGetPixelMapuiv, glGetPixelMapusv, glGetPolygonStipple, 
+    glGetSeparableFilter, glGetTexEnvfv, glGetTexEnviv, glGetTexGendv, 
+    glGetTexGenfv, glGetTexGeniv, glHistogram, glIndexMask, glIndexPointer, 
+    glIndexd, glIndexdv, glIndexf, glIndexfv, glIndexi, glIndexiv, glIndexs, 
+    glIndexsv, glInitNames, glInterleavedArrays, glIsList, glLightModelf, 
+    glLightModelfv, glLightModeli, glLightModeliv, glLightf, glLightfv, 
+    glLighti, glLightiv, glLineStipple, glListBase, glLoadIdentity, 
+    glLoadMatrixd, glLoadMatrixf, glLoadName, glLoadTransposeMatrixd, 
+    glLoadTransposeMatrixf, glMap1d, glMap1f, glMap2d, glMap2f, glMapGrid1d, 
+    glMapGrid1f, glMapGrid2d, glMapGrid2f, glMaterialf, glMaterialfv, 
+    glMateriali, glMaterialiv, glMatrixMode, glMinmax, glMultMatrixd, 
+    glMultMatrixf, glMultTransposeMatrixd, glMultTransposeMatrixf, 
+    glMultiTexCoord1d, glMultiTexCoord1dv, glMultiTexCoord1f, 
+    glMultiTexCoord1fv, glMultiTexCoord1i, glMultiTexCoord1iv, 
+    glMultiTexCoord1s, glMultiTexCoord1sv, glMultiTexCoord2d, 
+    glMultiTexCoord2dv, glMultiTexCoord2f, glMultiTexCoord2fv, 
+    glMultiTexCoord2i, glMultiTexCoord2iv, glMultiTexCoord2s, 
+    glMultiTexCoord2sv, glMultiTexCoord3d, glMultiTexCoord3dv, 
+    glMultiTexCoord3f, glMultiTexCoord3fv, glMultiTexCoord3i, 
+    glMultiTexCoord3iv, glMultiTexCoord3s, glMultiTexCoord3sv, 
+    glMultiTexCoord4d, glMultiTexCoord4dv, glMultiTexCoord4f, 
+    glMultiTexCoord4fv, glMultiTexCoord4i, glMultiTexCoord4iv, 
+    glMultiTexCoord4s, glMultiTexCoord4sv, glNewList, glNormal3b, 
+    glNormal3bv, glNormal3d, glNormal3dv, glNormal3f, glNormal3fv, 
+    glNormal3i, glNormal3iv, glNormal3s, glNormal3sv, glNormalPointer, 
+    glOrtho, glPassThrough, glPixelMapfv, glPixelMapuiv, glPixelMapusv, 
+    glPixelTransferf, glPixelTransferi, glPixelZoom, glPolygonStipple, 
+    glPopAttrib, glPopClientAttrib, glPopMatrix, glPopName, 
+    glPrioritizeTextures, glPushAttrib, glPushClientAttrib, glPushMatrix, 
+    glPushName, glRasterPos2d, glRasterPos2dv, glRasterPos2f, glRasterPos2fv, 
+    glRasterPos2i, glRasterPos2iv, glRasterPos2s, glRasterPos2sv, 
+    glRasterPos3d, glRasterPos3dv, glRasterPos3f, glRasterPos3fv, 
+    glRasterPos3i, glRasterPos3iv, glRasterPos3s, glRasterPos3sv, 
+    glRasterPos4d, glRasterPos4dv, glRasterPos4f, glRasterPos4fv, 
+    glRasterPos4i, glRasterPos4iv, glRasterPos4s, glRasterPos4sv, glRectd, 
+    glRectdv, glRectf, glRectfv, glRecti, glRectiv, glRects, glRectsv, 
+    glRenderMode, glResetHistogram, glResetMinmax, glRotated, glRotatef, 
+    glScaled, glScalef, glSecondaryColor3b, glSecondaryColor3bv, 
+    glSecondaryColor3d, glSecondaryColor3dv, glSecondaryColor3f, 
+    glSecondaryColor3fv, glSecondaryColor3i, glSecondaryColor3iv, 
+    glSecondaryColor3s, glSecondaryColor3sv, glSecondaryColor3ub, 
+    glSecondaryColor3ubv, glSecondaryColor3ui, glSecondaryColor3uiv, 
+    glSecondaryColor3us, glSecondaryColor3usv, glSecondaryColorPointer, 
+    glSelectBuffer, glSeparableFilter2D, glShadeModel, glTexCoord1d, 
+    glTexCoord1dv, glTexCoord1f, glTexCoord1fv, glTexCoord1i, glTexCoord1iv, 
+    glTexCoord1s, glTexCoord1sv, glTexCoord2d, glTexCoord2dv, glTexCoord2f, 
+    glTexCoord2fv, glTexCoord2i, glTexCoord2iv, glTexCoord2s, glTexCoord2sv, 
+    glTexCoord3d, glTexCoord3dv, glTexCoord3f, glTexCoord3fv, glTexCoord3i, 
+    glTexCoord3iv, glTexCoord3s, glTexCoord3sv, glTexCoord4d, glTexCoord4dv, 
+    glTexCoord4f, glTexCoord4fv, glTexCoord4i, glTexCoord4iv, glTexCoord4s, 
+    glTexCoord4sv, glTexCoordPointer, glTexEnvf, glTexEnvfv, glTexEnvi, 
+    glTexEnviv, glTexGend, glTexGendv, glTexGenf, glTexGenfv, glTexGeni, 
+    glTexGeniv, glTranslated, glTranslatef, glVertex2d, glVertex2dv, 
+    glVertex2f, glVertex2fv, glVertex2i, glVertex2iv, glVertex2s, 
+    glVertex2sv, glVertex3d, glVertex3dv, glVertex3f, glVertex3fv, 
+    glVertex3i, glVertex3iv, glVertex3s, glVertex3sv, glVertex4d, 
+    glVertex4dv, glVertex4f, glVertex4fv, glVertex4i, glVertex4iv, 
+    glVertex4s, glVertex4sv, glVertexAttrib1d, glVertexAttrib1dv, 
+    glVertexAttrib1f, glVertexAttrib1fv, glVertexAttrib1s, glVertexAttrib1sv, 
+    glVertexAttrib2d, glVertexAttrib2dv, glVertexAttrib2f, glVertexAttrib2fv, 
+    glVertexAttrib2s, glVertexAttrib2sv, glVertexAttrib3d, glVertexAttrib3dv, 
+    glVertexAttrib3f, glVertexAttrib3fv, glVertexAttrib3s, glVertexAttrib3sv, 
+    glVertexAttrib4Nbv, glVertexAttrib4Niv, glVertexAttrib4Nsv, 
+    glVertexAttrib4Nub, glVertexAttrib4Nubv, glVertexAttrib4Nuiv, 
+    glVertexAttrib4Nusv, glVertexAttrib4bv, glVertexAttrib4d, 
+    glVertexAttrib4dv, glVertexAttrib4f, glVertexAttrib4fv, 
+    glVertexAttrib4iv, glVertexAttrib4s, glVertexAttrib4sv, 
+    glVertexAttrib4ubv, glVertexAttrib4uiv, glVertexAttrib4usv, 
+    glVertexAttribI1i, glVertexAttribI1iv, glVertexAttribI1ui, 
+    glVertexAttribI1uiv, glVertexAttribI2i, glVertexAttribI2iv, 
+    glVertexAttribI2ui, glVertexAttribI2uiv, glVertexAttribI3i, 
+    glVertexAttribI3iv, glVertexAttribI3ui, glVertexAttribI3uiv, 
+    glVertexAttribI4bv, glVertexAttribI4i, glVertexAttribI4iv, 
+    glVertexAttribI4sv, glVertexAttribI4ubv, glVertexAttribI4ui, 
+    glVertexAttribI4uiv, glVertexAttribI4usv, glVertexPointer, glWindowPos2d, 
+    glWindowPos2dv, glWindowPos2f, glWindowPos2fv, glWindowPos2i, 
+    glWindowPos2iv, glWindowPos2s, glWindowPos2sv, glWindowPos3d, 
+    glWindowPos3dv, glWindowPos3f, glWindowPos3fv, glWindowPos3i, 
+    glWindowPos3iv, glWindowPos3s, glWindowPos3sv, 
+    """
+
+
+_inject()

vispy/gloo/gl/pyopengl2.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+"""GL ES 2.0 API implemented via pyOpenGL library. Intended as a
+fallback and for testing.
+"""
+
+from OpenGL import GL as _GL
+import OpenGL.GL.framebufferobjects as _FBO
+
+from ...util import logger
+
+from . import _copy_gl_functions
+from ._constants import *  # noqa
+
+
+def _patch():
+    """Monkey-patch pyopengl to fix a bug in glBufferSubData."""
+    import sys
+    from OpenGL import GL
+    if sys.version_info > (3,):
+        buffersubdatafunc = GL.glBufferSubData
+        if hasattr(buffersubdatafunc, 'wrapperFunction'):
+            buffersubdatafunc = buffersubdatafunc.wrapperFunction
+        _m = sys.modules[buffersubdatafunc.__module__]
+        _m.long = int
+
+    # Fix missing enum
+    try:
+        from OpenGL.GL.VERSION import GL_2_0
+        GL_2_0.GL_OBJECT_SHADER_SOURCE_LENGTH = GL_2_0.GL_SHADER_SOURCE_LENGTH
+    except Exception:
+        pass
+
+# Patch OpenGL package
+_patch()
+
+
+# Inject
+
+def _make_unavailable_func(funcname):
+    def cb(*args, **kwargs):
+        raise RuntimeError('OpenGL API call "%s" is not available.' % funcname)
+    return cb
+
+
+def _get_function_from_pyopengl(funcname):
+    """Try getting the given function from PyOpenGL, return
+    a dummy function (that shows a warning when called) if it
+    could not be found.
+    """
+    func = None
+
+    # Get function from GL
+    try:
+        func = getattr(_GL, funcname)
+    except AttributeError:
+        # Get function from FBO
+        try:
+            func = getattr(_FBO, funcname)
+        except AttributeError:
+            func = None
+
+    # Try using "alias"
+    if not bool(func):
+        # Some functions are known by a slightly different name
+        # e.g. glDepthRangef, glClearDepthf
+        if funcname.endswith('f'):
+            try:
+                func = getattr(_GL, funcname[:-1])
+            except AttributeError:
+                pass
+
+    # Set dummy function if we could not find it
+    if func is None:
+        func = _make_unavailable_func(funcname)
+        logger.warning('warning: %s not available' % funcname)
+    return func
+
+
+def _inject():
+    """Copy functions from OpenGL.GL into _pyopengl namespace."""
+    NS = _pyopengl2.__dict__
+    for glname, ourname in _pyopengl2._functions_to_import:
+        func = _get_function_from_pyopengl(glname)
+        NS[ourname] = func
+
+
+from . import _pyopengl2  # noqa
+
+# Inject remaining functions from OpenGL.GL
+# copies name to _pyopengl2 namespace
+_inject()
+
+# Inject all function definitions in _pyopengl2
+_copy_gl_functions(_pyopengl2, globals())

vispy/gloo/gl/tests/test_basics.py

@@ -0,0 +1,282 @@
+"""Test to verify some basic functionality of our OpenGL API. We cover
+much more in the test_functionality. Together, these two tests should
+touch *all* ES 2.0 API calls.
+
+The only exception is glCompressedTexImage2D and glCompressedTexSubImage2D.
+"""
+
+import sys
+
+from vispy.app import Canvas
+from numpy.testing import assert_almost_equal
+from vispy.testing import (requires_application, requires_pyopengl, SkipTest,
+                           run_tests_if_main, assert_equal, assert_true)
+from vispy.util import use_log_level
+from vispy.gloo import gl
+
+
+def teardown_module():
+    gl.use_gl()  # Reset to default
+
+
+@requires_application()
+def test_basics_desktop():
+    """Test desktop GL backend for basic functionality."""
+    _test_basics('gl2')
+    with Canvas():
+        _test_setting_parameters()
+        _test_enabling_disabling()
+        _test_setting_stuff()
+        _test_object_creation_and_deletion()
+        _test_fbo()
+        try:
+            gl.gl2._get_gl_func('foo', None, ())
+        except RuntimeError as exp:
+            exp = str(exp)
+            assert 'version' in exp
+            assert 'unknown' not in exp
+        gl.glFinish()
+
+
+@requires_application()
+def test_functionality_proxy():
+    """Test GL proxy class for basic functionality."""
+    # By using debug mode, we are using the proxy class
+    _test_basics('gl2 debug')
+
+
+@requires_application()
+@requires_pyopengl()
+def test_basics_pypengl():
+    """Test pyopengl GL backend for basic functionality."""
+    _test_basics('pyopengl2')
+
+
+@requires_application()
+def test_functionality_es2():
+    """Test es2 GL backend for basic functionality."""
+    if True:
+        raise SkipTest('Skip es2 functionality test for now.')
+    if sys.platform.startswith('win'):
+        raise SkipTest('Can only test es2 functionality on Windows.')
+    _test_basics('es2')
+
+
+def _test_basics(backend):
+    """Create app and canvas so we have a context. Then run tests."""
+    # use the backend
+    with use_log_level('error', print_msg=False):
+        gl.use_gl(backend)  # pyopengl throws warning on injection
+
+    with Canvas():
+        _test_setting_parameters()
+        _test_enabling_disabling()
+        _test_setting_stuff()
+        _test_object_creation_and_deletion()
+        _test_fbo()
+        gl.glFinish()
+
+
+def _test_setting_parameters():
+    # Set some parameters and get result
+    clr = 1.0, 0.1, 0.2, 0.7
+    gl.glClearColor(*clr)
+    assert_almost_equal(gl.glGetParameter(gl.GL_COLOR_CLEAR_VALUE), clr)
+    #
+    gl.glCullFace(gl.GL_FRONT)
+    assert_equal(gl.glGetParameter(gl.GL_CULL_FACE_MODE), gl.GL_FRONT)
+    gl.glCullFace(gl.GL_BACK)
+    assert_equal(gl.glGetParameter(gl.GL_CULL_FACE_MODE), gl.GL_BACK)
+    #
+    gl.glDepthFunc(gl.GL_NOTEQUAL)
+    assert_equal(gl.glGetParameter(gl.GL_DEPTH_FUNC), gl.GL_NOTEQUAL)
+    #
+    val = 0.2, 0.3
+    gl.glDepthRange(*val)
+    assert_almost_equal(gl.glGetParameter(gl.GL_DEPTH_RANGE), val)
+
+    gl.check_error()
+
+
+def _test_enabling_disabling():
+    # Enabling/disabling
+    gl.glEnable(gl.GL_DEPTH_TEST)
+    assert_equal(gl.glIsEnabled(gl.GL_DEPTH_TEST), True)
+    assert_equal(gl.glGetParameter(gl.GL_DEPTH_TEST), 1)
+    gl.glDisable(gl.GL_DEPTH_TEST)
+    assert_equal(gl.glIsEnabled(gl.GL_DEPTH_TEST), False)
+    assert_equal(gl.glGetParameter(gl.GL_DEPTH_TEST), 0)
+    #
+    gl.glEnable(gl.GL_BLEND)
+    assert_equal(gl.glIsEnabled(gl.GL_BLEND), True)
+    assert_equal(gl.glGetParameter(gl.GL_BLEND), 1)
+    gl.glDisable(gl.GL_BLEND)
+    assert_equal(gl.glIsEnabled(gl.GL_BLEND), False)
+    assert_equal(gl.glGetParameter(gl.GL_BLEND), 0)
+
+    gl.check_error()
+
+
+def _test_setting_stuff():
+    # Set stuff to touch functions
+
+    gl.glClear(gl.GL_COLOR_BUFFER_BIT)
+    #
+    gl.glBlendColor(1.0, 1.0, 1.0, 1.0)
+    gl.glBlendEquation(gl.GL_FUNC_ADD)
+    gl.glBlendEquationSeparate(gl.GL_FUNC_ADD, gl.GL_FUNC_ADD)
+    gl.glBlendFunc(gl.GL_ONE, gl.GL_ZERO)
+    gl.glBlendFuncSeparate(gl.GL_ONE, gl.GL_ZERO, gl.GL_ONE, gl.GL_ZERO)
+    #
+    gl.glClearColor(0.0, 0.0, 0.0, 1.0)
+    gl.glClearDepth(1)
+    gl.glClearStencil(0)
+    #
+    gl.glColorMask(True, True, True, True)
+    gl.glDepthMask(False)
+    gl.glStencilMask(255)
+    gl.glStencilMaskSeparate(gl.GL_FRONT, 128)
+    #
+    gl.glStencilFunc(gl.GL_ALWAYS, 0, 255)
+    gl.glStencilFuncSeparate(gl.GL_FRONT, gl.GL_ALWAYS, 0, 255)
+    gl.glStencilOp(gl.GL_KEEP, gl.GL_KEEP, gl.GL_KEEP)
+    gl.glStencilOpSeparate(gl.GL_FRONT, gl.GL_KEEP, gl.GL_KEEP, gl.GL_KEEP)
+    #
+    gl.glFrontFace(gl.GL_CW)
+    gl.glHint(gl.GL_GENERATE_MIPMAP_HINT, gl.GL_FASTEST)
+    gl.glLineWidth(2.0)
+    gl.glPolygonOffset(0.0, 0.0)
+    gl.glSampleCoverage(1.0, False)
+
+    # And getting stuff
+    try:
+        with use_log_level('error', print_msg=False):
+            r, p = gl.glGetShaderPrecisionFormat(gl.GL_FRAGMENT_SHADER,
+                                                 gl.GL_HIGH_FLOAT)
+            gl.check_error()  # Sometimes the func is there but OpenGL errs
+    except Exception:
+        pass  # accept if the function is not there ...
+        # We should catch RuntimeError and GL.error.NullFunctionError,
+        # but PyOpenGL may not be available.
+        # On Travis this function was not there on one machine according
+        # to PyOpenGL, but our desktop backend worked fine ...
+
+    #
+    v = gl.glGetParameter(gl.GL_VERSION)
+    assert_true(isinstance(v, str))
+    assert_true(len(v) > 0)
+    gl.check_error()
+
+
+def _test_object_creation_and_deletion():
+
+    # Stuff that is originally glGenX
+
+    # Note that if we test glIsTexture(x), we cannot assume x to be a
+    # nonexisting texture; we might have created a texture in another
+    # test and failed to clean it up.
+
+    # Create/delete texture
+    # assert_equal(gl.glIsTexture(12), False)
+    handle = gl.glCreateTexture()
+    gl.glBindTexture(gl.GL_TEXTURE_2D, handle)
+    assert_equal(gl.glIsTexture(handle), True)
+    gl.glDeleteTexture(handle)
+    assert_equal(gl.glIsTexture(handle), False)
+
+    # Create/delete buffer
+    # assert_equal(gl.glIsBuffer(12), False)
+    handle = gl.glCreateBuffer()
+    gl.glBindBuffer(gl.GL_ARRAY_BUFFER, handle)
+    assert_equal(gl.glIsBuffer(handle), True)
+    gl.glDeleteBuffer(handle)
+    assert_equal(gl.glIsBuffer(handle), False)
+
+    # Create/delete framebuffer
+    # assert_equal(gl.glIsFramebuffer(12), False)
+    handle = gl.glCreateFramebuffer()
+    gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, handle)
+    assert_equal(gl.glIsFramebuffer(handle), True)
+    gl.glDeleteFramebuffer(handle)
+    assert_equal(gl.glIsFramebuffer(handle), False)
+
+    # Create/delete renderbuffer
+    # assert_equal(gl.glIsRenderbuffer(12), False)
+    handle = gl.glCreateRenderbuffer()
+    gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, handle)
+    assert_equal(gl.glIsRenderbuffer(handle), True)
+    gl.glDeleteRenderbuffer(handle)
+    assert_equal(gl.glIsRenderbuffer(handle), False)
+
+    # Stuff that is originally called glCreate
+
+    # Create/delete program
+    # assert_equal(gl.glIsProgram(12), False)
+    handle = gl.glCreateProgram()
+    assert_equal(gl.glIsProgram(handle), True)
+    gl.glDeleteProgram(handle)
+    assert_equal(gl.glIsProgram(handle), False)
+
+    # Create/delete shader
+    # assert_equal(gl.glIsShader(12), False)
+    handle = gl.glCreateShader(gl.GL_VERTEX_SHADER)
+    assert_equal(gl.glIsShader(handle), True)
+    gl.glDeleteShader(handle)
+    assert_equal(gl.glIsShader(handle), False)
+
+    gl.check_error()
+
+
+def _test_fbo():
+
+    w, h = 120, 130
+
+    # Create frame buffer
+    hframebuf = gl.glCreateFramebuffer()
+    gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, hframebuf)
+
+    # Create render buffer (for depth)
+    hrenderbuf = gl.glCreateRenderbuffer()
+    gl.glBindRenderbuffer(gl.GL_RENDERBUFFER, hrenderbuf)
+    gl.glRenderbufferStorage(gl.GL_RENDERBUFFER, gl.GL_DEPTH_COMPONENT16, w, h)
+    gl.glFramebufferRenderbuffer(gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT,
+                                 gl.GL_RENDERBUFFER, hrenderbuf)
+
+    # Create texture (for color)
+    htex = gl.glCreateTexture()
+    gl.glBindTexture(gl.GL_TEXTURE_2D, htex)
+    gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, gl.GL_RGB,
+                    gl.GL_UNSIGNED_BYTE, (h, w))
+    gl.glFramebufferTexture2D(gl.GL_FRAMEBUFFER, gl.GL_COLOR_ATTACHMENT0,
+                              gl.GL_TEXTURE_2D, htex, 0)
+
+    # Check framebuffer status
+    status = gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER)
+    assert_equal(status, gl.GL_FRAMEBUFFER_COMPLETE)
+
+    # Tests renderbuffer params
+    name = gl.glGetFramebufferAttachmentParameter(
+        gl.GL_FRAMEBUFFER, gl.GL_DEPTH_ATTACHMENT,
+        gl.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME)
+    assert_equal(name, hrenderbuf)
+    #
+    width = gl.glGetRenderbufferParameter(gl.GL_RENDERBUFFER,
+                                          gl.GL_RENDERBUFFER_WIDTH)
+    assert_equal(width, w)
+
+    # Touch copy tex functions
+    gl.glBindTexture(gl.GL_TEXTURE_2D, htex)
+    gl.glCopyTexSubImage2D(gl.GL_TEXTURE_2D, 0, 5, 5, 5, 5, 20, 20)
+    gl.glCopyTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGB, 0, 0, 30, 30, 0)
+
+    gl.check_error()
+
+    # Clean up
+    gl.glDeleteTexture(htex)
+    gl.glDeleteRenderbuffer(hrenderbuf)
+    gl.glDeleteFramebuffer(hframebuf)
+
+    gl.check_error()
+
+
+run_tests_if_main()