From decd88f67efab2e622cf6c81ec62b9d93bb8bd7a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cl=C3=A9ment=20Foucault?= Date: Mon, 16 Jun 2025 12:50:50 +0200 Subject: [PATCH] Python: Remove deprecated BGL API The API was in a deprecation state for many years now. This API was not compatible with Metal nor Vulkan. This also remove `Image.bindcode`. Pull Request: https://projects.blender.org/blender/blender/pulls/140370 --- doc/python_api/rst/bgl.rst | 1497 --------- doc/python_api/sphinx_doc_gen.py | 3 - scripts/modules/console_python.py | 2 +- scripts/modules/gpu_extras/presets.py | 10 +- source/blender/blenfont/intern/blf.cc | 6 - source/blender/blenkernel/BKE_global.hh | 7 - .../draw/engines/external/external_engine.cc | 3 - .../blender/editors/space_api/spacetypes.cc | 3 - source/blender/gpu/GPU_state.hh | 8 - source/blender/gpu/GPU_texture.hh | 7 - source/blender/gpu/intern/gpu_state.cc | 59 - source/blender/gpu/intern/gpu_texture.cc | 6 - source/blender/gpu/opengl/gl_debug.cc | 2 +- source/blender/makesrna/intern/rna_image.cc | 13 - .../blender/makesrna/intern/rna_wm_gizmo.cc | 4 - source/blender/python/generic/CMakeLists.txt | 2 - source/blender/python/generic/bgl.cc | 2727 ----------------- source/blender/python/generic/bgl.hh | 61 - source/blender/python/gpu/gpu_py_offscreen.cc | 28 - source/blender/python/intern/bpy.cc | 2 - source/blender/python/intern/bpy_interface.cc | 2 - .../blender/windowmanager/intern/wm_draw.cc | 3 - .../windowmanager/intern/wm_event_system.cc | 1 - .../blender/windowmanager/intern/wm_window.cc | 44 - .../windowmanager/intern/wm_window_private.hh | 1 - tests/python/bl_rst_completeness.py | 1 - 26 files changed, 3 insertions(+), 4499 deletions(-) delete mode 100644 doc/python_api/rst/bgl.rst delete mode 100644 source/blender/python/generic/bgl.cc delete mode 100644 source/blender/python/generic/bgl.hh diff --git a/doc/python_api/rst/bgl.rst b/doc/python_api/rst/bgl.rst deleted file mode 100644 index 2c9be7928fb..00000000000 --- a/doc/python_api/rst/bgl.rst +++ /dev/null @@ -1,1497 +0,0 @@ - -OpenGL Wrapper (bgl) -==================== - -.. module:: bgl - -.. warning:: - - This module is deprecated and will be removed in a future release, - when OpenGL is replaced by Metal and Vulkan. - Use the graphics API independent :mod:`gpu` module instead. - -This module wraps OpenGL constants and functions, making them available from -within Blender Python. - -The complete list can be retrieved from the module itself, by listing its -contents: dir(bgl). A simple search on the web can point to more -than enough material to teach OpenGL programming, from books to many -collections of tutorials. - -Here is a comprehensive `list of books `__ (non free). -`Learn OpenGL `__ is one of the best resources to learn modern OpenGL and -`opengl-tutorial.org `__ offers a set of extensive examples, -including advanced features. - - -.. note:: - - You can use the :class:`bpy.types.Image` type to load and set textures. - See :class:`bpy.types.Image.gl_load` and :class:`bpy.types.Image.gl_free`, - for example. - - -.. function:: glBindTexture(target, texture): - - Bind a named texture to a texturing target - - .. seealso:: `OpenGL Docs `__ - - :type target: Enumerated constant - :arg target: Specifies the target to which the texture is bound. - :type texture: unsigned int - :arg texture: Specifies the name of a texture. - - -.. function:: glBlendFunc(sfactor, dfactor): - - Specify pixel arithmetic - - .. seealso:: `OpenGL Docs `__ - - :type sfactor: Enumerated constant - :arg sfactor: Specifies how the red, green, blue, and alpha source blending factors are - computed. - :type dfactor: Enumerated constant - :arg dfactor: Specifies how the red, green, blue, and alpha destination - blending factors are computed. - - -.. function:: glClear(mask): - - Clear buffers to preset values - - .. seealso:: `OpenGL Docs `__ - - :type mask: Enumerated constant(s) - :arg mask: Bitwise OR of masks that indicate the buffers to be cleared. - - -.. function:: glClearColor(red, green, blue, alpha): - - Specify clear values for the color buffers - - .. seealso:: `OpenGL Docs `__ - - :type red, green, blue, alpha: float - :arg red, green, blue, alpha: Specify the red, green, blue, and alpha values used when the - color buffers are cleared. The initial values are all 0. - - -.. function:: glClearDepth(depth): - - Specify the clear value for the depth buffer - - .. seealso:: `OpenGL Docs `__ - - :type depth: int - :arg depth: Specifies the depth value used when the depth buffer is cleared. - The initial value is 1. - - -.. function:: glClearStencil(s): - - Specify the clear value for the stencil buffer - - .. seealso:: `OpenGL Docs `__ - - :type s: int - :arg s: Specifies the index used when the stencil buffer is cleared. The initial value is 0. - - -.. function:: glClipPlane (plane, equation): - - Specify a plane against which all geometry is clipped - - .. seealso:: `OpenGL Docs `__ - - :type plane: Enumerated constant - :arg plane: Specifies which clipping plane is being positioned. - :type equation: :class:`bgl.Buffer` object I{type GL_FLOAT}(double) - :arg equation: Specifies the address of an array of four double- precision - floating-point values. These values are interpreted as a plane equation. - - -.. function:: glColorMask(red, green, blue, alpha): - - Enable and disable writing of frame buffer color components - - .. seealso:: `OpenGL Docs `__ - - :type red, green, blue, alpha: int (boolean) - :arg red, green, blue, alpha: Specify whether red, green, blue, and alpha can or cannot be - written into the frame buffer. The initial values are all GL_TRUE, indicating that the - color components can be written. - - -.. function:: glCopyTexImage2D(target, level, internalformat, x, y, width, height, border): - - Copy pixels into a 2D texture image - - .. seealso:: `OpenGL Docs `__ - - :type target: Enumerated constant - :arg target: Specifies the target texture. - :type level: int - :arg level: Specifies the level-of-detail number. Level 0 is the base image level. - Level n is the nth mipmap reduction image. - :type internalformat: int - :arg internalformat: Specifies the number of color components in the texture. - :type width: int - :type x, y: int - :arg x, y: Specify the window coordinates of the first pixel that is copied - from the frame buffer. This location is the lower left corner of a rectangular - block of pixels. - :arg width: Specifies the width of the texture image. Must be 2n+2(border) for - some integer n. All implementations support texture images that are at least 64 - texels wide. - :type height: int - :arg height: Specifies the height of the texture image. Must be 2m+2(border) for - some integer m. All implementations support texture images that are at least 64 - texels high. - :type border: int - :arg border: Specifies the width of the border. Must be either 0 or 1. - - -.. function:: glCullFace(mode): - - Specify whether front- or back-facing facets can be culled - - .. seealso:: `OpenGL Docs `__ - - :type mode: Enumerated constant - :arg mode: Specifies whether front- or back-facing facets are candidates for culling. - - -.. function:: glDeleteTextures(n, textures): - - Delete named textures - - .. seealso:: `OpenGL Docs `__ - - :type n: int - :arg n: Specifies the number of textures to be deleted - :type textures: :class:`bgl.Buffer` I{GL_INT} - :arg textures: Specifies an array of textures to be deleted - - -.. function:: glDepthFunc(func): - - Specify the value used for depth buffer comparisons - - .. seealso:: `OpenGL Docs `__ - - :type func: Enumerated constant - :arg func: Specifies the depth comparison function. - - -.. function:: glDepthMask(flag): - - Enable or disable writing into the depth buffer - - .. seealso:: `OpenGL Docs `__ - - :type flag: int (boolean) - :arg flag: Specifies whether the depth buffer is enabled for writing. If flag is GL_FALSE, - depth buffer writing is disabled. Otherwise, it is enabled. Initially, depth buffer - writing is enabled. - - -.. function:: glDepthRange(zNear, zFar): - - Specify mapping of depth values from normalized device coordinates to window coordinates - - .. seealso:: `OpenGL Docs `__ - - :type zNear: int - :arg zNear: Specifies the mapping of the near clipping plane to window coordinates. - The initial value is 0. - :type zFar: int - :arg zFar: Specifies the mapping of the far clipping plane to window coordinates. - The initial value is 1. - - -.. function:: glDisable(cap): - - Disable server-side GL capabilities - - .. seealso:: `OpenGL Docs `__ - - :type cap: Enumerated constant - :arg cap: Specifies a symbolic constant indicating a GL capability. - - -.. function:: glDrawBuffer(mode): - - Specify which color buffers are to be drawn into - - .. seealso:: `OpenGL Docs `__ - - :type mode: Enumerated constant - :arg mode: Specifies up to four color buffers to be drawn into. - - -.. function:: glEdgeFlag (flag): - - B{glEdgeFlag, glEdgeFlagv} - - Flag edges as either boundary or non-boundary - - .. seealso:: `OpenGL Docs `__ - - :type flag: Depends of function prototype - :arg flag: Specifies the current edge flag value.The initial value is GL_TRUE. - - -.. function:: glEnable(cap): - - Enable server-side GL capabilities - - .. seealso:: `OpenGL Docs `__ - - :type cap: Enumerated constant - :arg cap: Specifies a symbolic constant indicating a GL capability. - - -.. function:: glEvalCoord (u,v): - - B{glEvalCoord1d, glEvalCoord1f, glEvalCoord2d, glEvalCoord2f, glEvalCoord1dv, glEvalCoord1fv, - glEvalCoord2dv, glEvalCoord2fv} - - Evaluate enabled one- and two-dimensional maps - - .. seealso:: `OpenGL Docs `__ - - :type u: Depends on function prototype. - :arg u: Specifies a value that is the domain coordinate u to the basis function defined - in a previous glMap1 or glMap2 command. If the function prototype ends in 'v' then - u specifies a pointer to an array containing either one or two domain coordinates. The first - coordinate is u. The second coordinate is v, which is present only in glEvalCoord2 versions. - :type v: Depends on function prototype. (only with '2' prototypes) - :arg v: Specifies a value that is the domain coordinate v to the basis function defined - in a previous glMap2 command. This argument is not present in a glEvalCoord1 command. - - -.. function:: glEvalMesh (mode, i1, i2): - - B{glEvalMesh1 or glEvalMesh2} - - Compute a one- or two-dimensional grid of points or lines - - .. seealso:: `OpenGL Docs `__ - - :type mode: Enumerated constant - :arg mode: In glEvalMesh1, specifies whether to compute a one-dimensional - mesh of points or lines. - :type i1, i2: int - :arg i1, i2: Specify the first and last integer values for the grid domain variable i. - - -.. function:: glEvalPoint (i, j): - - B{glEvalPoint1 and glEvalPoint2} - - Generate and evaluate a single point in a mesh - - .. seealso:: `OpenGL Docs `__ - - :type i: int - :arg i: Specifies the integer value for grid domain variable i. - :type j: int (only with '2' prototypes) - :arg j: Specifies the integer value for grid domain variable j (glEvalPoint2 only). - - -.. function:: glFeedbackBuffer (size, type, buffer): - - Controls feedback mode - - .. seealso:: `OpenGL Docs `__ - - :type size: int - :arg size: Specifies the maximum number of values that can be written into buffer. - :type type: Enumerated constant - :arg type: Specifies a symbolic constant that describes the information that - will be returned for each vertex. - :type buffer: :class:`bgl.Buffer` object I{GL_FLOAT} - :arg buffer: Returns the feedback data. - - -.. function:: glFinish(): - - Block until all GL execution is complete - - .. seealso:: `OpenGL Docs `__ - - -.. function:: glFlush(): - - Force Execution of GL commands in finite time - - .. seealso:: `OpenGL Docs `__ - - -.. function:: glFog (pname, param): - - B{glFogf, glFogi, glFogfv, glFogiv} - - Specify fog parameters - - .. seealso:: `OpenGL Docs `__ - - :type pname: Enumerated constant - :arg pname: Specifies a single-valued fog parameter. If the function prototype - ends in 'v' specifies a fog parameter. - :type param: Depends on function prototype. - :arg param: Specifies the value or values to be assigned to pname. GL_FOG_COLOR - requires an array of four values. All other parameters accept an array containing - only a single value. - - -.. function:: glFrontFace(mode): - - Define front- and back-facing polygons - - .. seealso:: `OpenGL Docs `__ - - :type mode: Enumerated constant - :arg mode: Specifies the orientation of front-facing polygons. - - -.. function:: glGenTextures(n, textures): - - Generate texture names - - .. seealso:: `OpenGL Docs `__ - - :type n: int - :arg n: Specifies the number of textures name to be generated. - :type textures: :class:`bgl.Buffer` object I{type GL_INT} - :arg textures: Specifies an array in which the generated textures names are stored. - - -.. function:: glGet (pname, param): - - B{glGetBooleanv, glGetfloatv, glGetFloatv, glGetIntegerv} - - Return the value or values of a selected parameter - - .. seealso:: `OpenGL Docs `__ - - :type pname: Enumerated constant - :arg pname: Specifies the parameter value to be returned. - :type param: Depends on function prototype. - :arg param: Returns the value or values of the specified parameter. - - -.. function:: glGetError(): - - Return error information - - .. seealso:: `OpenGL Docs `__ - - -.. function:: glGetLight (light, pname, params): - - B{glGetLightfv and glGetLightiv} - - Return light source parameter values - - .. seealso:: `OpenGL Docs `__ - - :type light: Enumerated constant - :arg light: Specifies a light source. The number of possible lights depends on the - implementation, but at least eight lights are supported. They are identified by symbolic - names of the form GL_LIGHTi where 0 < i < GL_MAX_LIGHTS. - :type pname: Enumerated constant - :arg pname: Specifies a light source parameter for light. - :type params: :class:`bgl.Buffer` object. Depends on function prototype. - :arg params: Returns the requested data. - - -.. function:: glGetMap (target, query, v): - - B{glGetMapdv, glGetMapfv, glGetMapiv} - - Return evaluator parameters - - .. seealso:: `OpenGL Docs `__ - - :type target: Enumerated constant - :arg target: Specifies the symbolic name of a map. - :type query: Enumerated constant - :arg query: Specifies which parameter to return. - :type v: :class:`bgl.Buffer` object. Depends on function prototype. - :arg v: Returns the requested data. - - -.. function:: glGetMaterial (face, pname, params): - - B{glGetMaterialfv, glGetMaterialiv} - - Return material parameters - - .. seealso:: `OpenGL Docs `__ - - :type face: Enumerated constant - :arg face: Specifies which of the two materials is being queried. - representing the front and back materials, respectively. - :type pname: Enumerated constant - :arg pname: Specifies the material parameter to return. - :type params: :class:`bgl.Buffer` object. Depends on function prototype. - :arg params: Returns the requested data. - - -.. function:: glGetPixelMap (map, values): - - B{glGetPixelMapfv, glGetPixelMapuiv, glGetPixelMapusv} - - Return the specified pixel map - - .. seealso:: `OpenGL Docs `__ - - :type map: Enumerated constant - :arg map: Specifies the name of the pixel map to return. - :type values: :class:`bgl.Buffer` object. Depends on function prototype. - :arg values: Returns the pixel map contents. - - -.. function:: glGetString(name): - - Return a string describing the current GL connection - - .. seealso:: `OpenGL Docs `__ - - :type name: Enumerated constant - :arg name: Specifies a symbolic constant. - - - -.. function:: glGetTexEnv (target, pname, params): - - B{glGetTexEnvfv, glGetTexEnviv} - - Return texture environment parameters - - .. seealso:: `OpenGL Docs `__ - - :type target: Enumerated constant - :arg target: Specifies a texture environment. Must be GL_TEXTURE_ENV. - :type pname: Enumerated constant - :arg pname: Specifies the symbolic name of a texture environment parameter. - :type params: :class:`bgl.Buffer` object. Depends on function prototype. - :arg params: Returns the requested data. - - -.. function:: glGetTexGen (coord, pname, params): - - B{glGetTexGendv, glGetTexGenfv, glGetTexGeniv} - - Return texture coordinate generation parameters - - .. seealso:: `OpenGL Docs `__ - - :type coord: Enumerated constant - :arg coord: Specifies a texture coordinate. - :type pname: Enumerated constant - :arg pname: Specifies the symbolic name of the value(s) to be returned. - :type params: :class:`bgl.Buffer` object. Depends on function prototype. - :arg params: Returns the requested data. - - -.. function:: glGetTexImage(target, level, format, type, pixels): - - Return a texture image - - .. seealso:: `OpenGL Docs `__ - - :type target: Enumerated constant - :arg target: Specifies which texture is to be obtained. - :type level: int - :arg level: Specifies the level-of-detail number of the desired image. - Level 0 is the base image level. Level n is the nth mipmap reduction image. - :type format: Enumerated constant - :arg format: Specifies a pixel format for the returned data. - :type type: Enumerated constant - :arg type: Specifies a pixel type for the returned data. - :type pixels: :class:`bgl.Buffer` object. - :arg pixels: Returns the texture image. Should be a pointer to an array of the - type specified by type - - -.. function:: glGetTexLevelParameter (target, level, pname, params): - - B{glGetTexLevelParameterfv, glGetTexLevelParameteriv} - - return texture parameter values for a specific level of detail - - .. seealso:: `OpenGL Docs `__ - - :type target: Enumerated constant - :arg target: Specifies the symbolic name of the target texture. - :type level: int - :arg level: Specifies the level-of-detail number of the desired image. - Level 0 is the base image level. Level n is the nth mipmap reduction image. - :type pname: Enumerated constant - :arg pname: Specifies the symbolic name of a texture parameter. - :type params: :class:`bgl.Buffer` object. Depends on function prototype. - :arg params: Returns the requested data. - - -.. function:: glGetTexParameter (target, pname, params): - - B{glGetTexParameterfv, glGetTexParameteriv} - - Return texture parameter values - - .. seealso:: `OpenGL Docs `__ - - :type target: Enumerated constant - :arg target: Specifies the symbolic name of the target texture. - :type pname: Enumerated constant - :arg pname: Specifies the symbolic name the target texture. - :type params: :class:`bgl.Buffer` object. Depends on function prototype. - :arg params: Returns the texture parameters. - - -.. function:: glHint(target, mode): - - Specify implementation-specific hints - - .. seealso:: `OpenGL Docs `__ - - :type target: Enumerated constant - :arg target: Specifies a symbolic constant indicating the behavior to be - controlled. - :type mode: Enumerated constant - :arg mode: Specifies a symbolic constant indicating the desired behavior. - - -.. function:: glIsEnabled(cap): - - Test whether a capability is enabled - - .. seealso:: `OpenGL Docs `__ - - :type cap: Enumerated constant - :arg cap: Specifies a constant representing a GL capability. - - -.. function:: glIsTexture(texture): - - Determine if a name corresponds to a texture - - .. seealso:: `OpenGL Docs `__ - - :type texture: unsigned int - :arg texture: Specifies a value that may be the name of a texture. - - -.. function:: glLight (light, pname, param): - - B{glLightf,glLighti, glLightfv, glLightiv} - - Set the light source parameters - - .. seealso:: `OpenGL Docs `__ - - :type light: Enumerated constant - :arg light: Specifies a light. The number of lights depends on the implementation, - but at least eight lights are supported. They are identified by symbolic names of the - form GL_LIGHTi where 0 < i < GL_MAX_LIGHTS. - :type pname: Enumerated constant - :arg pname: Specifies a single-valued light source parameter for light. - :type param: Depends on function prototype. - :arg param: Specifies the value that parameter pname of light source light will be set to. - If function prototype ends in 'v' specifies a pointer to the value or values that - parameter pname of light source light will be set to. - - -.. function:: glLightModel (pname, param): - - B{glLightModelf, glLightModeli, glLightModelfv, glLightModeliv} - - Set the lighting model parameters - - .. seealso:: `OpenGL Docs `__ - - :type pname: Enumerated constant - :arg pname: Specifies a single-value light model parameter. - :type param: Depends on function prototype. - :arg param: Specifies the value that param will be set to. If function prototype ends in 'v' - specifies a pointer to the value or values that param will be set to. - - -.. function:: glLineWidth(width): - - Specify the width of rasterized lines. - - .. seealso:: `OpenGL Docs `__ - - :type width: float - :arg width: Specifies the width of rasterized lines. The initial value is 1. - - -.. function:: glLoadMatrix (m): - - B{glLoadMatrixd, glLoadMatixf} - - Replace the current matrix with the specified matrix - - .. seealso:: `OpenGL Docs `__ - - :type m: :class:`bgl.Buffer` object. Depends on function prototype. - :arg m: Specifies a pointer to 16 consecutive values, which are used as the elements - of a 4x4 column-major matrix. - - -.. function:: glLogicOp(opcode): - - Specify a logical pixel operation for color index rendering - - .. seealso:: `OpenGL Docs `__ - - :type opcode: Enumerated constant - :arg opcode: Specifies a symbolic constant that selects a logical operation. - - -.. function:: glMap1 (target, u1, u2, stride, order, points): - - B{glMap1d, glMap1f} - - Define a one-dimensional evaluator - - .. seealso:: `OpenGL Docs `__ - - :type target: Enumerated constant - :arg target: Specifies the kind of values that are generated by the evaluator. - :type u1, u2: Depends on function prototype. - :arg u1,u2: Specify a linear mapping of u, as presented to glEvalCoord1, to ^, t - he variable that is evaluated by the equations specified by this command. - :type stride: int - :arg stride: Specifies the number of floats or float (double)s between the beginning - of one control point and the beginning of the next one in the data structure - referenced in points. This allows control points to be embedded in arbitrary data - structures. The only constraint is that the values for a particular control point must - occupy contiguous memory locations. - :type order: int - :arg order: Specifies the number of control points. Must be positive. - :type points: :class:`bgl.Buffer` object. Depends on function prototype. - :arg points: Specifies a pointer to the array of control points. - - -.. function:: glMap2 (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points): - - B{glMap2d, glMap2f} - - Define a two-dimensional evaluator - - .. seealso:: `OpenGL Docs `__ - - :type target: Enumerated constant - :arg target: Specifies the kind of values that are generated by the evaluator. - :type u1, u2: Depends on function prototype. - :arg u1,u2: Specify a linear mapping of u, as presented to glEvalCoord2, to ^, t - he variable that is evaluated by the equations specified by this command. Initially - u1 is 0 and u2 is 1. - :type ustride: int - :arg ustride: Specifies the number of floats or float (double)s between the beginning - of control point R and the beginning of control point R ij, where i and j are the u - and v control point indices, respectively. This allows control points to be embedded - in arbitrary data structures. The only constraint is that the values for a particular - control point must occupy contiguous memory locations. The initial value of ustride is 0. - :type uorder: int - :arg uorder: Specifies the dimension of the control point array in the u axis. - Must be positive. The initial value is 1. - :type v1, v2: Depends on function prototype. - :arg v1, v2: Specify a linear mapping of v, as presented to glEvalCoord2, - to ^, one of the two variables that are evaluated by the equations - specified by this command. Initially, v1 is 0 and v2 is 1. - :type vstride: int - :arg vstride: Specifies the number of floats or float (double)s between the - beginning of control point R and the beginning of control point R ij, - where i and j are the u and v control point(indices, respectively. - This allows control points to be embedded in arbitrary data structures. - The only constraint is that the values for a particular control point must - occupy contiguous memory locations. The initial value of vstride is 0. - :type vorder: int - :arg vorder: Specifies the dimension of the control point array in the v axis. - Must be positive. The initial value is 1. - :type points: :class:`bgl.Buffer` object. Depends on function prototype. - :arg points: Specifies a pointer to the array of control points. - - -.. function:: glMapGrid (un, u1,u2 ,vn, v1, v2): - - B{glMapGrid1d, glMapGrid1f, glMapGrid2d, glMapGrid2f} - - Define a one- or two-dimensional mesh - - .. seealso:: `OpenGL Docs `__ - - :type un: int - :arg un: Specifies the number of partitions in the grid range interval - [u1, u2]. Must be positive. - :type u1, u2: Depends on function prototype. - :arg u1, u2: Specify the mappings for integer grid domain values i=0 and i=un. - :type vn: int - :arg vn: Specifies the number of partitions in the grid range interval - [v1, v2] (glMapGrid2 only). - :type v1, v2: Depends on function prototype. - :arg v1, v2: Specify the mappings for integer grid domain values j=0 and j=vn - (glMapGrid2 only). - - -.. function:: glMaterial (face, pname, params): - - Specify material parameters for the lighting model. - - .. seealso:: `OpenGL Docs `__ - - :type face: Enumerated constant - :arg face: Specifies which face or faces are being updated. Must be one of: - :type pname: Enumerated constant - :arg pname: Specifies the single-valued material parameter of the face - or faces that is being updated. Must be GL_SHININESS. - :type params: int - :arg params: Specifies the value that parameter GL_SHININESS will be set to. - If function prototype ends in 'v' specifies a pointer to the value or values that - pname will be set to. - - -.. function:: glMultMatrix (m): - - B{glMultMatrixd, glMultMatrixf} - - Multiply the current matrix with the specified matrix - - .. seealso:: `OpenGL Docs `__ - - :type m: :class:`bgl.Buffer` object. Depends on function prototype. - :arg m: Points to 16 consecutive values that are used as the elements of a 4x4 column - major matrix. - - -.. function:: glNormal3 (nx, ny, nz, v): - - B{Normal3b, Normal3bv, Normal3d, Normal3dv, Normal3f, Normal3fv, Normal3i, Normal3iv, - Normal3s, Normal3sv} - - Set the current normal vector - - .. seealso:: `OpenGL Docs `__ - - :type nx, ny, nz: Depends on function prototype. (non - 'v' prototypes only) - :arg nx, ny, nz: Specify the x, y, and z coordinates of the new current normal. - The initial value of the current normal is the unit vector, (0, 0, 1). - :type v: :class:`bgl.Buffer` object. Depends on function prototype. ('v' prototypes) - :arg v: Specifies a pointer to an array of three elements: the x, y, and z coordinates - of the new current normal. - - -.. function:: glPixelMap (map, mapsize, values): - - B{glPixelMapfv, glPixelMapuiv, glPixelMapusv} - - Set up pixel transfer maps - - .. seealso:: `OpenGL Docs `__ - - :type map: Enumerated constant - :arg map: Specifies a symbolic map name. - :type mapsize: int - :arg mapsize: Specifies the size of the map being defined. - :type values: :class:`bgl.Buffer` object. Depends on function prototype. - :arg values: Specifies an array of mapsize values. - - -.. function:: glPixelStore (pname, param): - - B{glPixelStoref, glPixelStorei} - - Set pixel storage modes - - .. seealso:: `OpenGL Docs `__ - - :type pname: Enumerated constant - :arg pname: Specifies the symbolic name of the parameter to be set. - Six values affect the packing of pixel data into memory. - Six more affect the unpacking of pixel data from memory. - :type param: Depends on function prototype. - :arg param: Specifies the value that pname is set to. - - -.. function:: glPixelTransfer (pname, param): - - B{glPixelTransferf, glPixelTransferi} - - Set pixel transfer modes - - .. seealso:: `OpenGL Docs `__ - - :type pname: Enumerated constant - :arg pname: Specifies the symbolic name of the pixel transfer parameter to be set. - :type param: Depends on function prototype. - :arg param: Specifies the value that pname is set to. - - -.. function:: glPointSize(size): - - Specify the diameter of rasterized points - - .. seealso:: `OpenGL Docs `__ - - :type size: float - :arg size: Specifies the diameter of rasterized points. The initial value is 1. - - -.. function:: glPolygonMode(face, mode): - - Select a polygon rasterization mode - - .. seealso:: `OpenGL Docs `__ - - :type face: Enumerated constant - :arg face: Specifies the polygons that mode applies to. - Must be GL_FRONT for front-facing polygons, GL_BACK for back- facing - polygons, or GL_FRONT_AND_BACK for front- and back-facing polygons. - :type mode: Enumerated constant - :arg mode: Specifies how polygons will be rasterized. - The initial value is GL_FILL for both front- and back- facing polygons. - - -.. function:: glPolygonOffset(factor, units): - - Set the scale and units used to calculate depth values - - .. seealso:: `OpenGL Docs `__ - - :type factor: float - :arg factor: Specifies a scale factor that is used to create a variable depth - offset for each polygon. The initial value is 0. - :type units: float - :arg units: Is multiplied by an implementation-specific value to create a - constant depth offset. The initial value is 0. - - -.. function:: glRasterPos (x,y,z,w): - - B{glRasterPos2d, glRasterPos2f, glRasterPos2i, glRasterPos2s, glRasterPos3d, - glRasterPos3f, glRasterPos3i, glRasterPos3s, glRasterPos4d, glRasterPos4f, - glRasterPos4i, glRasterPos4s, glRasterPos2dv, glRasterPos2fv, glRasterPos2iv, - glRasterPos2sv, glRasterPos3dv, glRasterPos3fv, glRasterPos3iv, glRasterPos3sv, - glRasterPos4dv, glRasterPos4fv, glRasterPos4iv, glRasterPos4sv} - - Specify the raster position for pixel operations - - .. seealso:: `OpenGL Docs `__ - - :type x, y, z, w: Depends on function prototype. (z and w for '3' and '4' prototypes only) - :arg x, y, z, w: Specify the x,y,z, and w object coordinates (if present) for the - raster position. If function prototype ends in 'v' specifies a pointer to an array of two, - three, or four elements, specifying x, y, z, and w coordinates, respectively. - - .. note:: - - If you are drawing to the 3d view with a Scriptlink of a space handler - the zoom level of the panels will scale the glRasterPos by the view matrix. - so a X of 10 will not always offset 10 pixels as you would expect. - - To work around this get the scale value of the view matrix and use it to scale your pixel values. - - .. code-block:: python - - import bgl - xval, yval= 100, 40 - # Get the scale of the view matrix. - view_matrix = bgl.Buffer(bgl.GL_FLOAT, 16) - bgl.glGetFloatv(bgl.GL_MODELVIEW_MATRIX, view_matrix) - f = 1.0 / view_matrix[0] - - # Instead of the usual `glRasterPos2i(xval, yval)`. - bgl.glRasterPos2f(xval * f, yval * f) - - -.. function:: glReadBuffer(mode): - - Select a color buffer source for pixels. - - .. seealso:: `OpenGL Docs `__ - - :type mode: Enumerated constant - :arg mode: Specifies a color buffer. - - -.. function:: glReadPixels(x, y, width, height, format, type, pixels): - - Read a block of pixels from the frame buffer - - .. seealso:: `OpenGL Docs `__ - - :type x, y: int - :arg x, y: Specify the window coordinates of the first pixel that is read - from the frame buffer. This location is the lower left corner of a rectangular - block of pixels. - :type width, height: int - :arg width, height: Specify the dimensions of the pixel rectangle. width and - height of one correspond to a single pixel. - :type format: Enumerated constant - :arg format: Specifies the format of the pixel data. - :type type: Enumerated constant - :arg type: Specifies the data type of the pixel data. - :type pixels: :class:`bgl.Buffer` object - :arg pixels: Returns the pixel data. - - -.. function:: glRect (x1,y1,x2,y2,v1,v2): - - B{glRectd, glRectf, glRecti, glRects, glRectdv, glRectfv, glRectiv, glRectsv} - - Draw a rectangle - - .. seealso:: `OpenGL Docs `__ - - :type x1, y1: Depends on function prototype. (for non 'v' prototypes only) - :arg x1, y1: Specify one vertex of a rectangle - :type x2, y2: Depends on function prototype. (for non 'v' prototypes only) - :arg x2, y2: Specify the opposite vertex of the rectangle - :type v1, v2: Depends on function prototype. (for 'v' prototypes only) - :arg v1, v2: Specifies a pointer to one vertex of a rectangle and the pointer - to the opposite vertex of the rectangle - - -.. function:: glRotate (angle, x, y, z): - - B{glRotated, glRotatef} - - Multiply the current matrix by a rotation matrix - - .. seealso:: `OpenGL Docs `__ - - :type angle: Depends on function prototype. - :arg angle: Specifies the angle of rotation in degrees. - :type x, y, z: Depends on function prototype. - :arg x, y, z: Specify the x, y, and z coordinates of a vector respectively. - - -.. function:: glScale (x,y,z): - - B{glScaled, glScalef} - - Multiply the current matrix by a general scaling matrix - - .. seealso:: `OpenGL Docs `__ - - :type x, y, z: Depends on function prototype. - :arg x, y, z: Specify scale factors along the x, y, and z axes, respectively. - - -.. function:: glScissor(x,y,width,height): - - Define the scissor box - - .. seealso:: `OpenGL Docs `__ - - :type x, y: int - :arg x, y: Specify the lower left corner of the scissor box. Initially (0, 0). - :type width, height: int - :arg width height: Specify the width and height of the scissor box. When a - GL context is first attached to a window, width and height are set to the - dimensions of that window. - - -.. function:: glStencilFunc(func, ref, mask): - - Set function and reference value for stencil testing - - .. seealso:: `OpenGL Docs `__ - - :type func: Enumerated constant - :arg func: Specifies the test function. - :type ref: int - :arg ref: Specifies the reference value for the stencil test. ref is clamped - to the range [0,2n-1], where n is the number of bitplanes in the stencil - buffer. The initial value is 0. - :type mask: unsigned int - :arg mask: Specifies a mask that is ANDed with both the reference value and - the stored stencil value when the test is done. The initial value is all 1's. - - -.. function:: glStencilMask(mask): - - Control the writing of individual bits in the stencil planes - - .. seealso:: `OpenGL Docs `__ - - :type mask: unsigned int - :arg mask: Specifies a bit mask to enable and disable writing of individual bits - in the stencil planes. Initially, the mask is all 1's. - - -.. function:: glStencilOp(fail, zfail, zpass): - - Set stencil test actions - - .. seealso:: `OpenGL Docs `__ - - :type fail: Enumerated constant - :arg fail: Specifies the action to take when the stencil test fails. - The initial value is GL_KEEP. - :type zfail: Enumerated constant - :arg zfail: Specifies the stencil action when the stencil test passes, but the - depth test fails. zfail accepts the same symbolic constants as fail. - The initial value is GL_KEEP. - :type zpass: Enumerated constant - :arg zpass: Specifies the stencil action when both the stencil test and the - depth test pass, or when the stencil test passes and either there is no - depth buffer or depth testing is not enabled. zpass accepts the same - symbolic constants - as fail. The initial value is GL_KEEP. - - -.. function:: glTexCoord (s,t,r,q,v): - - B{glTexCoord1d, glTexCoord1f, glTexCoord1i, glTexCoord1s, glTexCoord2d, glTexCoord2f, - glTexCoord2i, glTexCoord2s, glTexCoord3d, glTexCoord3f, glTexCoord3i, glTexCoord3s, - glTexCoord4d, glTexCoord4f, glTexCoord4i, glTexCoord4s, glTexCoord1dv, glTexCoord1fv, - glTexCoord1iv, glTexCoord1sv, glTexCoord2dv, glTexCoord2fv, glTexCoord2iv, - glTexCoord2sv, glTexCoord3dv, glTexCoord3fv, glTexCoord3iv, glTexCoord3sv, - glTexCoord4dv, glTexCoord4fv, glTexCoord4iv, glTexCoord4sv} - - Set the current texture coordinates - - .. seealso:: `OpenGL Docs `__ - - :type s, t, r, q: Depends on function prototype. (r and q for '3' and '4' prototypes only) - :arg s, t, r, q: Specify s, t, r, and q texture coordinates. Not all parameters are - present in all forms of the command. - :type v: :class:`bgl.Buffer` object. Depends on function prototype. (for 'v' prototypes only) - :arg v: Specifies a pointer to an array of one, two, three, or four elements, - which in turn specify the s, t, r, and q texture coordinates. - - -.. function:: glTexEnv (target, pname, param): - - B{glTextEnvf, glTextEnvi, glTextEnvfv, glTextEnviv} - - Set texture environment parameters - - .. seealso:: `OpenGL Docs `__ - - :type target: Enumerated constant - :arg target: Specifies a texture environment. Must be GL_TEXTURE_ENV. - :type pname: Enumerated constant - :arg pname: Specifies the symbolic name of a single-valued texture environment - parameter. Must be GL_TEXTURE_ENV_MODE. - :type param: Depends on function prototype. - :arg param: Specifies a single symbolic constant. If function prototype ends in 'v' - specifies a pointer to a parameter array that contains either a single - symbolic constant or an RGBA color - - -.. function:: glTexGen (coord, pname, param): - - B{glTexGend, glTexGenf, glTexGeni, glTexGendv, glTexGenfv, glTexGeniv} - - Control the generation of texture coordinates - - .. seealso:: `OpenGL Docs `__ - - :type coord: Enumerated constant - :arg coord: Specifies a texture coordinate. - :type pname: Enumerated constant - :arg pname: Specifies the symbolic name of the texture- coordinate generation function. - :type param: Depends on function prototype. - :arg param: Specifies a single-valued texture generation parameter. - If function prototype ends in 'v' specifies a pointer to an array of texture - generation parameters. If pname is GL_TEXTURE_GEN_MODE, then the array must - contain a single symbolic constant. Otherwise, params holds the coefficients - for the texture-coordinate generation function specified by pname. - - -.. function:: glTexImage1D(target, level, internalformat, width, border, format, type, pixels): - - Specify a one-dimensional texture image - - .. seealso:: `OpenGL Docs `__ - - :type target: Enumerated constant - :arg target: Specifies the target texture. - :type level: int - :arg level: Specifies the level-of-detail number. Level 0 is the base image level. - Level n is the nth mipmap reduction image. - :type internalformat: int - :arg internalformat: Specifies the number of color components in the texture. - :type width: int - :arg width: Specifies the width of the texture image. Must be 2n+2(border) - for some integer n. All implementations support texture images that are - at least 64 texels wide. The height of the 1D texture image is 1. - :type border: int - :arg border: Specifies the width of the border. Must be either 0 or 1. - :type format: Enumerated constant - :arg format: Specifies the format of the pixel data. - :type type: Enumerated constant - :arg type: Specifies the data type of the pixel data. - :type pixels: :class:`bgl.Buffer` object. - :arg pixels: Specifies a pointer to the image data in memory. - - -.. function:: glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels): - - Specify a two-dimensional texture image - - .. seealso:: `OpenGL Docs `__ - - :type target: Enumerated constant - :arg target: Specifies the target texture. - :type level: int - :arg level: Specifies the level-of-detail number. Level 0 is the base image level. - Level n is the nth mipmap reduction image. - :type internalformat: int - :arg internalformat: Specifies the number of color components in the texture. - :type width: int - :arg width: Specifies the width of the texture image. Must be 2n+2(border) - for some integer n. All implementations support texture images that are at - least 64 texels wide. - :type height: int - :arg height: Specifies the height of the texture image. Must be 2m+2(border) for - some integer m. All implementations support texture images that are at - least 64 texels high. - :type border: int - :arg border: Specifies the width of the border. Must be either 0 or 1. - :type format: Enumerated constant - :arg format: Specifies the format of the pixel data. - :type type: Enumerated constant - :arg type: Specifies the data type of the pixel data. - :type pixels: :class:`bgl.Buffer` object. - :arg pixels: Specifies a pointer to the image data in memory. - - -.. function:: glTexParameter (target, pname, param): - - B{glTexParameterf, glTexParameteri, glTexParameterfv, glTexParameteriv} - - Set texture parameters - - .. seealso:: `OpenGL Docs `__ - - :type target: Enumerated constant - :arg target: Specifies the target texture. - :type pname: Enumerated constant - :arg pname: Specifies the symbolic name of a single-valued texture parameter. - :type param: Depends on function prototype. - :arg param: Specifies the value of pname. If function prototype ends in 'v' specifies - a pointer to an array where the value or values of pname are stored. - - -.. function:: glTranslate (x, y, z): - - B{glTranslatef, glTranslated} - - Multiply the current matrix by a translation matrix - - .. seealso:: `OpenGL Docs `__ - - :type x, y, z: Depends on function prototype. - :arg x, y, z: Specify the x, y, and z coordinates of a translation vector. - - -.. function:: glViewport(x,y,width,height): - - Set the viewport - - .. seealso:: `OpenGL Docs `__ - - :type x, y: int - :arg x, y: Specify the lower left corner of the viewport rectangle, - in pixels. The initial value is (0,0). - :type width, height: int - :arg width, height: Specify the width and height of the viewport. When a GL - context is first attached to a window, width and height are set to the - dimensions of that window. - - -.. function:: glUseProgram(program): - - Installs a program object as part of current rendering state - - .. seealso:: `OpenGL Docs `__ - - :type program: int - :arg program: Specifies the handle of the program object whose executables are to be used as part of current rendering state. - - -.. function:: glValidateProgram(program): - - Validates a program object - - .. seealso:: `OpenGL Docs `__ - - :type program: int - :arg program: Specifies the handle of the program object to be validated. - - -.. function:: glLinkProgram(program): - - Links a program object. - - .. seealso:: `OpenGL Docs `__ - - :type program: int - :arg program: Specifies the handle of the program object to be linked. - - -.. function:: glActiveTexture(texture): - - Select active texture unit. - - .. seealso:: `OpenGL Docs `__ - - :type texture: int - :arg texture: Constant in ``GL_TEXTURE0`` 0 - 8 - - -.. function:: glAttachShader(program, shader): - - Attaches a shader object to a program object. - - .. seealso:: `OpenGL Docs `__ - - :type program: int - :arg program: Specifies the program object to which a shader object will be attached. - :type shader: int - :arg shader: Specifies the shader object that is to be attached. - - -.. function:: glCompileShader(shader): - - Compiles a shader object. - - .. seealso:: `OpenGL Docs `__ - - :type shader: int - :arg shader: Specifies the shader object to be compiled. - - -.. function:: glCreateProgram(): - - Creates a program object - - .. seealso:: `OpenGL Docs `__ - - :rtype: int - :return: The new program or zero if an error occurs. - - -.. function:: glCreateShader(shaderType): - - Creates a shader object. - - .. seealso:: `OpenGL Docs `__ - - :type shaderType: Specifies the type of shader to be created. - Must be one of ``GL_VERTEX_SHADER``, - ``GL_TESS_CONTROL_SHADER``, - ``GL_TESS_EVALUATION_SHADER``, - ``GL_GEOMETRY_SHADER``, - or ``GL_FRAGMENT_SHADER``. - :arg shaderType: - :rtype: int - :return: 0 if an error occurs. - - -.. function:: glDeleteProgram(program): - - Deletes a program object. - - .. seealso:: `OpenGL Docs `__ - - :type program: int - :arg program: Specifies the program object to be deleted. - - -.. function:: glDeleteShader(shader): - - Deletes a shader object. - - .. seealso:: `OpenGL Docs `__ - - :type shader: int - :arg shader: Specifies the shader object to be deleted. - - -.. function:: glDetachShader(program, shader): - - Detaches a shader object from a program object to which it is attached. - - .. seealso:: `OpenGL Docs `__ - - :type program: int - :arg program: Specifies the program object from which to detach the shader object. - :type shader: int - :arg shader: pecifies the program object from which to detach the shader object. - - -.. function:: glGetAttachedShaders(program, maxCount, count, shaders): - - Returns the handles of the shader objects attached to a program object. - - .. seealso:: `OpenGL Docs `__ - - :type program: int - :arg program: Specifies the program object to be queried. - :type maxCount: int - :arg maxCount: Specifies the size of the array for storing the returned object names. - :type count: :class:`bgl.Buffer` int buffer. - :arg count: Returns the number of names actually returned in objects. - :type shaders: :class:`bgl.Buffer` int buffer. - :arg shaders: Specifies an array that is used to return the names of attached shader objects. - - -.. function:: glGetProgramInfoLog(program, maxLength, length, infoLog): - - Returns the information log for a program object. - - .. seealso:: `OpenGL Docs `__ - - :type program: int - :arg program: Specifies the program object whose information log is to be queried. - :type maxLength: int - :arg maxLength: Specifies the size of the character buffer for storing the returned information log. - :type length: :class:`bgl.Buffer` int buffer. - :arg length: Returns the length of the string returned in **infoLog** (excluding the null terminator). - :type infoLog: :class:`bgl.Buffer` char buffer. - :arg infoLog: Specifies an array of characters that is used to return the information log. - - -.. function:: glGetShaderInfoLog(program, maxLength, length, infoLog): - - Returns the information log for a shader object. - - .. seealso:: `OpenGL Docs `__ - - :type shader: int - :arg shader: Specifies the shader object whose information log is to be queried. - :type maxLength: int - :arg maxLength: Specifies the size of the character buffer for storing the returned information log. - :type length: :class:`bgl.Buffer` int buffer. - :arg length: Returns the length of the string returned in **infoLog** (excluding the null terminator). - :type infoLog: :class:`bgl.Buffer` char buffer. - :arg infoLog: Specifies an array of characters that is used to return the information log. - - -.. function:: glGetProgramiv(program, pname, params): - - Returns a parameter from a program object. - - .. seealso:: `OpenGL Docs `__ - - :type program: int - :arg program: Specifies the program object to be queried. - :type pname: int - :arg pname: Specifies the object parameter. - :type params: :class:`bgl.Buffer` int buffer. - :arg params: Returns the requested object parameter. - - -.. function:: glIsShader(shader): - - Determines if a name corresponds to a shader object. - - .. seealso:: `OpenGL Docs `__ - - :type shader: int - :arg shader: Specifies a potential shader object. - - -.. function:: glIsProgram(program): - - Determines if a name corresponds to a program object - - .. seealso:: `OpenGL Docs `__ - - :type program: int - :arg program: Specifies a potential program object. - - -.. function:: glGetShaderSource(shader, bufSize, length, source): - - Returns the source code string from a shader object - - .. seealso:: `OpenGL Docs `__ - - :type shader: int - :arg shader: Specifies the shader object to be queried. - :type bufSize: int - :arg bufSize: Specifies the size of the character buffer for storing the returned source code string. - :type length: :class:`bgl.Buffer` int buffer. - :arg length: Returns the length of the string returned in source (excluding the null terminator). - :type source: :class:`bgl.Buffer` char. - :arg source: Specifies an array of characters that is used to return the source code string. - - -.. function:: glShaderSource(shader, shader_string): - - Replaces the source code in a shader object. - - .. seealso:: `OpenGL Docs `__ - - :type shader: int - :arg shader: Specifies the handle of the shader object whose source code is to be replaced. - :type shader_string: string - :arg shader_string: The shader string. - - -.. class:: Buffer - - The Buffer object is simply a block of memory that is delineated and initialized by the - user. Many OpenGL functions return data to a C-style pointer, however, because this - is not possible in python the Buffer object can be used to this end. Wherever pointer - notation is used in the OpenGL functions the Buffer object can be used in it's bgl - wrapper. In some instances the Buffer object will need to be initialized with the template - parameter, while in other instances the user will want to create just a blank buffer - which will be zeroed by default. - - .. code-block:: python - - import bgl - - myByteBuffer = bgl.Buffer(bgl.GL_BYTE, [32, 32]) - bgl.glGetPolygonStipple(myByteBuffer) - - print(myByteBuffer.dimensions) - print(myByteBuffer.to_list()) - - sliceBuffer = myByteBuffer[0:16] - print(sliceBuffer) - - .. attribute:: dimensions - - The number of dimensions of the Buffer. - - .. method:: to_list() - - The contents of the Buffer as a python list. - - .. method:: __init__(type, dimensions, template = None): - - This will create a new Buffer object for use with other bgl OpenGL commands. - Only the type of argument to store in the buffer and the dimensions of the buffer - are necessary. Buffers are zeroed by default unless a template is supplied, in - which case the buffer is initialized to the template. - - :type type: int - :arg type: The format to store data in. The type should be one of - GL_BYTE, GL_SHORT, GL_INT, or GL_FLOAT. - :type dimensions: An int or sequence object specifying the dimensions of the buffer. - :arg dimensions: If the dimensions are specified as an int a linear array will - be created for the buffer. If a sequence is passed for the dimensions, the buffer - becomes n-Dimensional, where n is equal to the number of parameters passed in the - sequence. Example: [256,2] is a two- dimensional buffer while [256,256,4] creates - a three- dimensional buffer. You can think of each additional dimension as a sub-item - of the dimension to the left. i.e. [10,2] is a 10 element array each with 2 sub-items. - [(0,0), (0,1), (1,0), (1,1), (2,0), ...] etc. - :type template: A python sequence object (optional) - :arg template: A sequence of matching dimensions which will be used to initialize - the Buffer. If a template is not passed in all fields will be initialized to 0. - :rtype: Buffer object - :return: The newly created buffer as a PyObject. diff --git a/doc/python_api/sphinx_doc_gen.py b/doc/python_api/sphinx_doc_gen.py index 363b835b5cf..dc0e7b9b98e 100644 --- a/doc/python_api/sphinx_doc_gen.py +++ b/doc/python_api/sphinx_doc_gen.py @@ -267,7 +267,6 @@ else: EXCLUDE_INFO_DOCS = True EXCLUDE_MODULES = [ "aud", - "bgl", "blf", "bl_math", "imbuf", @@ -2033,7 +2032,6 @@ def write_rst_index(basepath): standalone_modules = ( # Sub-modules are added in parent page. "aud", - "bgl", "bl_math", "blf", "bmesh", @@ -2364,7 +2362,6 @@ def copy_handwritten_rsts(basepath): # TODO: put this docs in Blender's code and use import as per modules above. handwritten_modules = [ - "bgl", # "Blender OpenGl wrapper" "bmesh.ops", # Generated by `rst_from_bmesh_opdefines.py`. # Includes. diff --git a/scripts/modules/console_python.py b/scripts/modules/console_python.py index 6e4d2e7a43f..18ce6915909 100644 --- a/scripts/modules/console_python.py +++ b/scripts/modules/console_python.py @@ -350,7 +350,7 @@ def banner(context): "PYTHON INTERACTIVE CONSOLE {:s}".format(version_string), "", "Builtin Modules: " - "bpy, bpy.data, bpy.ops, bpy.props, bpy.types, bpy.context, bpy.utils, bgl, gpu, blf, mathutils", + "bpy, bpy.data, bpy.ops, bpy.props, bpy.types, bpy.context, bpy.utils, gpu, blf, mathutils", "Convenience Imports: from mathutils import *; from math import *", "Convenience Variables: C = bpy.context, D = bpy.data", diff --git a/scripts/modules/gpu_extras/presets.py b/scripts/modules/gpu_extras/presets.py index 6b9da4ab19c..b4d3a0375bb 100644 --- a/scripts/modules/gpu_extras/presets.py +++ b/scripts/modules/gpu_extras/presets.py @@ -89,14 +89,6 @@ def draw_texture_2d(texture, position, width, height): gpu.matrix.scale((width, height)) shader = gpu.shader.from_builtin('IMAGE') - - if isinstance(texture, int): - # Call the legacy bgl to not break the existing API - import bgl - bgl.glActiveTexture(bgl.GL_TEXTURE0) - bgl.glBindTexture(bgl.GL_TEXTURE_2D, texture) - shader.uniform_int("image", 0) - else: - shader.uniform_sampler("image", texture) + shader.uniform_sampler("image", texture) batch.draw(shader) diff --git a/source/blender/blenfont/intern/blf.cc b/source/blender/blenfont/intern/blf.cc index cd76fd88604..76213986ce0 100644 --- a/source/blender/blenfont/intern/blf.cc +++ b/source/blender/blenfont/intern/blf.cc @@ -590,10 +590,6 @@ void BLF_draw(int fontid, const char *str, const size_t str_len, ResultBLF *r_in FontBLF *font = blf_get(fontid); if (font) { - - /* Avoid bgl usage to corrupt BLF drawing. */ - GPU_bgl_end(); - blf_draw_gpu__start(font); if (font->flags & BLF_WORD_WRAP) { blf_font_draw__wrap(font, str, str_len, r_info); @@ -635,8 +631,6 @@ void BLF_draw_svg_icon(uint icon_id, #ifndef WITH_HEADLESS FontBLF *font = global_font[0]; if (font) { - /* Avoid bgl usage to corrupt BLF drawing. */ - GPU_bgl_end(); blf_draw_gpu__start(font); blf_draw_svg_icon(font, icon_id, x, y, size, color, outline_alpha, multicolor, edit_source_cb); blf_draw_gpu__end(font); diff --git a/source/blender/blenkernel/BKE_global.hh b/source/blender/blenkernel/BKE_global.hh index 73dfd41e06b..48929485aea 100644 --- a/source/blender/blenkernel/BKE_global.hh +++ b/source/blender/blenkernel/BKE_global.hh @@ -173,13 +173,6 @@ struct Global { */ char autoexec_fail[200]; - /** - * Has there been an opengl deprecation call detected when running on a none OpenGL backend. - */ - bool opengl_deprecation_usage_detected; - const char *opengl_deprecation_usage_filename; - int opengl_deprecation_usage_lineno; - /** * Triggers a GPU capture if the name matches a DebugScope. * Set using `--debug-gpu-scope-capture "debug_scope"`. diff --git a/source/blender/draw/engines/external/external_engine.cc b/source/blender/draw/engines/external/external_engine.cc index a08f567e3a5..a3f60b67446 100644 --- a/source/blender/draw/engines/external/external_engine.cc +++ b/source/blender/draw/engines/external/external_engine.cc @@ -259,8 +259,6 @@ class Instance : public DrawEngine { const RenderEngineType *type = render_engine->type; type->view_draw(render_engine, draw_ctx->evil_C, draw_ctx->depsgraph); - GPU_bgl_end(); - GPU_matrix_pop(); GPU_matrix_pop_projection(); @@ -362,7 +360,6 @@ class Instance : public DrawEngine { GPU_matrix_pop_projection(); blender::draw::command::StateSet::set(); - GPU_bgl_end(); RE_engine_draw_release(re); } diff --git a/source/blender/editors/space_api/spacetypes.cc b/source/blender/editors/space_api/spacetypes.cc index b2b9dfc412a..bb62a58f277 100644 --- a/source/blender/editors/space_api/spacetypes.cc +++ b/source/blender/editors/space_api/spacetypes.cc @@ -263,9 +263,6 @@ static void ed_region_draw_cb_draw(const bContext *C, ARegion *region, ARegionTy LISTBASE_FOREACH_MUTABLE (RegionDrawCB *, rdc, &art->drawcalls) { if (rdc->type == type) { rdc->draw(C, region, rdc->customdata); - - /* This is needed until we get rid of BGL which can change the states we are tracking. */ - GPU_bgl_end(); } } } diff --git a/source/blender/gpu/GPU_state.hh b/source/blender/gpu/GPU_state.hh index d2864d6ef58..787a3a7f00c 100644 --- a/source/blender/gpu/GPU_state.hh +++ b/source/blender/gpu/GPU_state.hh @@ -215,14 +215,6 @@ void GPU_flush(); void GPU_finish(); void GPU_apply_state(); -void GPU_bgl_start(); - -/** - * Just turn off the `bgl` safeguard system. Can be called even without #GPU_bgl_start. - */ -void GPU_bgl_end(); -bool GPU_bgl_get(); - /** * A barrier _must_ be issued _after_ a shader arbitrary write to a buffer or a * texture (i.e: using imageStore, imageAtomics, or SSBO). Otherwise, the written value may not diff --git a/source/blender/gpu/GPU_texture.hh b/source/blender/gpu/GPU_texture.hh index 1483193d6b6..9348812a16a 100644 --- a/source/blender/gpu/GPU_texture.hh +++ b/source/blender/gpu/GPU_texture.hh @@ -1272,13 +1272,6 @@ void **GPU_texture_py_reference_get(GPUTexture *texture); void GPU_texture_py_reference_set(GPUTexture *texture, void **py_ref); #endif -/** - * Return the backend handle of the texture. - * \note This is a legacy feature only working on OpenGL backend. It will be removed once we remove - * the python BGL module. - */ -int GPU_texture_opengl_bindcode(const GPUTexture *texture); - /** \} */ /* -------------------------------------------------------------------- */ diff --git a/source/blender/gpu/intern/gpu_state.cc b/source/blender/gpu/intern/gpu_state.cc index 959a98c2111..92e6715fcc0 100644 --- a/source/blender/gpu/intern/gpu_state.cc +++ b/source/blender/gpu/intern/gpu_state.cc @@ -319,65 +319,6 @@ void GPU_apply_state() /** \} */ -/* -------------------------------------------------------------------- */ -/** \name BGL workaround - * - * bgl makes direct GL calls that makes our state tracking out of date. - * This flag make it so that the pyGPU calls will not override the state set by - * bgl functions. - * \{ */ - -void GPU_bgl_start() -{ - Context *ctx = Context::get(); - if (!(ctx && ctx->state_manager)) { - return; - } - StateManager &state_manager = *(Context::get()->state_manager); - if (state_manager.use_bgl == false) { - /* Expected by many addons (see #80169, #81289). - * This will reset the blend function. */ - GPU_blend(GPU_BLEND_NONE); - - /* Equivalent of setting the depth func `glDepthFunc(GL_LEQUAL)` - * Needed since Python scripts may enable depth test. - * Without this block the depth test function is undefined. */ - { - eGPUDepthTest depth_test_real = GPU_depth_test_get(); - eGPUDepthTest depth_test_temp = GPU_DEPTH_LESS_EQUAL; - if (depth_test_real != depth_test_temp) { - GPU_depth_test(depth_test_temp); - state_manager.apply_state(); - GPU_depth_test(depth_test_real); - } - } - - state_manager.apply_state(); - state_manager.use_bgl = true; - } -} - -void GPU_bgl_end() -{ - Context *ctx = Context::get(); - if (!(ctx && ctx->state_manager)) { - return; - } - StateManager &state_manager = *ctx->state_manager; - if (state_manager.use_bgl == true) { - state_manager.use_bgl = false; - /* Resync state tracking. */ - state_manager.force_state(); - } -} - -bool GPU_bgl_get() -{ - return Context::get()->state_manager->use_bgl; -} - -/** \} */ - /* -------------------------------------------------------------------- */ /** \name Synchronization Utils * \{ */ diff --git a/source/blender/gpu/intern/gpu_texture.cc b/source/blender/gpu/intern/gpu_texture.cc index 68ed0bf4dc4..6823a984fec 100644 --- a/source/blender/gpu/intern/gpu_texture.cc +++ b/source/blender/gpu/intern/gpu_texture.cc @@ -946,12 +946,6 @@ void GPU_texture_py_reference_set(GPUTexture *texture, void **py_ref) } #endif -/* TODO: remove. */ -int GPU_texture_opengl_bindcode(const GPUTexture *texture) -{ - return unwrap(texture)->gl_bindcode_get(); -} - void GPU_texture_get_mipmap_size(GPUTexture *texture, int mip_level, int *r_size) { unwrap(texture)->mip_size_get(mip_level, r_size); diff --git a/source/blender/gpu/opengl/gl_debug.cc b/source/blender/gpu/opengl/gl_debug.cc index 7a9a2711aaf..4d1dac7b32a 100644 --- a/source/blender/gpu/opengl/gl_debug.cc +++ b/source/blender/gpu/opengl/gl_debug.cc @@ -215,7 +215,7 @@ void check_gl_error(const char *info) void check_gl_resources(const char *info) { - if (!(G.debug & G_DEBUG_GPU) || GPU_bgl_get()) { + if (!(G.debug & G_DEBUG_GPU)) { return; } diff --git a/source/blender/makesrna/intern/rna_image.cc b/source/blender/makesrna/intern/rna_image.cc index e56115fe82e..f62edfc6ab1 100644 --- a/source/blender/makesrna/intern/rna_image.cc +++ b/source/blender/makesrna/intern/rna_image.cc @@ -556,13 +556,6 @@ static void rna_Image_resolution_set(PointerRNA *ptr, const float *values) BKE_image_release_ibuf(im, ibuf, lock); } -static int rna_Image_bindcode_get(PointerRNA *ptr) -{ - Image *ima = (Image *)ptr->data; - GPUTexture *tex = ima->gputexture[TEXTARGET_2D][0]; - return (tex) ? GPU_texture_opengl_bindcode(tex) : 0; -} - static int rna_Image_depth_get(PointerRNA *ptr) { Image *im = (Image *)ptr->data; @@ -1296,12 +1289,6 @@ static void rna_def_image(BlenderRNA *brna) prop, "Display Aspect", "Display Aspect for this image, does not affect rendering"); RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, nullptr); - prop = RNA_def_property(srna, "bindcode", PROP_INT, PROP_UNSIGNED); - RNA_def_property_int_funcs(prop, "rna_Image_bindcode_get", nullptr, nullptr); - RNA_def_property_clear_flag(prop, PROP_EDITABLE); - RNA_def_property_ui_text(prop, "Bindcode", "OpenGL bindcode"); - RNA_def_property_update(prop, NC_IMAGE | ND_DISPLAY, nullptr); - prop = RNA_def_property(srna, "render_slots", PROP_COLLECTION, PROP_NONE); RNA_def_property_struct_type(prop, "RenderSlot"); RNA_def_property_collection_sdna(prop, nullptr, "renderslots", nullptr); diff --git a/source/blender/makesrna/intern/rna_wm_gizmo.cc b/source/blender/makesrna/intern/rna_wm_gizmo.cc index 725c645585e..2a1df289d1a 100644 --- a/source/blender/makesrna/intern/rna_wm_gizmo.cc +++ b/source/blender/makesrna/intern/rna_wm_gizmo.cc @@ -66,8 +66,6 @@ static void rna_gizmo_draw_cb(const bContext *C, wmGizmo *gz) RNA_parameter_set_lookup(&list, "context", &C); gzgroup->type->rna_ext.call((bContext *)C, &gz_ptr, func, &list); RNA_parameter_list_free(&list); - /* This callback may have called bgl functions. */ - GPU_bgl_end(); } static void rna_gizmo_draw_select_cb(const bContext *C, wmGizmo *gz, int select_id) @@ -84,8 +82,6 @@ static void rna_gizmo_draw_select_cb(const bContext *C, wmGizmo *gz, int select_ RNA_parameter_set_lookup(&list, "select_id", &select_id); gzgroup->type->rna_ext.call((bContext *)C, &gz_ptr, func, &list); RNA_parameter_list_free(&list); - /* This callback may have called bgl functions. */ - GPU_bgl_end(); } static int rna_gizmo_test_select_cb(bContext *C, wmGizmo *gz, const int location[2]) diff --git a/source/blender/python/generic/CMakeLists.txt b/source/blender/python/generic/CMakeLists.txt index 5cf1f8d8b5e..0daa887c937 100644 --- a/source/blender/python/generic/CMakeLists.txt +++ b/source/blender/python/generic/CMakeLists.txt @@ -12,7 +12,6 @@ set(INC_SYS ) set(SRC - bgl.cc bl_math_py_api.cc blf_py_api.cc bpy_threads.cc @@ -22,7 +21,6 @@ set(SRC py_capi_rna.cc py_capi_utils.cc - bgl.hh bl_math_py_api.hh blf_py_api.hh idprop_py_api.hh diff --git a/source/blender/python/generic/bgl.cc b/source/blender/python/generic/bgl.cc deleted file mode 100644 index d3d3e919d0c..00000000000 --- a/source/blender/python/generic/bgl.cc +++ /dev/null @@ -1,2727 +0,0 @@ -/* SPDX-FileCopyrightText: 2023 Blender Authors - * - * SPDX-License-Identifier: GPL-2.0-or-later */ - -/** \file - * \ingroup pygen - * - * This file is the 'bgl' module which wraps OpenGL functions and constants, - * allowing script writers to make OpenGL calls in their Python scripts. - * - * \note - * This module is very similar to 'PyOpenGL' which could replace 'bgl' one day. - */ - -#include - -#include "BLI_utildefines.h" - -#include "MEM_guardedalloc.h" - -#include "GPU_context.hh" - -#include "py_capi_utils.hh" - -#include - -#include - -#include "CLG_log.h" - -/* Forward declare API's defines here. */ -#define USE_BGL_DEPRECATED_API -#include "bgl.hh" /* Own include. */ -#undef USE_BGL_DEPRECATED_API - -static CLG_LogRef LOG = {"bgl"}; - -/* -------------------------------------------------------------------- */ -/** \name Local utility defines for wrapping OpenGL - * \{ */ - -#ifdef WITH_OPENGL_BACKEND -static void report_deprecated_call(const char *function_name) -{ - /* Only report first 10 deprecated calls. BGL is typically used inside an handler that is - * triggered at refresh. */ - static int times = 0; - while (times >= 10) { - return; - } - char message[256]; - SNPRINTF(message, - "'bgl.gl%s' is deprecated and will not work on all platforms. Report or update your " - "script to use 'gpu' module.", - function_name); - CLOG_WARN(&LOG, "%s", message); - PyErr_WarnEx(PyExc_DeprecationWarning, message, 1); - times++; -} - -static void report_deprecated_call_to_user() -{ - /* Only report the first deprecated usage. */ - if (G.opengl_deprecation_usage_detected) { - return; - } - G.opengl_deprecation_usage_detected = true; - PyC_FileAndNum(&G.opengl_deprecation_usage_filename, &G.opengl_deprecation_usage_lineno); -} -#endif - -/** \} */ - -/* -------------------------------------------------------------------- */ -/** \name Local utility defines for wrapping OpenGL - * \{ */ - -/* By golly George! It looks like fancy pants macro time! */ - -/* TYPE_str is the string to pass to Py_ArgParse (for the format) */ -/* TYPE_var is the name to pass to the GL function */ -/* TYPE_ref is the pointer to pass to Py_ArgParse (to store in) */ -/* TYPE_def is the C initialization of the variable */ - -#define void_str "" -#define void_var(num) -#define void_ref(num) &bgl_var##num -#define void_def(num) char bgl_var##num - -#if 0 -# define buffer_str "O!" -# define buffer_var(number) (bgl_buffer##number)->buf.asvoid -# define buffer_ref(number) &BGL_bufferType, &bgl_buffer##number -# define buffer_def(number) Buffer *bgl_buffer##number -#endif - -/* GL Pointer fields, handled by buffer type */ -/* GLdoubleP, GLfloatP, GLintP, GLuintP, GLshortP, GLsizeiP, GLcharP */ - -#define GLbooleanP_str "O!" -#define GLbooleanP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLbooleanP_ref(number) &BGL_bufferType, &bgl_buffer##number -#define GLbooleanP_def(number) Buffer *bgl_buffer##number - -#define GLbyteP_str "O!" -#define GLbyteP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLbyteP_ref(number) &BGL_bufferType, &bgl_buffer##number -#define GLbyteP_def(number) Buffer *bgl_buffer##number - -#define GLubyteP_str "O!" -#define GLubyteP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLubyteP_ref(number) &BGL_bufferType, &bgl_buffer##number -#define GLubyteP_def(number) Buffer *bgl_buffer##number - -#define GLintP_str "O!" -#define GLintP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLintP_ref(number) &BGL_bufferType, &bgl_buffer##number -#define GLintP_def(number) Buffer *bgl_buffer##number - -#define GLint64P_str "O!" -#define GLint64P_var(number) (bgl_buffer##number)->buf.asvoid -#define GLint64P_ref(number) &BGL_bufferType, &bgl_buffer##number -#define GLint64P_def(number) Buffer *bgl_buffer##number - -#define GLenumP_str "O!" -#define GLenumP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLenumP_ref(number) &BGL_bufferType, &bgl_buffer##number -#define GLenumP_def(number) Buffer *bgl_buffer##number - -#define GLuintP_str "O!" -#define GLuintP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLuintP_ref(number) &BGL_bufferType, &bgl_buffer##number -#define GLuintP_def(number) Buffer *bgl_buffer##number - -#if 0 -# define GLuint64P_str "O!" -# define GLuint64P_var(number) (bgl_buffer##number)->buf.asvoid -# define GLuint64P_ref(number) &BGL_bufferType, &bgl_buffer##number -# define GLuint64P_def(number) Buffer *bgl_buffer##number -#endif - -#define GLshortP_str "O!" -#define GLshortP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLshortP_ref(number) &BGL_bufferType, &bgl_buffer##number -#define GLshortP_def(number) Buffer *bgl_buffer##number - -#define GLushortP_str "O!" -#define GLushortP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLushortP_ref(number) &BGL_bufferType, &bgl_buffer##number -#define GLushortP_def(number) Buffer *bgl_buffer##number - -#define GLfloatP_str "O!" -#define GLfloatP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLfloatP_ref(number) &BGL_bufferType, &bgl_buffer##number -#define GLfloatP_def(number) Buffer *bgl_buffer##number - -#define GLdoubleP_str "O!" -#define GLdoubleP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLdoubleP_ref(number) &BGL_bufferType, &bgl_buffer##number -#define GLdoubleP_def(number) Buffer *bgl_buffer##number - -#if 0 -# define GLclampfP_str "O!" -# define GLclampfP_var(number) (bgl_buffer##number)->buf.asvoid -# define GLclampfP_ref(number) &BGL_bufferType, &bgl_buffer##number -# define GLclampfP_def(number) Buffer *bgl_buffer##number -#endif - -struct BufferOrOffset { - Buffer *buffer; - void *offset; -}; - -#define GLvoidP_str "O&" -#define GLvoidP_var(number) \ - ((bgl_buffer##number.buffer) ? (bgl_buffer##number.buffer)->buf.asvoid : \ - (bgl_buffer##number.offset)) -#define GLvoidP_ref(number) BGL_BufferOrOffsetConverter, &bgl_buffer##number -#define GLvoidP_def(number) BufferOrOffset bgl_buffer##number - -#define GLsizeiP_str "O!" -#define GLsizeiP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLsizeiP_ref(number) &BGL_bufferType, &bgl_buffer##number -#define GLsizeiP_def(number) Buffer *bgl_buffer##number - -#define GLcharP_str "O!" -#define GLcharP_var(number) (bgl_buffer##number)->buf.asvoid -#define GLcharP_ref(number) &BGL_bufferType, &bgl_buffer##number -#define GLcharP_def(number) Buffer *bgl_buffer##number - -#if 0 -# define buffer_str "O!" -# define buffer_var(number) (bgl_buffer##number)->buf.asvoid -# define buffer_ref(number) &BGL_bufferType, &bgl_buffer##number -# define buffer_def(number) Buffer *bgl_buffer##number -#endif - -/* The standard GL typedefs are used as prototypes, we can't - * use the GL type directly because Py_ArgParse expects normal - * C types. - * - * Py_ArgParse doesn't grok writing into unsigned variables, - * so we use signed everything (even stuff that should be unsigned. - */ - -/* Type: `typedef uint GLenum`. */ -#define GLenum_str "i" -#define GLenum_var(num) bgl_var##num -#define GLenum_ref(num) &bgl_var##num -#define GLenum_def(num) /*unsigned*/ int GLenum_var(num) - -/* Type: `typedef uint GLboolean`. */ -#define GLboolean_str "b" -#define GLboolean_var(num) bgl_var##num -#define GLboolean_ref(num) &bgl_var##num -#define GLboolean_def(num) /*unsigned*/ char GLboolean_var(num) - -/* Type: `typedef uint GLbitfield`. */ -#define GLbitfield_str "i" -#define GLbitfield_var(num) bgl_var##num -#define GLbitfield_ref(num) &bgl_var##num -#define GLbitfield_def(num) /*unsigned*/ int GLbitfield_var(num) - -#if 0 -/* Type: `typedef signed char GLbyte`. */ -# define GLbyte_str "b" -# define GLbyte_var(num) bgl_var##num -# define GLbyte_ref(num) &bgl_var##num -# define GLbyte_def(num) signed char GLbyte_var(num) -#endif - -/* Type: `typedef short GLshort`. */ -#define GLshort_str "h" -#define GLshort_var(num) bgl_var##num -#define GLshort_ref(num) &bgl_var##num -#define GLshort_def(num) short GLshort_var(num) - -/* Type: `typedef int GLint`. */ -#define GLint_str "i" -#define GLint_var(num) bgl_var##num -#define GLint_ref(num) &bgl_var##num -#define GLint_def(num) int GLint_var(num) - -/* Type: `typedef int GLsizei`. */ -#define GLsizei_str "n" -#define GLsizei_var(num) bgl_var##num -#define GLsizei_ref(num) &bgl_var##num -#define GLsizei_def(num) size_t GLsizei_var(num) - -/* Type: `typedef int GLsizeiptr`. */ -#define GLsizeiptr_str "n" -#define GLsizeiptr_var(num) bgl_var##num -#define GLsizeiptr_ref(num) &bgl_var##num -#define GLsizeiptr_def(num) size_t GLsizeiptr_var(num) - -/* Type: `typedef int GLintptr`. */ -#define GLintptr_str "n" -#define GLintptr_var(num) bgl_var##num -#define GLintptr_ref(num) &bgl_var##num -#define GLintptr_def(num) size_t GLintptr_var(num) - -/* Type: `typedef uchar GLubyte`. */ -#define GLubyte_str "B" -#define GLubyte_var(num) bgl_var##num -#define GLubyte_ref(num) &bgl_var##num -#define GLubyte_def(num) /*unsigned*/ char GLubyte_var(num) - -#if 0 -/* Type: `typedef ushort GLushort`. */ -# define GLushort_str "H" -# define GLushort_var(num) bgl_var##num -# define GLushort_ref(num) &bgl_var##num -# define GLushort_def(num) /*unsigned*/ short GLushort_var(num) -#endif - -/* Type: `typedef uint GLuint`. */ -#define GLuint_str "I" -#define GLuint_var(num) bgl_var##num -#define GLuint_ref(num) &bgl_var##num -#define GLuint_def(num) /*unsigned*/ int GLuint_var(num) - -/* Type: `typedef uint GLuint64`. */ -#if 0 -# define GLuint64_str "Q" -# define GLuint64_var(num) bgl_var##num -# define GLuint64_ref(num) &bgl_var##num -# define GLuint64_def(num) /*unsigned*/ int GLuint64_var(num) -#endif - -/* Type: `typedef uint GLsync`. */ -#if 0 -# define GLsync_str "I" -# define GLsync_var(num) bgl_var##num -# define GLsync_ref(num) &bgl_var##num -# define GLsync_def(num) /*unsigned*/ int GLsync_var(num) -#endif - -/* Type: `typedef float GLfloat`. */ -#define GLfloat_str "f" -#define GLfloat_var(num) bgl_var##num -#define GLfloat_ref(num) &bgl_var##num -#define GLfloat_def(num) float GLfloat_var(num) - -/* Type: `typedef char *GLstring`. */ -#define GLstring_str "s" -#define GLstring_var(number) bgl_var##number -#define GLstring_ref(number) &bgl_var##number -#define GLstring_def(number) char *GLstring_var(number) - -/* Type: `typedef float GLclampf`. */ -#if 0 -# define GLclampf_str "f" -# define GLclampf_var(num) bgl_var##num -# define GLclampf_ref(num) &bgl_var##num -# define GLclampf_def(num) float GLclampf_var(num) -#endif - -/* Type: `typedef double GLdouble`. */ -#define GLdouble_str "d" -#define GLdouble_var(num) bgl_var##num -#define GLdouble_ref(num) &bgl_var##num -#define GLdouble_def(num) double GLdouble_var(num) - -/* Type: `typedef double GLclampd`. */ -#if 0 -# define GLclampd_str "d" -# define GLclampd_var(num) bgl_var##num -# define GLclampd_ref(num) &bgl_var##num -# define GLclampd_def(num) double GLclampd_var(num) -#endif - -#define _arg_def1(a1) a1##_def(1) -#define _arg_def2(a1, a2) \ - _arg_def1(a1); \ - a2##_def(2) -#define _arg_def3(a1, a2, a3) \ - _arg_def2(a1, a2); \ - a3##_def(3) -#define _arg_def4(a1, a2, a3, a4) \ - _arg_def3(a1, a2, a3); \ - a4##_def(4) -#define _arg_def5(a1, a2, a3, a4, a5) \ - _arg_def4(a1, a2, a3, a4); \ - a5##_def(5) -#define _arg_def6(a1, a2, a3, a4, a5, a6) \ - _arg_def5(a1, a2, a3, a4, a5); \ - a6##_def(6) -#define _arg_def7(a1, a2, a3, a4, a5, a6, a7) \ - _arg_def6(a1, a2, a3, a4, a5, a6); \ - a7##_def(7) -#define _arg_def8(a1, a2, a3, a4, a5, a6, a7, a8) \ - _arg_def7(a1, a2, a3, a4, a5, a6, a7); \ - a8##_def(8) -#define _arg_def9(a1, a2, a3, a4, a5, a6, a7, a8, a9) \ - _arg_def8(a1, a2, a3, a4, a5, a6, a7, a8); \ - a9##_def(9) -#define _arg_def10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) \ - _arg_def9(a1, a2, a3, a4, a5, a6, a7, a8, a9); \ - a10##_def(10) -#define _arg_def11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \ - _arg_def10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); \ - a11##_def(11) -#define arg_def(...) VA_NARGS_CALL_OVERLOAD(_arg_def, __VA_ARGS__) - -#define _arg_var1(a1) a1##_var(1) -#define _arg_var2(a1, a2) _arg_var1(a1), a2##_var(2) -#define _arg_var3(a1, a2, a3) _arg_var2(a1, a2), a3##_var(3) -#define _arg_var4(a1, a2, a3, a4) _arg_var3(a1, a2, a3), a4##_var(4) -#define _arg_var5(a1, a2, a3, a4, a5) _arg_var4(a1, a2, a3, a4), a5##_var(5) -#define _arg_var6(a1, a2, a3, a4, a5, a6) _arg_var5(a1, a2, a3, a4, a5), a6##_var(6) -#define _arg_var7(a1, a2, a3, a4, a5, a6, a7) _arg_var6(a1, a2, a3, a4, a5, a6), a7##_var(7) -#define _arg_var8(a1, a2, a3, a4, a5, a6, a7, a8) \ - _arg_var7(a1, a2, a3, a4, a5, a6, a7), a8##_var(8) -#define _arg_var9(a1, a2, a3, a4, a5, a6, a7, a8, a9) \ - _arg_var8(a1, a2, a3, a4, a5, a6, a7, a8), a9##_var(9) -#define _arg_var10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) \ - _arg_var9(a1, a2, a3, a4, a5, a6, a7, a8, a9), a10##_var(10) -#define _arg_var11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \ - _arg_var10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10), a11##_var(11) -#define arg_var(...) VA_NARGS_CALL_OVERLOAD(_arg_var, __VA_ARGS__) - -#define _arg_ref1(a1) a1##_ref(1) -#define _arg_ref2(a1, a2) _arg_ref1(a1), a2##_ref(2) -#define _arg_ref3(a1, a2, a3) _arg_ref2(a1, a2), a3##_ref(3) -#define _arg_ref4(a1, a2, a3, a4) _arg_ref3(a1, a2, a3), a4##_ref(4) -#define _arg_ref5(a1, a2, a3, a4, a5) _arg_ref4(a1, a2, a3, a4), a5##_ref(5) -#define _arg_ref6(a1, a2, a3, a4, a5, a6) _arg_ref5(a1, a2, a3, a4, a5), a6##_ref(6) -#define _arg_ref7(a1, a2, a3, a4, a5, a6, a7) _arg_ref6(a1, a2, a3, a4, a5, a6), a7##_ref(7) -#define _arg_ref8(a1, a2, a3, a4, a5, a6, a7, a8) \ - _arg_ref7(a1, a2, a3, a4, a5, a6, a7), a8##_ref(8) -#define _arg_ref9(a1, a2, a3, a4, a5, a6, a7, a8, a9) \ - _arg_ref8(a1, a2, a3, a4, a5, a6, a7, a8), a9##_ref(9) -#define _arg_ref10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) \ - _arg_ref9(a1, a2, a3, a4, a5, a6, a7, a8, a9), a10##_ref(10) -#define _arg_ref11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \ - _arg_ref10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10), a11##_ref(11) -#define arg_ref(...) VA_NARGS_CALL_OVERLOAD(_arg_ref, __VA_ARGS__) - -#define _arg_str1(a1) a1##_str -#define _arg_str2(a1, a2) _arg_str1(a1) a2##_str -#define _arg_str3(a1, a2, a3) _arg_str2(a1, a2) a3##_str -#define _arg_str4(a1, a2, a3, a4) _arg_str3(a1, a2, a3) a4##_str -#define _arg_str5(a1, a2, a3, a4, a5) _arg_str4(a1, a2, a3, a4) a5##_str -#define _arg_str6(a1, a2, a3, a4, a5, a6) _arg_str5(a1, a2, a3, a4, a5) a6##_str -#define _arg_str7(a1, a2, a3, a4, a5, a6, a7) _arg_str6(a1, a2, a3, a4, a5, a6) a7##_str -#define _arg_str8(a1, a2, a3, a4, a5, a6, a7, a8) _arg_str7(a1, a2, a3, a4, a5, a6, a7) a8##_str -#define _arg_str9(a1, a2, a3, a4, a5, a6, a7, a8, a9) \ - _arg_str8(a1, a2, a3, a4, a5, a6, a7, a8) a9##_str -#define _arg_str10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) \ - _arg_str9(a1, a2, a3, a4, a5, a6, a7, a8, a9) a10##_str -#define _arg_str11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11) \ - _arg_str10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) a11##_str -#define arg_str(...) VA_NARGS_CALL_OVERLOAD(_arg_str, __VA_ARGS__) - -#define ret_def_void -#define ret_set_void -#define ret_default_void -#define ret_ret_void return Py_INCREF(Py_None), Py_None - -#define ret_def_GLint int ret_int -#define ret_set_GLint ret_int = -#define ret_default_GLint -1 -#define ret_ret_GLint return PyLong_FromLong(ret_int) - -#define ret_def_GLuint uint ret_uint -#define ret_set_GLuint ret_uint = -#define ret_default_GLuint 0 -#define ret_ret_GLuint return PyLong_FromLong(long(ret_uint)) - -#if 0 -# define ret_def_GLsizei size_t ret_size_t -# define ret_set_GLsizei ret_size_t = -# define ret_ret_GLsizei return PyLong_FromSsize_t(ret_size_t) -#endif - -#if 0 -# define ret_def_GLsync uint ret_sync -# define ret_set_GLsync ret_sync = -# define ret_ret_GLsync return PyLong_FromLong(long(ret_sync)) -#endif - -#define ret_def_GLenum uint ret_uint -#define ret_set_GLenum ret_uint = -#define ret_default_GLenum 0 -#define ret_ret_GLenum return PyLong_FromLong(long(ret_uint)) - -#define ret_def_GLboolean uchar ret_bool -#define ret_set_GLboolean ret_bool = -#define ret_default_GLboolean GL_FALSE -#define ret_ret_GLboolean return PyLong_FromLong(long(ret_bool)) - -#define ret_def_GLstring \ - const char *default_GLstring = ""; \ - const uchar *ret_str -#define ret_set_GLstring ret_str = -#define ret_default_GLstring (const uchar *)default_GLstring - -#define ret_ret_GLstring \ - if (ret_str) { \ - return PyUnicode_FromString((const char *)ret_str); \ - } \ -\ - PyErr_SetString(PyExc_AttributeError, "could not get opengl string"); \ - return nullptr; - -/** \} */ - -/* -------------------------------------------------------------------- */ -/* Forward Declarations */ - -static PyObject *Buffer_new(PyTypeObject *type, PyObject *args, PyObject *kwds); -static PyObject *Method_ShaderSource(PyObject *self, PyObject *args); - -/* Buffer sequence methods */ - -static Py_ssize_t Buffer_len(Buffer *self); -static PyObject *Buffer_item(Buffer *self, Py_ssize_t i); -static PyObject *Buffer_slice(Buffer *self, Py_ssize_t begin, Py_ssize_t end); -static int Buffer_ass_item(Buffer *self, Py_ssize_t i, PyObject *v); -static int Buffer_ass_slice(Buffer *self, Py_ssize_t begin, Py_ssize_t end, PyObject *seq); -static PyObject *Buffer_subscript(Buffer *self, PyObject *item); -static int Buffer_ass_subscript(Buffer *self, PyObject *item, PyObject *value); - -/* -------------------------------------------------------------------- */ -/** \name Utility Functions - * \{ */ - -int BGL_typeSize(int type) -{ - switch (type) { - case GL_BYTE: - return sizeof(char); - case GL_SHORT: - return sizeof(short); - case GL_INT: - return sizeof(int); - case GL_FLOAT: - return sizeof(float); - case GL_DOUBLE: - return sizeof(double); - } - return -1; -} - -static int gl_buffer_type_from_py_buffer(Py_buffer *pybuffer) -{ - const char format = PyC_StructFmt_type_from_str(pybuffer->format); - const Py_ssize_t itemsize = pybuffer->itemsize; - - if (PyC_StructFmt_type_is_float_any(format)) { - if (itemsize == 4) { - return GL_FLOAT; - } - if (itemsize == 8) { - return GL_DOUBLE; - } - } - if (PyC_StructFmt_type_is_byte(format) || PyC_StructFmt_type_is_int_any(format)) { - if (itemsize == 1) { - return GL_BYTE; - } - if (itemsize == 2) { - return GL_SHORT; - } - if (itemsize == 4) { - return GL_INT; - } - } - - return -1; /* UNKNOWN */ -} - -static bool compare_dimensions(int ndim, const int *dim1, const Py_ssize_t *dim2) -{ - for (int i = 0; i < ndim; i++) { - if (dim1[i] != dim2[i]) { - return false; - } - } - return true; -} - -/** \} */ - -/* -------------------------------------------------------------------- */ -/** \name Buffer API - * \{ */ - -static PySequenceMethods Buffer_SeqMethods = { - /*sq_length*/ (lenfunc)Buffer_len, - /*sq_concat*/ nullptr, - /*sq_repeat*/ nullptr, - /*sq_item*/ (ssizeargfunc)Buffer_item, - /*was_sq_slice*/ nullptr, /* DEPRECATED. Handled by #Buffer_item. */ - /*sq_ass_item*/ (ssizeobjargproc)Buffer_ass_item, - /*was_sq_ass_slice*/ nullptr, /* DEPRECATED. Handled by #Buffer_ass_item. */ - /*sq_contains*/ nullptr, - /*sq_inplace_concat*/ nullptr, - /*sq_inplace_repeat*/ nullptr, -}; - -static PyMappingMethods Buffer_AsMapping = { - /*mp_length*/ (lenfunc)Buffer_len, - /*mp_subscript*/ (binaryfunc)Buffer_subscript, - /*mp_ass_subscript*/ (objobjargproc)Buffer_ass_subscript, -}; - -static void Buffer_dealloc(Buffer *self); -static PyObject *Buffer_repr(Buffer *self); - -static PyObject *Buffer_to_list(Buffer *self) -{ - int i, len = self->dimensions[0]; - PyObject *list = PyList_New(len); - - for (i = 0; i < len; i++) { - PyList_SET_ITEM(list, i, Buffer_item(self, i)); - } - - return list; -} - -static PyObject *Buffer_to_list_recursive(Buffer *self) -{ - PyObject *list; - - if (self->ndimensions > 1) { - int i, len = self->dimensions[0]; - list = PyList_New(len); - - for (i = 0; i < len; i++) { - Buffer *sub = (Buffer *)Buffer_item(self, i); - PyList_SET_ITEM(list, i, Buffer_to_list_recursive(sub)); - Py_DECREF(sub); - } - } - else { - list = Buffer_to_list(self); - } - - return list; -} - -static PyObject *Buffer_dimensions(Buffer *self, void * /*arg*/) -{ - PyObject *list = PyList_New(self->ndimensions); - int i; - - for (i = 0; i < self->ndimensions; i++) { - PyList_SET_ITEM(list, i, PyLong_FromLong(self->dimensions[i])); - } - - return list; -} - -#ifdef __GNUC__ -# ifdef __clang__ -# pragma clang diagnostic push -# pragma clang diagnostic ignored "-Wcast-function-type" -# else -# pragma GCC diagnostic push -# pragma GCC diagnostic ignored "-Wcast-function-type" -# endif -#endif - -static PyMethodDef Buffer_methods[] = { - {"to_list", (PyCFunction)Buffer_to_list_recursive, METH_NOARGS, "return the buffer as a list"}, - {nullptr, nullptr, 0, nullptr}, -}; - -#ifdef __GNUC__ -# ifdef __clang__ -# pragma clang diagnostic pop -# else -# pragma GCC diagnostic pop -# endif -#endif - -static PyGetSetDef Buffer_getseters[] = { - {"dimensions", (getter)Buffer_dimensions, nullptr, nullptr, nullptr}, - {nullptr, nullptr, nullptr, nullptr, nullptr}, -}; - -PyTypeObject BGL_bufferType = { - /*ob_base*/ PyVarObject_HEAD_INIT(nullptr, 0) - /*tp_name*/ "bgl.Buffer", - /*tp_basicsize*/ sizeof(Buffer), - /*tp_itemsize*/ 0, - /*tp_dealloc*/ (destructor)Buffer_dealloc, - /*tp_vectorcall_offset*/ 0, - /*tp_getattr*/ nullptr, - /*tp_setattr*/ nullptr, - /*tp_as_async*/ nullptr, - /*tp_repr*/ (reprfunc)Buffer_repr, - /*tp_as_number*/ nullptr, - /*tp_as_sequence*/ &Buffer_SeqMethods, - /*tp_as_mapping*/ &Buffer_AsMapping, - /*tp_hash*/ nullptr, - /*tp_call*/ nullptr, - /*tp_str*/ nullptr, - /*tp_getattro*/ nullptr, - /*tp_setattro*/ nullptr, - /*tp_as_buffer*/ nullptr, - /*tp_flags*/ Py_TPFLAGS_DEFAULT, - /*tp_doc*/ nullptr, - /*tp_traverse*/ nullptr, - /*tp_clear*/ nullptr, - /*tp_richcompare*/ nullptr, - /*tp_weaklistoffset*/ 0, - /*tp_iter*/ nullptr, - /*tp_iternext*/ nullptr, - /*tp_methods*/ Buffer_methods, - /*tp_members*/ nullptr, - /*tp_getset*/ Buffer_getseters, - /*tp_base*/ nullptr, - /*tp_dict*/ nullptr, - /*tp_descr_get*/ nullptr, - /*tp_descr_set*/ nullptr, - /*tp_dictoffset*/ 0, - /*tp_init*/ nullptr, - /*tp_alloc*/ nullptr, - /*tp_new*/ Buffer_new, - /*tp_free*/ nullptr, - /*tp_is_gc*/ nullptr, - /*tp_bases*/ nullptr, - /*tp_mro*/ nullptr, - /*tp_cache*/ nullptr, - /*tp_subclasses*/ nullptr, - /*tp_weaklist*/ nullptr, - /*tp_del*/ nullptr, - /*tp_version_tag*/ 0, - /*tp_finalize*/ nullptr, - /*tp_vectorcall*/ nullptr, -}; - -static Buffer *BGL_MakeBuffer_FromData( - PyObject *parent, int type, int ndimensions, const int *dimensions, void *buf) -{ - Buffer *buffer = (Buffer *)PyObject_NEW(Buffer, &BGL_bufferType); - - Py_XINCREF(parent); - buffer->parent = parent; - buffer->ndimensions = ndimensions; - buffer->dimensions = MEM_malloc_arrayN(size_t(ndimensions), "Buffer dimensions"); - memcpy(buffer->dimensions, dimensions, ndimensions * sizeof(int)); - buffer->type = type; - buffer->buf.asvoid = buf; - - return buffer; -} - -Buffer *BGL_MakeBuffer(int type, int ndimensions, const int *dimensions, const void *initbuffer) -{ - Buffer *buffer; - void *buf = nullptr; - int i, size = BGL_typeSize(type); - - for (i = 0; i < ndimensions; i++) { - size *= dimensions[i]; - } - - buf = MEM_mallocN(size, __func__); - - buffer = BGL_MakeBuffer_FromData(nullptr, type, ndimensions, dimensions, buf); - - if (initbuffer) { - memcpy(buffer->buf.asvoid, initbuffer, size); - } - else { - memset(buffer->buf.asvoid, 0, size); - } - return buffer; -} - -#ifdef WITH_OPENGL_BACKEND -/* Custom converter function so we can support a buffer, an integer or nullptr. - * Many OpenGL API functions can accept both an actual pointer or an offset - * into a buffer that is already bound. */ -static int BGL_BufferOrOffsetConverter(PyObject *object, BufferOrOffset *buffer) -{ - if (object == Py_None) { - buffer->buffer = nullptr; - buffer->offset = nullptr; - return 1; - } - if (PyNumber_Check(object)) { - const Py_ssize_t offset = PyNumber_AsSsize_t(object, PyExc_IndexError); - if (offset == -1 && PyErr_Occurred()) { - return 0; - } - - buffer->buffer = nullptr; - buffer->offset = (void *)offset; - return 1; - } - if (PyObject_TypeCheck(object, &BGL_bufferType)) { - buffer->buffer = (Buffer *)object; - buffer->offset = nullptr; - return 1; - } - - PyErr_SetString(PyExc_TypeError, "expected a bgl.Buffer or None"); - return 0; -} -#endif - -#define MAX_DIMENSIONS 256 -static PyObject *Buffer_new(PyTypeObject * /*type*/, PyObject *args, PyObject *kwds) -{ - PyObject *length_ob = nullptr, *init = nullptr; - Buffer *buffer = nullptr; - int dimensions[MAX_DIMENSIONS]; - - int type; - Py_ssize_t i, ndimensions = 0; - - if (kwds && PyDict_Size(kwds)) { - PyErr_SetString(PyExc_TypeError, "bgl.Buffer(): takes no keyword args"); - return nullptr; - } - - if (!PyArg_ParseTuple(args, "iO|O: bgl.Buffer", &type, &length_ob, &init)) { - return nullptr; - } - if (!ELEM(type, GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT, GL_DOUBLE)) { - PyErr_SetString(PyExc_AttributeError, - "invalid first argument type, should be one of " - "GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT or GL_DOUBLE"); - return nullptr; - } - - if (PyLong_Check(length_ob)) { - ndimensions = 1; - if ((dimensions[0] = PyLong_AsLong(length_ob)) < 1) { - PyErr_SetString(PyExc_AttributeError, - "dimensions must be between 1 and " STRINGIFY(MAX_DIMENSIONS)); - return nullptr; - } - } - else if (PySequence_Check(length_ob)) { - ndimensions = PySequence_Size(length_ob); - if (ndimensions > MAX_DIMENSIONS) { - PyErr_SetString(PyExc_AttributeError, - "too many dimensions, max is " STRINGIFY(MAX_DIMENSIONS)); - return nullptr; - } - if (ndimensions < 1) { - PyErr_SetString(PyExc_AttributeError, "sequence must have at least one dimension"); - return nullptr; - } - for (i = 0; i < ndimensions; i++) { - PyObject *ob = PySequence_GetItem(length_ob, i); - - if (!PyLong_Check(ob)) { - dimensions[i] = 1; - } - else { - dimensions[i] = PyLong_AsLong(ob); - } - Py_DECREF(ob); - - if (dimensions[i] < 1) { - PyErr_SetString(PyExc_AttributeError, - "dimensions must be between 1 and " STRINGIFY(MAX_DIMENSIONS)); - return nullptr; - } - } - } - else { - PyErr_Format(PyExc_TypeError, - "invalid second argument expected a sequence " - "or an int, not a %.200s", - Py_TYPE(length_ob)->tp_name); - return nullptr; - } - - if (init && PyObject_CheckBuffer(init)) { - Py_buffer pybuffer; - - if (PyObject_GetBuffer(init, &pybuffer, PyBUF_ND | PyBUF_FORMAT) == -1) { - /* PyObject_GetBuffer raise a PyExc_BufferError */ - return nullptr; - } - - if (type != gl_buffer_type_from_py_buffer(&pybuffer)) { - PyErr_Format(PyExc_TypeError, - "`GL_TYPE` and `typestr` of object with buffer interface do not match. '%s'", - pybuffer.format); - } - else if (ndimensions != pybuffer.ndim || - !compare_dimensions(ndimensions, dimensions, pybuffer.shape)) - { - PyErr_Format(PyExc_TypeError, "array size does not match"); - } - else { - buffer = BGL_MakeBuffer_FromData(init, type, pybuffer.ndim, dimensions, pybuffer.buf); - } - - PyBuffer_Release(&pybuffer); - } - else { - buffer = BGL_MakeBuffer(type, ndimensions, dimensions, nullptr); - if (init && Buffer_ass_slice(buffer, 0, dimensions[0], init)) { - Py_DECREF(buffer); - return nullptr; - } - } - - return (PyObject *)buffer; -} - -/* Buffer sequence methods */ - -static Py_ssize_t Buffer_len(Buffer *self) -{ - return self->dimensions[0]; -} - -static PyObject *Buffer_item(Buffer *self, Py_ssize_t i) -{ - if (i >= self->dimensions[0] || i < 0) { - PyErr_SetString(PyExc_IndexError, "array index out of range"); - return nullptr; - } - - if (self->ndimensions == 1) { - switch (self->type) { - case GL_BYTE: - return Py_BuildValue("b", self->buf.asbyte[i]); - case GL_SHORT: - return Py_BuildValue("h", self->buf.asshort[i]); - case GL_INT: - return Py_BuildValue("i", self->buf.asint[i]); - case GL_FLOAT: - return PyFloat_FromDouble(self->buf.asfloat[i]); - case GL_DOUBLE: - return Py_BuildValue("d", self->buf.asdouble[i]); - } - } - else { - int j, offset = i * BGL_typeSize(self->type); - - for (j = 1; j < self->ndimensions; j++) { - offset *= self->dimensions[j]; - } - - return (PyObject *)BGL_MakeBuffer_FromData((PyObject *)self, - self->type, - self->ndimensions - 1, - self->dimensions + 1, - self->buf.asbyte + offset); - } - - return nullptr; -} - -static PyObject *Buffer_slice(Buffer *self, Py_ssize_t begin, Py_ssize_t end) -{ - PyObject *list; - - begin = std::max(begin, 0); - end = std::min(end, self->dimensions[0]); - begin = std::min(begin, end); - - list = PyList_New(end - begin); - - for (Py_ssize_t count = begin; count < end; count++) { - PyList_SET_ITEM(list, count - begin, Buffer_item(self, count)); - } - return list; -} - -static int Buffer_ass_item(Buffer *self, Py_ssize_t i, PyObject *v) -{ - if (i >= self->dimensions[0] || i < 0) { - PyErr_SetString(PyExc_IndexError, "array assignment index out of range"); - return -1; - } - - if (self->ndimensions != 1) { - Buffer *row = (Buffer *)Buffer_item(self, i); - - if (row) { - const int ret = Buffer_ass_slice(row, 0, self->dimensions[1], v); - Py_DECREF(row); - return ret; - } - - return -1; - } - - switch (self->type) { - case GL_BYTE: - return PyArg_Parse(v, "b:Expected ints", &self->buf.asbyte[i]) ? 0 : -1; - case GL_SHORT: - return PyArg_Parse(v, "h:Expected ints", &self->buf.asshort[i]) ? 0 : -1; - case GL_INT: - return PyArg_Parse(v, "i:Expected ints", &self->buf.asint[i]) ? 0 : -1; - case GL_FLOAT: - return PyArg_Parse(v, "f:Expected floats", &self->buf.asfloat[i]) ? 0 : -1; - case GL_DOUBLE: - return PyArg_Parse(v, "d:Expected floats", &self->buf.asdouble[i]) ? 0 : -1; - default: - return 0; /* should never happen */ - } -} - -static int Buffer_ass_slice(Buffer *self, Py_ssize_t begin, Py_ssize_t end, PyObject *seq) -{ - PyObject *item; - int err = 0; - Py_ssize_t count; - - begin = std::max(begin, 0); - end = std::min(end, self->dimensions[0]); - begin = std::min(begin, end); - - if (!PySequence_Check(seq)) { - PyErr_Format(PyExc_TypeError, - "buffer[:] = value, invalid assignment. " - "Expected a sequence, not an %.200s type", - Py_TYPE(seq)->tp_name); - return -1; - } - - /* Re-use count variable. */ - if ((count = PySequence_Size(seq)) != (end - begin)) { - PyErr_Format(PyExc_TypeError, - "buffer[:] = value, size mismatch in assignment. " - "Expected: %d (given: %d)", - count, - end - begin); - return -1; - } - - for (count = begin; count < end; count++) { - item = PySequence_GetItem(seq, count - begin); - if (item) { - err = Buffer_ass_item(self, count, item); - Py_DECREF(item); - } - else { - err = -1; - } - if (err) { - break; - } - } - return err; -} - -static PyObject *Buffer_subscript(Buffer *self, PyObject *item) -{ - if (PyIndex_Check(item)) { - Py_ssize_t i; - i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) { - return nullptr; - } - if (i < 0) { - i += self->dimensions[0]; - } - return Buffer_item(self, i); - } - if (PySlice_Check(item)) { - Py_ssize_t start, stop, step, slicelength; - - if (PySlice_GetIndicesEx(item, self->dimensions[0], &start, &stop, &step, &slicelength) < 0) { - return nullptr; - } - - if (slicelength <= 0) { - return PyTuple_New(0); - } - if (step == 1) { - return Buffer_slice(self, start, stop); - } - - PyErr_SetString(PyExc_IndexError, "slice steps not supported with vectors"); - return nullptr; - } - - PyErr_Format( - PyExc_TypeError, "buffer indices must be integers, not %.200s", Py_TYPE(item)->tp_name); - return nullptr; -} - -static int Buffer_ass_subscript(Buffer *self, PyObject *item, PyObject *value) -{ - if (PyIndex_Check(item)) { - Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); - if (i == -1 && PyErr_Occurred()) { - return -1; - } - if (i < 0) { - i += self->dimensions[0]; - } - return Buffer_ass_item(self, i, value); - } - if (PySlice_Check(item)) { - Py_ssize_t start, stop, step, slicelength; - - if (PySlice_GetIndicesEx(item, self->dimensions[0], &start, &stop, &step, &slicelength) < 0) { - return -1; - } - - if (step == 1) { - return Buffer_ass_slice(self, start, stop, value); - } - - PyErr_SetString(PyExc_IndexError, "slice steps not supported with vectors"); - return -1; - } - - PyErr_Format( - PyExc_TypeError, "buffer indices must be integers, not %.200s", Py_TYPE(item)->tp_name); - return -1; -} - -static void Buffer_dealloc(Buffer *self) -{ - if (self->parent) { - Py_DECREF(self->parent); - } - else { - MEM_freeN(self->buf.asvoid); - } - - MEM_freeN(self->dimensions); - - PyObject_DEL(self); -} - -static PyObject *Buffer_repr(Buffer *self) -{ - PyObject *list = Buffer_to_list_recursive(self); - PyObject *repr; - const char *typestr; - - switch (self->type) { - case GL_BYTE: - typestr = "GL_BYTE"; - break; - case GL_SHORT: - typestr = "GL_SHORT"; - break; - case GL_INT: - typestr = "GL_INT"; - break; - case GL_FLOAT: - typestr = "GL_FLOAT"; - break; - case GL_DOUBLE: - typestr = "GL_DOUBLE"; - break; - default: - typestr = "UNKNOWN"; - break; - } - - repr = PyUnicode_FromFormat("Buffer(%s, %R)", typestr, list); - Py_DECREF(list); - - return repr; -} - -/** \} */ - -/* -------------------------------------------------------------------- */ -/** \name OpenGL API Wrapping - * \{ */ - -#ifdef WITH_OPENGL_BACKEND -# define BGL_Wrap(funcname, ret, arg_list) \ - static PyObject *Method_##funcname(PyObject * /*self*/, PyObject *args) \ - { \ - arg_def arg_list; \ - ret_def_##ret; \ - report_deprecated_call(#funcname); \ - if (!PyArg_ParseTuple(args, arg_str arg_list, arg_ref arg_list)) { \ - return nullptr; \ - } \ - const bool has_opengl_backend = GPU_backend_get_type() == GPU_BACKEND_OPENGL; \ - if (has_opengl_backend) { \ - GPU_bgl_start(); \ - ret_set_##ret gl##funcname(arg_var arg_list); \ - } \ - else { \ - report_deprecated_call_to_user(); \ - ret_set_##ret ret_default_##ret; \ - } \ - ret_ret_##ret; \ - } -#else - -static void bgl_no_opengl_error() -{ - PyErr_SetString(PyExc_RuntimeError, "Built without OpenGL support"); -} - -# define BGL_Wrap(funcname, ret, arg_list) \ - static PyObject *Method_##funcname(PyObject * /*self*/, PyObject *args) \ - { \ - (void)args; \ - bgl_no_opengl_error(); \ - return nullptr; \ - } -#endif - -/* GL_VERSION_1_0 */ -BGL_Wrap(BlendFunc, void, (GLenum, GLenum)); -BGL_Wrap(Clear, void, (GLbitfield)); -BGL_Wrap(ClearColor, void, (GLfloat, GLfloat, GLfloat, GLfloat)); -BGL_Wrap(ClearDepth, void, (GLdouble)); -BGL_Wrap(ClearStencil, void, (GLint)); -BGL_Wrap(ColorMask, void, (GLboolean, GLboolean, GLboolean, GLboolean)); -BGL_Wrap(CullFace, void, (GLenum)); -BGL_Wrap(DepthFunc, void, (GLenum)); -BGL_Wrap(DepthMask, void, (GLboolean)); -BGL_Wrap(DepthRange, void, (GLdouble, GLdouble)); -BGL_Wrap(Disable, void, (GLenum)); -BGL_Wrap(DrawBuffer, void, (GLenum)); -BGL_Wrap(Enable, void, (GLenum)); -BGL_Wrap(Finish, void, (void)); -BGL_Wrap(Flush, void, (void)); -BGL_Wrap(FrontFace, void, (GLenum)); -BGL_Wrap(GetBooleanv, void, (GLenum, GLbooleanP)); -BGL_Wrap(GetDoublev, void, (GLenum, GLdoubleP)); -BGL_Wrap(GetError, GLenum, (void)); -BGL_Wrap(GetFloatv, void, (GLenum, GLfloatP)); -BGL_Wrap(GetIntegerv, void, (GLenum, GLintP)); -BGL_Wrap(GetString, GLstring, (GLenum)); -BGL_Wrap(GetTexImage, void, (GLenum, GLint, GLenum, GLenum, GLvoidP)); -BGL_Wrap(GetTexLevelParameterfv, void, (GLenum, GLint, GLenum, GLfloatP)); -BGL_Wrap(GetTexLevelParameteriv, void, (GLenum, GLint, GLenum, GLintP)); -BGL_Wrap(GetTexParameterfv, void, (GLenum, GLenum, GLfloatP)); -BGL_Wrap(GetTexParameteriv, void, (GLenum, GLenum, GLintP)); -BGL_Wrap(Hint, void, (GLenum, GLenum)); -BGL_Wrap(IsEnabled, GLboolean, (GLenum)); -BGL_Wrap(LineWidth, void, (GLfloat)); -BGL_Wrap(LogicOp, void, (GLenum)); -BGL_Wrap(PixelStoref, void, (GLenum, GLfloat)); -BGL_Wrap(PixelStorei, void, (GLenum, GLint)); -BGL_Wrap(PointSize, void, (GLfloat)); -BGL_Wrap(PolygonMode, void, (GLenum, GLenum)); -BGL_Wrap(ReadBuffer, void, (GLenum)); -BGL_Wrap(ReadPixels, void, (GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoidP)); -BGL_Wrap(Scissor, void, (GLint, GLint, GLsizei, GLsizei)); -BGL_Wrap(StencilFunc, void, (GLenum, GLint, GLuint)); -BGL_Wrap(StencilMask, void, (GLuint)); -BGL_Wrap(StencilOp, void, (GLenum, GLenum, GLenum)); -BGL_Wrap(TexImage1D, void, (GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, GLvoidP)); -BGL_Wrap(TexImage2D, - void, - (GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, GLvoidP)); -BGL_Wrap(TexParameterf, void, (GLenum, GLenum, GLfloat)); -BGL_Wrap(TexParameterfv, void, (GLenum, GLenum, GLfloatP)); -BGL_Wrap(TexParameteri, void, (GLenum, GLenum, GLint)); -BGL_Wrap(TexParameteriv, void, (GLenum, GLenum, GLintP)); -BGL_Wrap(Viewport, void, (GLint, GLint, GLsizei, GLsizei)); - -/* GL_VERSION_1_1 */ -BGL_Wrap(BindTexture, void, (GLenum, GLuint)); -BGL_Wrap(CopyTexImage1D, void, (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint)); -BGL_Wrap(CopyTexImage2D, void, (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint)); -BGL_Wrap(CopyTexSubImage1D, void, (GLenum, GLint, GLint, GLint, GLint, GLsizei)); -BGL_Wrap(CopyTexSubImage2D, void, (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei)); -BGL_Wrap(DeleteTextures, void, (GLsizei, GLuintP)); -BGL_Wrap(DrawArrays, void, (GLenum, GLint, GLsizei)); -BGL_Wrap(DrawElements, void, (GLenum, GLsizei, GLenum, GLvoidP)); -BGL_Wrap(GenTextures, void, (GLsizei, GLuintP)); -BGL_Wrap(IsTexture, GLboolean, (GLuint)); -BGL_Wrap(PolygonOffset, void, (GLfloat, GLfloat)); -BGL_Wrap(TexSubImage1D, void, (GLenum, GLint, GLint, GLsizei, GLenum, GLenum, GLvoidP)); -BGL_Wrap(TexSubImage2D, - void, - (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoidP)); - -/* GL_VERSION_1_2 */ -BGL_Wrap(CopyTexSubImage3D, - void, - (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei)); -BGL_Wrap(DrawRangeElements, void, (GLenum, GLuint, GLuint, GLsizei, GLenum, GLvoidP)); -BGL_Wrap(TexImage3D, - void, - (GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, GLvoidP)); -BGL_Wrap(TexSubImage3D, - void, - (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLvoidP)); - -/* GL_VERSION_1_3 */ -BGL_Wrap(ActiveTexture, void, (GLenum)); -BGL_Wrap(CompressedTexImage1D, void, (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, GLvoidP)); -BGL_Wrap(CompressedTexImage2D, - void, - (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, GLvoidP)); -BGL_Wrap(CompressedTexImage3D, - void, - (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, GLvoidP)); -BGL_Wrap(CompressedTexSubImage1D, void, (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, GLvoidP)); -BGL_Wrap(CompressedTexSubImage2D, - void, - (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, GLvoidP)); -BGL_Wrap( - CompressedTexSubImage3D, - void, - (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, GLvoidP)); -BGL_Wrap(GetCompressedTexImage, void, (GLenum, GLint, GLvoidP)); -BGL_Wrap(SampleCoverage, void, (GLfloat, GLboolean)); - -/* GL_VERSION_1_4 */ -BGL_Wrap(BlendColor, void, (GLfloat, GLfloat, GLfloat, GLfloat)); -BGL_Wrap(BlendEquation, void, (GLenum)); - -/* GL_VERSION_1_5 */ -BGL_Wrap(BeginQuery, void, (GLenum, GLuint)); -BGL_Wrap(BindBuffer, void, (GLenum, GLuint)); -BGL_Wrap(BufferData, void, (GLenum, GLsizeiptr, GLvoidP, GLenum)); -BGL_Wrap(BufferSubData, void, (GLenum, GLintptr, GLsizeiptr, GLvoidP)); -BGL_Wrap(DeleteBuffers, void, (GLsizei, GLuintP)); -BGL_Wrap(DeleteQueries, void, (GLsizei, GLuintP)); -BGL_Wrap(EndQuery, void, (GLenum)); -BGL_Wrap(GenBuffers, void, (GLsizei, GLuintP)); -BGL_Wrap(GenQueries, void, (GLsizei, GLuintP)); -BGL_Wrap(GetBufferParameteriv, void, (GLenum, GLenum, GLintP)); -BGL_Wrap(GetBufferPointerv, void, (GLenum, GLenum, GLvoidP)); -BGL_Wrap(GetBufferSubData, void, (GLenum, GLintptr, GLsizeiptr, GLvoidP)); -BGL_Wrap(GetQueryObjectiv, void, (GLuint, GLenum, GLintP)); -BGL_Wrap(GetQueryObjectuiv, void, (GLuint, GLenum, GLuintP)); -BGL_Wrap(GetQueryiv, void, (GLenum, GLenum, GLintP)); -BGL_Wrap(IsBuffer, GLboolean, (GLuint)); -BGL_Wrap(IsQuery, GLboolean, (GLuint)); -BGL_Wrap(MapBuffer, void, (GLenum, GLenum)); -BGL_Wrap(UnmapBuffer, GLboolean, (GLenum)); - -/* GL_VERSION_2_0 */ -BGL_Wrap(AttachShader, void, (GLuint, GLuint)); -BGL_Wrap(BindAttribLocation, void, (GLuint, GLuint, GLstring)); -BGL_Wrap(BlendEquationSeparate, void, (GLenum, GLenum)); -BGL_Wrap(CompileShader, void, (GLuint)); -BGL_Wrap(CreateProgram, GLuint, (void)); -BGL_Wrap(CreateShader, GLuint, (GLenum)); -BGL_Wrap(DeleteProgram, void, (GLuint)); -BGL_Wrap(DeleteShader, void, (GLuint)); -BGL_Wrap(DetachShader, void, (GLuint, GLuint)); -BGL_Wrap(DisableVertexAttribArray, void, (GLuint)); -BGL_Wrap(DrawBuffers, void, (GLsizei, GLenumP)); -BGL_Wrap(EnableVertexAttribArray, void, (GLuint)); -BGL_Wrap(GetActiveAttrib, void, (GLuint, GLuint, GLsizei, GLsizeiP, GLintP, GLenumP, GLcharP)); -BGL_Wrap(GetActiveUniform, void, (GLuint, GLuint, GLsizei, GLsizeiP, GLintP, GLenumP, GLcharP)); -BGL_Wrap(GetAttachedShaders, void, (GLuint, GLsizei, GLsizeiP, GLuintP)); -BGL_Wrap(GetAttribLocation, GLint, (GLuint, GLstring)); -BGL_Wrap(GetProgramInfoLog, void, (GLuint, GLsizei, GLsizeiP, GLcharP)); -BGL_Wrap(GetProgramiv, void, (GLuint, GLenum, GLintP)); -BGL_Wrap(GetShaderInfoLog, void, (GLuint, GLsizei, GLsizeiP, GLcharP)); -BGL_Wrap(GetShaderSource, void, (GLuint, GLsizei, GLsizeiP, GLcharP)); -BGL_Wrap(GetShaderiv, void, (GLuint, GLenum, GLintP)); -BGL_Wrap(GetUniformLocation, GLint, (GLuint, GLstring)); -BGL_Wrap(GetUniformfv, void, (GLuint, GLint, GLfloatP)); -BGL_Wrap(GetUniformiv, void, (GLuint, GLint, GLintP)); -BGL_Wrap(GetVertexAttribPointerv, void, (GLuint, GLenum, GLvoidP)); -BGL_Wrap(GetVertexAttribdv, void, (GLuint, GLenum, GLdoubleP)); -BGL_Wrap(GetVertexAttribfv, void, (GLuint, GLenum, GLfloatP)); -BGL_Wrap(GetVertexAttribiv, void, (GLuint, GLenum, GLintP)); -BGL_Wrap(IsProgram, GLboolean, (GLuint)); -BGL_Wrap(IsShader, GLboolean, (GLuint)); -BGL_Wrap(LinkProgram, void, (GLuint)); -BGL_Wrap(StencilFuncSeparate, void, (GLenum, GLenum, GLint, GLuint)); -BGL_Wrap(StencilMaskSeparate, void, (GLenum, GLuint)); -BGL_Wrap(StencilOpSeparate, void, (GLenum, GLenum, GLenum, GLenum)); -BGL_Wrap(Uniform1f, void, (GLint, GLfloat)); -BGL_Wrap(Uniform1fv, void, (GLint, GLsizei, GLfloatP)); -BGL_Wrap(Uniform1i, void, (GLint, GLint)); -BGL_Wrap(Uniform1iv, void, (GLint, GLsizei, GLintP)); -BGL_Wrap(Uniform2f, void, (GLint, GLfloat, GLfloat)); -BGL_Wrap(Uniform2fv, void, (GLint, GLsizei, GLfloatP)); -BGL_Wrap(Uniform2i, void, (GLint, GLint, GLint)); -BGL_Wrap(Uniform2iv, void, (GLint, GLsizei, GLintP)); -BGL_Wrap(Uniform3f, void, (GLint, GLfloat, GLfloat, GLfloat)); -BGL_Wrap(Uniform3fv, void, (GLint, GLsizei, GLfloatP)); -BGL_Wrap(Uniform3i, void, (GLint, GLint, GLint, GLint)); -BGL_Wrap(Uniform3iv, void, (GLint, GLsizei, GLintP)); -BGL_Wrap(Uniform4f, void, (GLint, GLfloat, GLfloat, GLfloat, GLfloat)); -BGL_Wrap(Uniform4fv, void, (GLint, GLsizei, GLfloatP)); -BGL_Wrap(Uniform4i, void, (GLint, GLint, GLint, GLint, GLint)); -BGL_Wrap(Uniform4iv, void, (GLint, GLsizei, GLintP)); -BGL_Wrap(UniformMatrix2fv, void, (GLint, GLsizei, GLboolean, GLfloatP)); -BGL_Wrap(UniformMatrix3fv, void, (GLint, GLsizei, GLboolean, GLfloatP)); -BGL_Wrap(UniformMatrix4fv, void, (GLint, GLsizei, GLboolean, GLfloatP)); -BGL_Wrap(UseProgram, void, (GLuint)); -BGL_Wrap(ValidateProgram, void, (GLuint)); -BGL_Wrap(VertexAttrib1d, void, (GLuint, GLdouble)); -BGL_Wrap(VertexAttrib1dv, void, (GLuint, GLdoubleP)); -BGL_Wrap(VertexAttrib1f, void, (GLuint, GLfloat)); -BGL_Wrap(VertexAttrib1fv, void, (GLuint, GLfloatP)); -BGL_Wrap(VertexAttrib1s, void, (GLuint, GLshort)); -BGL_Wrap(VertexAttrib1sv, void, (GLuint, GLshortP)); -BGL_Wrap(VertexAttrib2d, void, (GLuint, GLdouble, GLdouble)); -BGL_Wrap(VertexAttrib2dv, void, (GLuint, GLdoubleP)); -BGL_Wrap(VertexAttrib2f, void, (GLuint, GLfloat, GLfloat)); -BGL_Wrap(VertexAttrib2fv, void, (GLuint, GLfloatP)); -BGL_Wrap(VertexAttrib2s, void, (GLuint, GLshort, GLshort)); -BGL_Wrap(VertexAttrib2sv, void, (GLuint, GLshortP)); -BGL_Wrap(VertexAttrib3d, void, (GLuint, GLdouble, GLdouble, GLdouble)); -BGL_Wrap(VertexAttrib3dv, void, (GLuint, GLdoubleP)); -BGL_Wrap(VertexAttrib3f, void, (GLuint, GLfloat, GLfloat, GLfloat)); -BGL_Wrap(VertexAttrib3fv, void, (GLuint, GLfloatP)); -BGL_Wrap(VertexAttrib3s, void, (GLuint, GLshort, GLshort, GLshort)); -BGL_Wrap(VertexAttrib3sv, void, (GLuint, GLshortP)); -BGL_Wrap(VertexAttrib4Nbv, void, (GLuint, GLbyteP)); -BGL_Wrap(VertexAttrib4Niv, void, (GLuint, GLintP)); -BGL_Wrap(VertexAttrib4Nsv, void, (GLuint, GLshortP)); -BGL_Wrap(VertexAttrib4Nub, void, (GLuint, GLubyte, GLubyte, GLubyte, GLubyte)); -BGL_Wrap(VertexAttrib4Nubv, void, (GLuint, GLubyteP)); -BGL_Wrap(VertexAttrib4Nuiv, void, (GLuint, GLuintP)); -BGL_Wrap(VertexAttrib4Nusv, void, (GLuint, GLushortP)); -BGL_Wrap(VertexAttrib4bv, void, (GLuint, GLbyteP)); -BGL_Wrap(VertexAttrib4d, void, (GLuint, GLdouble, GLdouble, GLdouble, GLdouble)); -BGL_Wrap(VertexAttrib4dv, void, (GLuint, GLdoubleP)); -BGL_Wrap(VertexAttrib4f, void, (GLuint, GLfloat, GLfloat, GLfloat, GLfloat)); -BGL_Wrap(VertexAttrib4fv, void, (GLuint, GLfloatP)); -BGL_Wrap(VertexAttrib4iv, void, (GLuint, GLintP)); -BGL_Wrap(VertexAttrib4s, void, (GLuint, GLshort, GLshort, GLshort, GLshort)); -BGL_Wrap(VertexAttrib4sv, void, (GLuint, GLshortP)); -BGL_Wrap(VertexAttrib4ubv, void, (GLuint, GLubyteP)); -BGL_Wrap(VertexAttrib4uiv, void, (GLuint, GLuintP)); -BGL_Wrap(VertexAttrib4usv, void, (GLuint, GLushortP)); -BGL_Wrap(VertexAttribPointer, void, (GLuint, GLint, GLenum, GLboolean, GLsizei, GLvoidP)); - -/* GL_VERSION_2_1 */ -BGL_Wrap(UniformMatrix2x3fv, void, (GLint, GLsizei, GLboolean, GLfloatP)); -BGL_Wrap(UniformMatrix2x4fv, void, (GLint, GLsizei, GLboolean, GLfloatP)); -BGL_Wrap(UniformMatrix3x2fv, void, (GLint, GLsizei, GLboolean, GLfloatP)); -BGL_Wrap(UniformMatrix3x4fv, void, (GLint, GLsizei, GLboolean, GLfloatP)); -BGL_Wrap(UniformMatrix4x2fv, void, (GLint, GLsizei, GLboolean, GLfloatP)); -BGL_Wrap(UniformMatrix4x3fv, void, (GLint, GLsizei, GLboolean, GLfloatP)); - -/* GL_VERSION_3_0 */ -BGL_Wrap(BindFramebuffer, void, (GLenum, GLuint)); -BGL_Wrap(BindRenderbuffer, void, (GLenum, GLuint)); -BGL_Wrap(BindVertexArray, void, (GLuint)); -BGL_Wrap(BlitFramebuffer, - void, - (GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum)); -BGL_Wrap(CheckFramebufferStatus, GLenum, (GLenum)); -BGL_Wrap(DeleteFramebuffers, void, (GLsizei, GLuintP)); -BGL_Wrap(DeleteRenderbuffers, void, (GLsizei, GLuintP)); -BGL_Wrap(DeleteVertexArrays, void, (GLsizei, GLuintP)); -BGL_Wrap(FramebufferRenderbuffer, void, (GLenum, GLenum, GLenum, GLuint)); -BGL_Wrap(GenFramebuffers, void, (GLsizei, GLuintP)); -BGL_Wrap(GenRenderbuffers, void, (GLsizei, GLuintP)); -BGL_Wrap(GenVertexArrays, void, (GLsizei, GLuintP)); -BGL_Wrap(GetStringi, GLstring, (GLenum, GLuint)); -BGL_Wrap(IsVertexArray, GLboolean, (GLuint)); -BGL_Wrap(RenderbufferStorage, void, (GLenum, GLenum, GLsizei, GLsizei)); -BGL_Wrap(VertexAttribIPointer, void, (GLuint, GLint, GLenum, GLsizei, GLvoidP)); - -/* GL_VERSION_3_1 */ -BGL_Wrap(BindBufferBase, void, (GLenum, GLuint, GLuint)); -BGL_Wrap(BindBufferRange, void, (GLenum, GLuint, GLuint, GLintptr, GLsizeiptr)); -BGL_Wrap(GetActiveUniformBlockName, void, (GLuint, GLuint, GLsizei, GLsizeiP, GLcharP)); -BGL_Wrap(GetActiveUniformBlockiv, void, (GLuint, GLuint, GLenum, GLintP)); -BGL_Wrap(GetActiveUniformName, void, (GLuint, GLuint, GLsizei, GLsizeiP, GLcharP)); -BGL_Wrap(GetActiveUniformsiv, void, (GLuint, GLsizei, GLuintP, GLenum, GLintP)); -BGL_Wrap(GetIntegeri_v, void, (GLenum, GLuint, GLintP)); -BGL_Wrap(GetUniformBlockIndex, GLuint, (GLuint, GLstring)); -BGL_Wrap(GetUniformIndices, void, (GLuint, GLsizei, GLcharP, GLuintP)); -BGL_Wrap(UniformBlockBinding, void, (GLuint, GLuint, GLuint)); - -/* GL_VERSION_3_2 */ -BGL_Wrap(FramebufferTexture, void, (GLenum, GLenum, GLuint, GLint)); -BGL_Wrap(GetBufferParameteri64v, void, (GLenum, GLenum, GLint64P)); -BGL_Wrap(GetInteger64i_v, void, (GLenum, GLuint, GLint64P)); -BGL_Wrap(GetMultisamplefv, void, (GLenum, GLuint, GLfloatP)); -BGL_Wrap(SampleMaski, void, (GLuint, GLbitfield)); -BGL_Wrap(TexImage2DMultisample, void, (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLboolean)); -BGL_Wrap(TexImage3DMultisample, - void, - (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, GLboolean)); - -/* GL_VERSION_3_3 */ -/* no new functions besides packed immediate mode (not part of core profile) */ - -/** \} */ - -/* -------------------------------------------------------------------- */ -/** \name Module Definition - * \{ */ - -static PyModuleDef BGL_module_def = { - /*m_base*/ PyModuleDef_HEAD_INIT, - /*m_name*/ "bgl", - /*m_doc*/ nullptr, - /*m_size*/ 0, - /*m_methods*/ nullptr, - /*m_slots*/ nullptr, - /*m_traverse*/ nullptr, - /*m_clear*/ nullptr, - /*m_free*/ nullptr, -}; - -static void py_module_dict_add_int(PyObject *dict, const char *name, int value) -{ - PyObject *item; - PyDict_SetItemString(dict, name, item = PyLong_FromLong(value)); - Py_DECREF(item); -} - -static void py_module_dict_add_int64(PyObject *dict, const char *name, int64_t value) -{ - PyObject *item; - PyDict_SetItemString(dict, name, item = PyLong_FromLongLong(value)); - Py_DECREF(item); -} - -static void py_module_dict_add_method(PyObject *submodule, - PyObject *dict, - PyMethodDef *method_def, - bool is_valid) -{ - if (is_valid) { - PyObject *m; - m = PyCFunction_NewEx(method_def, nullptr, submodule); - PyDict_SetItemString(dict, method_def->ml_name, m); - Py_DECREF(m); - } - else { - PyDict_SetItemString(dict, method_def->ml_name, Py_None); - } -} - -/* needed since some function pointers won't be nullptr */ -#ifdef __GNUC__ -# pragma GCC diagnostic ignored "-Waddress" -#endif - -#ifdef WITH_OPENGL_BACKEND -# define PY_MOD_ADD_METHOD(func) \ - { \ - static PyMethodDef method_def = {"gl" #func, Method_##func, METH_VARARGS}; \ - py_module_dict_add_method(submodule, dict, &method_def, (gl##func != nullptr)); \ - } \ - ((void)0) -#else -# define PY_MOD_ADD_METHOD(func) \ - { \ - static PyMethodDef method_def = {"gl" #func, Method_##func, METH_VARARGS}; \ - py_module_dict_add_method(submodule, dict, &method_def, false); \ - } \ - ((void)0) -#endif - -static void init_bgl_version_1_0_methods(PyObject *submodule, PyObject *dict) -{ - /* GL_VERSION_1_0 */ - PY_MOD_ADD_METHOD(BlendFunc); - PY_MOD_ADD_METHOD(Clear); - PY_MOD_ADD_METHOD(ClearColor); - PY_MOD_ADD_METHOD(ClearDepth); - PY_MOD_ADD_METHOD(ClearStencil); - PY_MOD_ADD_METHOD(ColorMask); - PY_MOD_ADD_METHOD(CullFace); - PY_MOD_ADD_METHOD(DepthFunc); - PY_MOD_ADD_METHOD(DepthMask); - PY_MOD_ADD_METHOD(DepthRange); - PY_MOD_ADD_METHOD(Disable); - PY_MOD_ADD_METHOD(DrawBuffer); - PY_MOD_ADD_METHOD(Enable); - PY_MOD_ADD_METHOD(Finish); - PY_MOD_ADD_METHOD(Flush); - PY_MOD_ADD_METHOD(FrontFace); - PY_MOD_ADD_METHOD(GetBooleanv); - PY_MOD_ADD_METHOD(GetDoublev); - PY_MOD_ADD_METHOD(GetError); - PY_MOD_ADD_METHOD(GetFloatv); - PY_MOD_ADD_METHOD(GetIntegerv); - PY_MOD_ADD_METHOD(GetString); - PY_MOD_ADD_METHOD(GetTexImage); - PY_MOD_ADD_METHOD(GetTexLevelParameterfv); - PY_MOD_ADD_METHOD(GetTexLevelParameteriv); - PY_MOD_ADD_METHOD(GetTexParameterfv); - PY_MOD_ADD_METHOD(GetTexParameteriv); - PY_MOD_ADD_METHOD(Hint); - PY_MOD_ADD_METHOD(IsEnabled); - PY_MOD_ADD_METHOD(LineWidth); - PY_MOD_ADD_METHOD(LogicOp); - PY_MOD_ADD_METHOD(PixelStoref); - PY_MOD_ADD_METHOD(PixelStorei); - PY_MOD_ADD_METHOD(PointSize); - PY_MOD_ADD_METHOD(PolygonMode); - PY_MOD_ADD_METHOD(ReadBuffer); - PY_MOD_ADD_METHOD(ReadPixels); - PY_MOD_ADD_METHOD(Scissor); - PY_MOD_ADD_METHOD(StencilFunc); - PY_MOD_ADD_METHOD(StencilMask); - PY_MOD_ADD_METHOD(StencilOp); - PY_MOD_ADD_METHOD(TexImage1D); - PY_MOD_ADD_METHOD(TexImage2D); - PY_MOD_ADD_METHOD(TexParameterf); - PY_MOD_ADD_METHOD(TexParameterfv); - PY_MOD_ADD_METHOD(TexParameteri); - PY_MOD_ADD_METHOD(TexParameteriv); - PY_MOD_ADD_METHOD(Viewport); -} -static void init_bgl_version_1_1_methods(PyObject *submodule, PyObject *dict) -{ - /* GL_VERSION_1_1 */ - PY_MOD_ADD_METHOD(BindTexture); - PY_MOD_ADD_METHOD(CopyTexImage1D); - PY_MOD_ADD_METHOD(CopyTexImage2D); - PY_MOD_ADD_METHOD(CopyTexSubImage1D); - PY_MOD_ADD_METHOD(CopyTexSubImage2D); - PY_MOD_ADD_METHOD(DeleteTextures); - PY_MOD_ADD_METHOD(DrawArrays); - PY_MOD_ADD_METHOD(DrawElements); - PY_MOD_ADD_METHOD(GenTextures); - PY_MOD_ADD_METHOD(IsTexture); - PY_MOD_ADD_METHOD(PolygonOffset); - PY_MOD_ADD_METHOD(TexSubImage1D); - PY_MOD_ADD_METHOD(TexSubImage2D); -} -static void init_bgl_version_1_2_methods(PyObject *submodule, PyObject *dict) -{ - /* GL_VERSION_1_2 */ - PY_MOD_ADD_METHOD(CopyTexSubImage3D); - PY_MOD_ADD_METHOD(DrawRangeElements); - PY_MOD_ADD_METHOD(TexImage3D); - PY_MOD_ADD_METHOD(TexSubImage3D); -} -static void init_bgl_version_1_3_methods(PyObject *submodule, PyObject *dict) -{ - /* GL_VERSION_1_3 */ - PY_MOD_ADD_METHOD(ActiveTexture); - PY_MOD_ADD_METHOD(CompressedTexImage1D); - PY_MOD_ADD_METHOD(CompressedTexImage2D); - PY_MOD_ADD_METHOD(CompressedTexImage3D); - PY_MOD_ADD_METHOD(CompressedTexSubImage1D); - PY_MOD_ADD_METHOD(CompressedTexSubImage2D); - PY_MOD_ADD_METHOD(CompressedTexSubImage3D); - PY_MOD_ADD_METHOD(GetCompressedTexImage); - PY_MOD_ADD_METHOD(SampleCoverage); -} -static void init_bgl_version_1_4_methods(PyObject *submodule, PyObject *dict) -{ - /* GL_VERSION_1_4 */ - PY_MOD_ADD_METHOD(BlendColor); - PY_MOD_ADD_METHOD(BlendEquation); -} -static void init_bgl_version_1_5_methods(PyObject *submodule, PyObject *dict) -/* GL_VERSION_1_5 */ -{ - PY_MOD_ADD_METHOD(BeginQuery); - PY_MOD_ADD_METHOD(BindBuffer); - PY_MOD_ADD_METHOD(BufferData); - PY_MOD_ADD_METHOD(BufferSubData); - PY_MOD_ADD_METHOD(DeleteBuffers); - PY_MOD_ADD_METHOD(DeleteQueries); - PY_MOD_ADD_METHOD(EndQuery); - PY_MOD_ADD_METHOD(GenBuffers); - PY_MOD_ADD_METHOD(GenQueries); - PY_MOD_ADD_METHOD(GetBufferParameteriv); - PY_MOD_ADD_METHOD(GetBufferPointerv); - PY_MOD_ADD_METHOD(GetBufferSubData); - PY_MOD_ADD_METHOD(GetQueryObjectiv); - PY_MOD_ADD_METHOD(GetQueryObjectuiv); - PY_MOD_ADD_METHOD(GetQueryiv); - PY_MOD_ADD_METHOD(IsBuffer); - PY_MOD_ADD_METHOD(IsQuery); - PY_MOD_ADD_METHOD(MapBuffer); - PY_MOD_ADD_METHOD(UnmapBuffer); -} -static void init_bgl_version_2_0_methods(PyObject *submodule, PyObject *dict) -{ - /* GL_VERSION_2_0 */ - PY_MOD_ADD_METHOD(AttachShader); - PY_MOD_ADD_METHOD(BindAttribLocation); - PY_MOD_ADD_METHOD(BlendEquationSeparate); - PY_MOD_ADD_METHOD(CompileShader); - PY_MOD_ADD_METHOD(CreateProgram); - PY_MOD_ADD_METHOD(CreateShader); - PY_MOD_ADD_METHOD(DeleteProgram); - PY_MOD_ADD_METHOD(DeleteShader); - PY_MOD_ADD_METHOD(DetachShader); - PY_MOD_ADD_METHOD(DisableVertexAttribArray); - PY_MOD_ADD_METHOD(DrawBuffers); - PY_MOD_ADD_METHOD(EnableVertexAttribArray); - PY_MOD_ADD_METHOD(GetActiveAttrib); - PY_MOD_ADD_METHOD(GetActiveUniform); - PY_MOD_ADD_METHOD(GetAttachedShaders); - PY_MOD_ADD_METHOD(GetAttribLocation); - PY_MOD_ADD_METHOD(GetProgramInfoLog); - PY_MOD_ADD_METHOD(GetProgramiv); - PY_MOD_ADD_METHOD(GetShaderInfoLog); - PY_MOD_ADD_METHOD(GetShaderSource); - PY_MOD_ADD_METHOD(GetShaderiv); - PY_MOD_ADD_METHOD(GetUniformLocation); - PY_MOD_ADD_METHOD(GetUniformfv); - PY_MOD_ADD_METHOD(GetUniformiv); - PY_MOD_ADD_METHOD(GetVertexAttribPointerv); - PY_MOD_ADD_METHOD(GetVertexAttribdv); - PY_MOD_ADD_METHOD(GetVertexAttribfv); - PY_MOD_ADD_METHOD(GetVertexAttribiv); - PY_MOD_ADD_METHOD(IsProgram); - PY_MOD_ADD_METHOD(IsShader); - PY_MOD_ADD_METHOD(LinkProgram); - PY_MOD_ADD_METHOD(ShaderSource); - PY_MOD_ADD_METHOD(StencilFuncSeparate); - PY_MOD_ADD_METHOD(StencilMaskSeparate); - PY_MOD_ADD_METHOD(StencilOpSeparate); - PY_MOD_ADD_METHOD(Uniform1f); - PY_MOD_ADD_METHOD(Uniform1fv); - PY_MOD_ADD_METHOD(Uniform1i); - PY_MOD_ADD_METHOD(Uniform1iv); - PY_MOD_ADD_METHOD(Uniform2f); - PY_MOD_ADD_METHOD(Uniform2fv); - PY_MOD_ADD_METHOD(Uniform2i); - PY_MOD_ADD_METHOD(Uniform2iv); - PY_MOD_ADD_METHOD(Uniform3f); - PY_MOD_ADD_METHOD(Uniform3fv); - PY_MOD_ADD_METHOD(Uniform3i); - PY_MOD_ADD_METHOD(Uniform3iv); - PY_MOD_ADD_METHOD(Uniform4f); - PY_MOD_ADD_METHOD(Uniform4fv); - PY_MOD_ADD_METHOD(Uniform4i); - PY_MOD_ADD_METHOD(Uniform4iv); - PY_MOD_ADD_METHOD(UniformMatrix2fv); - PY_MOD_ADD_METHOD(UniformMatrix3fv); - PY_MOD_ADD_METHOD(UniformMatrix4fv); - PY_MOD_ADD_METHOD(UseProgram); - PY_MOD_ADD_METHOD(ValidateProgram); - PY_MOD_ADD_METHOD(VertexAttrib1d); - PY_MOD_ADD_METHOD(VertexAttrib1dv); - PY_MOD_ADD_METHOD(VertexAttrib1f); - PY_MOD_ADD_METHOD(VertexAttrib1fv); - PY_MOD_ADD_METHOD(VertexAttrib1s); - PY_MOD_ADD_METHOD(VertexAttrib1sv); - PY_MOD_ADD_METHOD(VertexAttrib2d); - PY_MOD_ADD_METHOD(VertexAttrib2dv); - PY_MOD_ADD_METHOD(VertexAttrib2f); - PY_MOD_ADD_METHOD(VertexAttrib2fv); - PY_MOD_ADD_METHOD(VertexAttrib2s); - PY_MOD_ADD_METHOD(VertexAttrib2sv); - PY_MOD_ADD_METHOD(VertexAttrib3d); - PY_MOD_ADD_METHOD(VertexAttrib3dv); - PY_MOD_ADD_METHOD(VertexAttrib3f); - PY_MOD_ADD_METHOD(VertexAttrib3fv); - PY_MOD_ADD_METHOD(VertexAttrib3s); - PY_MOD_ADD_METHOD(VertexAttrib3sv); - PY_MOD_ADD_METHOD(VertexAttrib4Nbv); - PY_MOD_ADD_METHOD(VertexAttrib4Niv); - PY_MOD_ADD_METHOD(VertexAttrib4Nsv); - PY_MOD_ADD_METHOD(VertexAttrib4Nub); - PY_MOD_ADD_METHOD(VertexAttrib4Nubv); - PY_MOD_ADD_METHOD(VertexAttrib4Nuiv); - PY_MOD_ADD_METHOD(VertexAttrib4Nusv); - PY_MOD_ADD_METHOD(VertexAttrib4bv); - PY_MOD_ADD_METHOD(VertexAttrib4d); - PY_MOD_ADD_METHOD(VertexAttrib4dv); - PY_MOD_ADD_METHOD(VertexAttrib4f); - PY_MOD_ADD_METHOD(VertexAttrib4fv); - PY_MOD_ADD_METHOD(VertexAttrib4iv); - PY_MOD_ADD_METHOD(VertexAttrib4s); - PY_MOD_ADD_METHOD(VertexAttrib4sv); - PY_MOD_ADD_METHOD(VertexAttrib4ubv); - PY_MOD_ADD_METHOD(VertexAttrib4uiv); - PY_MOD_ADD_METHOD(VertexAttrib4usv); - PY_MOD_ADD_METHOD(VertexAttribPointer); -} -static void init_bgl_version_2_1_methods(PyObject *submodule, PyObject *dict) -{ - /* GL_VERSION_2_1 */ - PY_MOD_ADD_METHOD(UniformMatrix2x3fv); - PY_MOD_ADD_METHOD(UniformMatrix2x4fv); - PY_MOD_ADD_METHOD(UniformMatrix3x2fv); - PY_MOD_ADD_METHOD(UniformMatrix3x4fv); - PY_MOD_ADD_METHOD(UniformMatrix4x2fv); - PY_MOD_ADD_METHOD(UniformMatrix4x3fv); -} -static void init_bgl_version_3_0_methods(PyObject *submodule, PyObject *dict) -{ - /* GL_VERSION_3_0 */ - PY_MOD_ADD_METHOD(BindFramebuffer); - PY_MOD_ADD_METHOD(BindRenderbuffer); - PY_MOD_ADD_METHOD(BindVertexArray); - PY_MOD_ADD_METHOD(BlitFramebuffer); - PY_MOD_ADD_METHOD(CheckFramebufferStatus); - PY_MOD_ADD_METHOD(DeleteFramebuffers); - PY_MOD_ADD_METHOD(DeleteRenderbuffers); - PY_MOD_ADD_METHOD(DeleteVertexArrays); - PY_MOD_ADD_METHOD(FramebufferRenderbuffer); - PY_MOD_ADD_METHOD(GenFramebuffers); - PY_MOD_ADD_METHOD(GenRenderbuffers); - PY_MOD_ADD_METHOD(GenVertexArrays); - PY_MOD_ADD_METHOD(GetStringi); - PY_MOD_ADD_METHOD(IsVertexArray); - PY_MOD_ADD_METHOD(RenderbufferStorage); - PY_MOD_ADD_METHOD(VertexAttribIPointer); -} -static void init_bgl_version_3_1_methods(PyObject *submodule, PyObject *dict) -{ - /* GL_VERSION_3_1 */ - PY_MOD_ADD_METHOD(BindBufferBase); - PY_MOD_ADD_METHOD(BindBufferRange); - PY_MOD_ADD_METHOD(GetActiveUniformBlockName); - PY_MOD_ADD_METHOD(GetActiveUniformBlockiv); - PY_MOD_ADD_METHOD(GetActiveUniformName); - PY_MOD_ADD_METHOD(GetActiveUniformsiv); - PY_MOD_ADD_METHOD(GetIntegeri_v); - PY_MOD_ADD_METHOD(GetUniformBlockIndex); - PY_MOD_ADD_METHOD(GetUniformIndices); - PY_MOD_ADD_METHOD(UniformBlockBinding); -} -static void init_bgl_version_3_2_methods(PyObject *submodule, PyObject *dict) -{ - /* GL_VERSION_3_2 */ - PY_MOD_ADD_METHOD(FramebufferTexture); - PY_MOD_ADD_METHOD(GetBufferParameteri64v); - PY_MOD_ADD_METHOD(GetInteger64i_v); - PY_MOD_ADD_METHOD(GetMultisamplefv); - PY_MOD_ADD_METHOD(SampleMaski); - PY_MOD_ADD_METHOD(TexImage2DMultisample); - PY_MOD_ADD_METHOD(TexImage3DMultisample); -} -static void init_bgl_version_3_3_methods(PyObject * /*submodule*/, PyObject * /*dict*/) -{ - /* GL_VERSION_3_3 */ -} - -#define PY_DICT_ADD_INT(x) py_module_dict_add_int(dict, #x, x) -#define PY_DICT_ADD_INT64(x) py_module_dict_add_int64(dict, #x, x) - -static void init_bgl_version_1_1_constants(PyObject *dict) -{ - /* GL_VERSION_1_1 */ - PY_DICT_ADD_INT(GL_ALPHA); - PY_DICT_ADD_INT(GL_ALWAYS); - PY_DICT_ADD_INT(GL_AND); - PY_DICT_ADD_INT(GL_AND_INVERTED); - PY_DICT_ADD_INT(GL_AND_REVERSE); - PY_DICT_ADD_INT(GL_BACK); - PY_DICT_ADD_INT(GL_BACK_LEFT); - PY_DICT_ADD_INT(GL_BACK_RIGHT); - PY_DICT_ADD_INT(GL_BLEND); - PY_DICT_ADD_INT(GL_BLEND_DST); - PY_DICT_ADD_INT(GL_BLEND_SRC); - PY_DICT_ADD_INT(GL_BLUE); - PY_DICT_ADD_INT(GL_BYTE); - PY_DICT_ADD_INT(GL_CCW); - PY_DICT_ADD_INT(GL_CLEAR); - PY_DICT_ADD_INT(GL_COLOR); - PY_DICT_ADD_INT(GL_COLOR_BUFFER_BIT); - PY_DICT_ADD_INT(GL_COLOR_CLEAR_VALUE); - PY_DICT_ADD_INT(GL_COLOR_LOGIC_OP); - PY_DICT_ADD_INT(GL_COLOR_WRITEMASK); - PY_DICT_ADD_INT(GL_COPY); - PY_DICT_ADD_INT(GL_COPY_INVERTED); - PY_DICT_ADD_INT(GL_CULL_FACE); - PY_DICT_ADD_INT(GL_CULL_FACE_MODE); - PY_DICT_ADD_INT(GL_CW); - PY_DICT_ADD_INT(GL_DECR); - PY_DICT_ADD_INT(GL_DEPTH); - PY_DICT_ADD_INT(GL_DEPTH_BUFFER_BIT); - PY_DICT_ADD_INT(GL_DEPTH_CLEAR_VALUE); - PY_DICT_ADD_INT(GL_DEPTH_COMPONENT); - PY_DICT_ADD_INT(GL_DEPTH_FUNC); - PY_DICT_ADD_INT(GL_DEPTH_RANGE); - PY_DICT_ADD_INT(GL_DEPTH_TEST); - PY_DICT_ADD_INT(GL_DEPTH_WRITEMASK); - PY_DICT_ADD_INT(GL_DITHER); - PY_DICT_ADD_INT(GL_DONT_CARE); - PY_DICT_ADD_INT(GL_DOUBLE); - PY_DICT_ADD_INT(GL_DOUBLEBUFFER); - PY_DICT_ADD_INT(GL_DRAW_BUFFER); - PY_DICT_ADD_INT(GL_DST_ALPHA); - PY_DICT_ADD_INT(GL_DST_COLOR); - PY_DICT_ADD_INT(GL_EQUAL); - PY_DICT_ADD_INT(GL_EQUIV); - PY_DICT_ADD_INT(GL_EXTENSIONS); - PY_DICT_ADD_INT(GL_FALSE); - PY_DICT_ADD_INT(GL_FASTEST); - PY_DICT_ADD_INT(GL_FILL); - PY_DICT_ADD_INT(GL_FLOAT); - PY_DICT_ADD_INT(GL_FRONT); - PY_DICT_ADD_INT(GL_FRONT_AND_BACK); - PY_DICT_ADD_INT(GL_FRONT_FACE); - PY_DICT_ADD_INT(GL_FRONT_LEFT); - PY_DICT_ADD_INT(GL_FRONT_RIGHT); - PY_DICT_ADD_INT(GL_GEQUAL); - PY_DICT_ADD_INT(GL_GREATER); - PY_DICT_ADD_INT(GL_GREEN); - PY_DICT_ADD_INT(GL_INCR); - PY_DICT_ADD_INT(GL_INT); - PY_DICT_ADD_INT(GL_INVALID_ENUM); - PY_DICT_ADD_INT(GL_INVALID_OPERATION); - PY_DICT_ADD_INT(GL_INVALID_VALUE); - PY_DICT_ADD_INT(GL_INVERT); - PY_DICT_ADD_INT(GL_KEEP); - PY_DICT_ADD_INT(GL_LEFT); - PY_DICT_ADD_INT(GL_LEQUAL); - PY_DICT_ADD_INT(GL_LESS); - PY_DICT_ADD_INT(GL_LINE); - PY_DICT_ADD_INT(GL_LINEAR); - PY_DICT_ADD_INT(GL_LINEAR_MIPMAP_LINEAR); - PY_DICT_ADD_INT(GL_LINEAR_MIPMAP_NEAREST); - PY_DICT_ADD_INT(GL_LINES); - PY_DICT_ADD_INT(GL_LINE_LOOP); - PY_DICT_ADD_INT(GL_LINE_SMOOTH); - PY_DICT_ADD_INT(GL_LINE_SMOOTH_HINT); - PY_DICT_ADD_INT(GL_LINE_STRIP); - PY_DICT_ADD_INT(GL_LINE_WIDTH); - PY_DICT_ADD_INT(GL_LINE_WIDTH_GRANULARITY); - PY_DICT_ADD_INT(GL_LINE_WIDTH_RANGE); - PY_DICT_ADD_INT(GL_LOGIC_OP_MODE); - PY_DICT_ADD_INT(GL_MAX_TEXTURE_SIZE); - PY_DICT_ADD_INT(GL_MAX_VIEWPORT_DIMS); - PY_DICT_ADD_INT(GL_NAND); - PY_DICT_ADD_INT(GL_NEAREST); - PY_DICT_ADD_INT(GL_NEAREST_MIPMAP_LINEAR); - PY_DICT_ADD_INT(GL_NEAREST_MIPMAP_NEAREST); - PY_DICT_ADD_INT(GL_NEVER); - PY_DICT_ADD_INT(GL_NICEST); - PY_DICT_ADD_INT(GL_NONE); - PY_DICT_ADD_INT(GL_NOOP); - PY_DICT_ADD_INT(GL_NOR); - PY_DICT_ADD_INT(GL_NOTEQUAL); - PY_DICT_ADD_INT(GL_NO_ERROR); - PY_DICT_ADD_INT(GL_ONE); - PY_DICT_ADD_INT(GL_ONE_MINUS_DST_ALPHA); - PY_DICT_ADD_INT(GL_ONE_MINUS_DST_COLOR); - PY_DICT_ADD_INT(GL_ONE_MINUS_SRC_ALPHA); - PY_DICT_ADD_INT(GL_ONE_MINUS_SRC_COLOR); - PY_DICT_ADD_INT(GL_OR); - PY_DICT_ADD_INT(GL_OR_INVERTED); - PY_DICT_ADD_INT(GL_OR_REVERSE); - PY_DICT_ADD_INT(GL_OUT_OF_MEMORY); - PY_DICT_ADD_INT(GL_PACK_ALIGNMENT); - PY_DICT_ADD_INT(GL_PACK_LSB_FIRST); - PY_DICT_ADD_INT(GL_PACK_ROW_LENGTH); - PY_DICT_ADD_INT(GL_PACK_SKIP_PIXELS); - PY_DICT_ADD_INT(GL_PACK_SKIP_ROWS); - PY_DICT_ADD_INT(GL_PACK_SWAP_BYTES); - PY_DICT_ADD_INT(GL_POINT); - PY_DICT_ADD_INT(GL_POINTS); - PY_DICT_ADD_INT(GL_POINT_SIZE); - PY_DICT_ADD_INT(GL_POLYGON_MODE); - PY_DICT_ADD_INT(GL_POLYGON_OFFSET_FACTOR); - PY_DICT_ADD_INT(GL_POLYGON_OFFSET_FILL); - PY_DICT_ADD_INT(GL_POLYGON_OFFSET_LINE); - PY_DICT_ADD_INT(GL_POLYGON_OFFSET_POINT); - PY_DICT_ADD_INT(GL_POLYGON_OFFSET_UNITS); - PY_DICT_ADD_INT(GL_POLYGON_SMOOTH); - PY_DICT_ADD_INT(GL_POLYGON_SMOOTH_HINT); - PY_DICT_ADD_INT(GL_PROXY_TEXTURE_1D); - PY_DICT_ADD_INT(GL_PROXY_TEXTURE_2D); - PY_DICT_ADD_INT(GL_R3_G3_B2); - PY_DICT_ADD_INT(GL_READ_BUFFER); - PY_DICT_ADD_INT(GL_RED); - PY_DICT_ADD_INT(GL_RENDERER); - PY_DICT_ADD_INT(GL_REPEAT); - PY_DICT_ADD_INT(GL_REPLACE); - PY_DICT_ADD_INT(GL_RGB); - PY_DICT_ADD_INT(GL_RGB10); - PY_DICT_ADD_INT(GL_RGB10_A2); - PY_DICT_ADD_INT(GL_RGB12); - PY_DICT_ADD_INT(GL_RGB16); - PY_DICT_ADD_INT(GL_RGB4); - PY_DICT_ADD_INT(GL_RGB5); - PY_DICT_ADD_INT(GL_RGB5_A1); - PY_DICT_ADD_INT(GL_RGB8); - PY_DICT_ADD_INT(GL_RGBA); - PY_DICT_ADD_INT(GL_RGBA12); - PY_DICT_ADD_INT(GL_RGBA16); - PY_DICT_ADD_INT(GL_RGBA2); - PY_DICT_ADD_INT(GL_RGBA4); - PY_DICT_ADD_INT(GL_RGBA8); - PY_DICT_ADD_INT(GL_RIGHT); - PY_DICT_ADD_INT(GL_SCISSOR_BOX); - PY_DICT_ADD_INT(GL_SCISSOR_TEST); - PY_DICT_ADD_INT(GL_SET); - PY_DICT_ADD_INT(GL_SHORT); - PY_DICT_ADD_INT(GL_SRC_ALPHA); - PY_DICT_ADD_INT(GL_SRC_ALPHA_SATURATE); - PY_DICT_ADD_INT(GL_SRC_COLOR); - PY_DICT_ADD_INT(GL_STENCIL); - PY_DICT_ADD_INT(GL_STENCIL_BUFFER_BIT); - PY_DICT_ADD_INT(GL_STENCIL_CLEAR_VALUE); - PY_DICT_ADD_INT(GL_STENCIL_FAIL); - PY_DICT_ADD_INT(GL_STENCIL_FUNC); - PY_DICT_ADD_INT(GL_STENCIL_INDEX); - PY_DICT_ADD_INT(GL_STENCIL_PASS_DEPTH_FAIL); - PY_DICT_ADD_INT(GL_STENCIL_PASS_DEPTH_PASS); - PY_DICT_ADD_INT(GL_STENCIL_REF); - PY_DICT_ADD_INT(GL_STENCIL_TEST); - PY_DICT_ADD_INT(GL_STENCIL_VALUE_MASK); - PY_DICT_ADD_INT(GL_STENCIL_WRITEMASK); - PY_DICT_ADD_INT(GL_STEREO); - PY_DICT_ADD_INT(GL_SUBPIXEL_BITS); - PY_DICT_ADD_INT(GL_TEXTURE); - PY_DICT_ADD_INT(GL_TEXTURE_1D); - PY_DICT_ADD_INT(GL_TEXTURE_2D); - PY_DICT_ADD_INT(GL_TEXTURE_ALPHA_SIZE); - PY_DICT_ADD_INT(GL_TEXTURE_BINDING_1D); - PY_DICT_ADD_INT(GL_TEXTURE_BINDING_2D); - PY_DICT_ADD_INT(GL_TEXTURE_BLUE_SIZE); - PY_DICT_ADD_INT(GL_TEXTURE_BORDER_COLOR); - PY_DICT_ADD_INT(GL_TEXTURE_GREEN_SIZE); - PY_DICT_ADD_INT(GL_TEXTURE_HEIGHT); - PY_DICT_ADD_INT(GL_TEXTURE_INTERNAL_FORMAT); - PY_DICT_ADD_INT(GL_TEXTURE_MAG_FILTER); - PY_DICT_ADD_INT(GL_TEXTURE_MIN_FILTER); - PY_DICT_ADD_INT(GL_TEXTURE_RED_SIZE); - PY_DICT_ADD_INT(GL_TEXTURE_WIDTH); - PY_DICT_ADD_INT(GL_TEXTURE_WRAP_S); - PY_DICT_ADD_INT(GL_TEXTURE_WRAP_T); - PY_DICT_ADD_INT(GL_TRIANGLES); - PY_DICT_ADD_INT(GL_TRIANGLE_FAN); - PY_DICT_ADD_INT(GL_TRIANGLE_STRIP); - PY_DICT_ADD_INT(GL_TRUE); - PY_DICT_ADD_INT(GL_UNPACK_ALIGNMENT); - PY_DICT_ADD_INT(GL_UNPACK_LSB_FIRST); - PY_DICT_ADD_INT(GL_UNPACK_ROW_LENGTH); - PY_DICT_ADD_INT(GL_UNPACK_SKIP_PIXELS); - PY_DICT_ADD_INT(GL_UNPACK_SKIP_ROWS); - PY_DICT_ADD_INT(GL_UNPACK_SWAP_BYTES); - PY_DICT_ADD_INT(GL_UNSIGNED_BYTE); - PY_DICT_ADD_INT(GL_UNSIGNED_INT); - PY_DICT_ADD_INT(GL_UNSIGNED_SHORT); - PY_DICT_ADD_INT(GL_VENDOR); - PY_DICT_ADD_INT(GL_VERSION); - PY_DICT_ADD_INT(GL_VIEWPORT); - PY_DICT_ADD_INT(GL_XOR); - PY_DICT_ADD_INT(GL_ZERO); -} -static void init_bgl_version_1_2_constants(PyObject *dict) -{ - /* GL_VERSION_1_2 */ - PY_DICT_ADD_INT(GL_ALIASED_LINE_WIDTH_RANGE); - PY_DICT_ADD_INT(GL_BGR); - PY_DICT_ADD_INT(GL_BGRA); - PY_DICT_ADD_INT(GL_CLAMP_TO_EDGE); - PY_DICT_ADD_INT(GL_MAX_3D_TEXTURE_SIZE); - PY_DICT_ADD_INT(GL_MAX_ELEMENTS_INDICES); - PY_DICT_ADD_INT(GL_MAX_ELEMENTS_VERTICES); - PY_DICT_ADD_INT(GL_PACK_IMAGE_HEIGHT); - PY_DICT_ADD_INT(GL_PACK_SKIP_IMAGES); - PY_DICT_ADD_INT(GL_PROXY_TEXTURE_3D); - PY_DICT_ADD_INT(GL_SMOOTH_LINE_WIDTH_GRANULARITY); - PY_DICT_ADD_INT(GL_SMOOTH_LINE_WIDTH_RANGE); - PY_DICT_ADD_INT(GL_SMOOTH_POINT_SIZE_GRANULARITY); - PY_DICT_ADD_INT(GL_SMOOTH_POINT_SIZE_RANGE); - PY_DICT_ADD_INT(GL_TEXTURE_3D); - PY_DICT_ADD_INT(GL_TEXTURE_BASE_LEVEL); - PY_DICT_ADD_INT(GL_TEXTURE_BINDING_3D); - PY_DICT_ADD_INT(GL_TEXTURE_DEPTH); - PY_DICT_ADD_INT(GL_TEXTURE_MAX_LEVEL); - PY_DICT_ADD_INT(GL_TEXTURE_MAX_LOD); - PY_DICT_ADD_INT(GL_TEXTURE_MIN_LOD); - PY_DICT_ADD_INT(GL_TEXTURE_WRAP_R); - PY_DICT_ADD_INT(GL_UNPACK_IMAGE_HEIGHT); - PY_DICT_ADD_INT(GL_UNPACK_SKIP_IMAGES); - PY_DICT_ADD_INT(GL_UNSIGNED_BYTE_2_3_3_REV); - PY_DICT_ADD_INT(GL_UNSIGNED_BYTE_3_3_2); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_10_10_10_2); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_2_10_10_10_REV); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_8_8_8_8); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_8_8_8_8_REV); - PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_1_5_5_5_REV); - PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_4_4_4_4); - PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_4_4_4_4_REV); - PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_5_5_5_1); - PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_5_6_5); - PY_DICT_ADD_INT(GL_UNSIGNED_SHORT_5_6_5_REV); -} -static void init_bgl_version_1_3_constants(PyObject *dict) -{ - /* GL_VERSION_1_3 */ - PY_DICT_ADD_INT(GL_ACTIVE_TEXTURE); - PY_DICT_ADD_INT(GL_CLAMP_TO_BORDER); - PY_DICT_ADD_INT(GL_COMPRESSED_RGB); - PY_DICT_ADD_INT(GL_COMPRESSED_RGBA); - PY_DICT_ADD_INT(GL_COMPRESSED_TEXTURE_FORMATS); - PY_DICT_ADD_INT(GL_MAX_CUBE_MAP_TEXTURE_SIZE); - PY_DICT_ADD_INT(GL_MULTISAMPLE); - PY_DICT_ADD_INT(GL_NUM_COMPRESSED_TEXTURE_FORMATS); - PY_DICT_ADD_INT(GL_PROXY_TEXTURE_CUBE_MAP); - PY_DICT_ADD_INT(GL_SAMPLES); - PY_DICT_ADD_INT(GL_SAMPLE_ALPHA_TO_COVERAGE); - PY_DICT_ADD_INT(GL_SAMPLE_ALPHA_TO_ONE); - PY_DICT_ADD_INT(GL_SAMPLE_BUFFERS); - PY_DICT_ADD_INT(GL_SAMPLE_COVERAGE); - PY_DICT_ADD_INT(GL_SAMPLE_COVERAGE_INVERT); - PY_DICT_ADD_INT(GL_SAMPLE_COVERAGE_VALUE); - PY_DICT_ADD_INT(GL_TEXTURE0); - PY_DICT_ADD_INT(GL_TEXTURE1); - PY_DICT_ADD_INT(GL_TEXTURE10); - PY_DICT_ADD_INT(GL_TEXTURE11); - PY_DICT_ADD_INT(GL_TEXTURE12); - PY_DICT_ADD_INT(GL_TEXTURE13); - PY_DICT_ADD_INT(GL_TEXTURE14); - PY_DICT_ADD_INT(GL_TEXTURE15); - PY_DICT_ADD_INT(GL_TEXTURE16); - PY_DICT_ADD_INT(GL_TEXTURE17); - PY_DICT_ADD_INT(GL_TEXTURE18); - PY_DICT_ADD_INT(GL_TEXTURE19); - PY_DICT_ADD_INT(GL_TEXTURE2); - PY_DICT_ADD_INT(GL_TEXTURE20); - PY_DICT_ADD_INT(GL_TEXTURE21); - PY_DICT_ADD_INT(GL_TEXTURE22); - PY_DICT_ADD_INT(GL_TEXTURE23); - PY_DICT_ADD_INT(GL_TEXTURE24); - PY_DICT_ADD_INT(GL_TEXTURE25); - PY_DICT_ADD_INT(GL_TEXTURE26); - PY_DICT_ADD_INT(GL_TEXTURE27); - PY_DICT_ADD_INT(GL_TEXTURE28); - PY_DICT_ADD_INT(GL_TEXTURE29); - PY_DICT_ADD_INT(GL_TEXTURE3); - PY_DICT_ADD_INT(GL_TEXTURE30); - PY_DICT_ADD_INT(GL_TEXTURE31); - PY_DICT_ADD_INT(GL_TEXTURE4); - PY_DICT_ADD_INT(GL_TEXTURE5); - PY_DICT_ADD_INT(GL_TEXTURE6); - PY_DICT_ADD_INT(GL_TEXTURE7); - PY_DICT_ADD_INT(GL_TEXTURE8); - PY_DICT_ADD_INT(GL_TEXTURE9); - PY_DICT_ADD_INT(GL_TEXTURE_BINDING_CUBE_MAP); - PY_DICT_ADD_INT(GL_TEXTURE_COMPRESSED); - PY_DICT_ADD_INT(GL_TEXTURE_COMPRESSED_IMAGE_SIZE); - PY_DICT_ADD_INT(GL_TEXTURE_COMPRESSION_HINT); - PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP); - PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_NEGATIVE_X); - PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y); - PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z); - PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_POSITIVE_X); - PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_POSITIVE_Y); - PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_POSITIVE_Z); -} -static void init_bgl_version_1_4_constants(PyObject *dict) -{ - /* GL_VERSION_1_4 */ - PY_DICT_ADD_INT(GL_BLEND_DST_ALPHA); - PY_DICT_ADD_INT(GL_BLEND_DST_RGB); - PY_DICT_ADD_INT(GL_BLEND_SRC_ALPHA); - PY_DICT_ADD_INT(GL_BLEND_SRC_RGB); - PY_DICT_ADD_INT(GL_CONSTANT_ALPHA); - PY_DICT_ADD_INT(GL_CONSTANT_COLOR); - PY_DICT_ADD_INT(GL_DECR_WRAP); - PY_DICT_ADD_INT(GL_DEPTH_COMPONENT16); - PY_DICT_ADD_INT(GL_DEPTH_COMPONENT24); - PY_DICT_ADD_INT(GL_DEPTH_COMPONENT32); - PY_DICT_ADD_INT(GL_FUNC_ADD); - PY_DICT_ADD_INT(GL_FUNC_REVERSE_SUBTRACT); - PY_DICT_ADD_INT(GL_FUNC_SUBTRACT); - PY_DICT_ADD_INT(GL_INCR_WRAP); - PY_DICT_ADD_INT(GL_MAX); - PY_DICT_ADD_INT(GL_MAX_TEXTURE_LOD_BIAS); - PY_DICT_ADD_INT(GL_MIN); - PY_DICT_ADD_INT(GL_MIRRORED_REPEAT); - PY_DICT_ADD_INT(GL_ONE_MINUS_CONSTANT_ALPHA); - PY_DICT_ADD_INT(GL_ONE_MINUS_CONSTANT_COLOR); - PY_DICT_ADD_INT(GL_POINT_FADE_THRESHOLD_SIZE); - PY_DICT_ADD_INT(GL_TEXTURE_COMPARE_FUNC); - PY_DICT_ADD_INT(GL_TEXTURE_COMPARE_MODE); - PY_DICT_ADD_INT(GL_TEXTURE_DEPTH_SIZE); - PY_DICT_ADD_INT(GL_TEXTURE_LOD_BIAS); -} -static void init_bgl_version_1_5_constants(PyObject *dict) -{ - /* GL_VERSION_1_5 */ - PY_DICT_ADD_INT(GL_ARRAY_BUFFER); - PY_DICT_ADD_INT(GL_ARRAY_BUFFER_BINDING); - PY_DICT_ADD_INT(GL_BUFFER_ACCESS); - PY_DICT_ADD_INT(GL_BUFFER_MAPPED); - PY_DICT_ADD_INT(GL_BUFFER_MAP_POINTER); - PY_DICT_ADD_INT(GL_BUFFER_SIZE); - PY_DICT_ADD_INT(GL_BUFFER_USAGE); - PY_DICT_ADD_INT(GL_CURRENT_QUERY); - PY_DICT_ADD_INT(GL_DYNAMIC_COPY); - PY_DICT_ADD_INT(GL_DYNAMIC_DRAW); - PY_DICT_ADD_INT(GL_DYNAMIC_READ); - PY_DICT_ADD_INT(GL_ELEMENT_ARRAY_BUFFER); - PY_DICT_ADD_INT(GL_ELEMENT_ARRAY_BUFFER_BINDING); - PY_DICT_ADD_INT(GL_QUERY_COUNTER_BITS); - PY_DICT_ADD_INT(GL_QUERY_RESULT); - PY_DICT_ADD_INT(GL_QUERY_RESULT_AVAILABLE); - PY_DICT_ADD_INT(GL_READ_ONLY); - PY_DICT_ADD_INT(GL_READ_WRITE); - PY_DICT_ADD_INT(GL_SAMPLES_PASSED); - PY_DICT_ADD_INT(GL_STATIC_COPY); - PY_DICT_ADD_INT(GL_STATIC_DRAW); - PY_DICT_ADD_INT(GL_STATIC_READ); - PY_DICT_ADD_INT(GL_STREAM_COPY); - PY_DICT_ADD_INT(GL_STREAM_DRAW); - PY_DICT_ADD_INT(GL_STREAM_READ); - PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING); - PY_DICT_ADD_INT(GL_WRITE_ONLY); -} -static void init_bgl_version_2_0_constants(PyObject *dict) -{ - /* GL_VERSION_2_0 */ - PY_DICT_ADD_INT(GL_ACTIVE_ATTRIBUTES); - PY_DICT_ADD_INT(GL_ACTIVE_ATTRIBUTE_MAX_LENGTH); - PY_DICT_ADD_INT(GL_ACTIVE_UNIFORMS); - PY_DICT_ADD_INT(GL_ACTIVE_UNIFORM_MAX_LENGTH); - PY_DICT_ADD_INT(GL_ATTACHED_SHADERS); - PY_DICT_ADD_INT(GL_BLEND_EQUATION_ALPHA); - PY_DICT_ADD_INT(GL_BLEND_EQUATION_RGB); - PY_DICT_ADD_INT(GL_BOOL); - PY_DICT_ADD_INT(GL_BOOL_VEC2); - PY_DICT_ADD_INT(GL_BOOL_VEC3); - PY_DICT_ADD_INT(GL_BOOL_VEC4); - PY_DICT_ADD_INT(GL_COMPILE_STATUS); - PY_DICT_ADD_INT(GL_CURRENT_PROGRAM); - PY_DICT_ADD_INT(GL_CURRENT_VERTEX_ATTRIB); - PY_DICT_ADD_INT(GL_DELETE_STATUS); - PY_DICT_ADD_INT(GL_DRAW_BUFFER0); - PY_DICT_ADD_INT(GL_DRAW_BUFFER1); - PY_DICT_ADD_INT(GL_DRAW_BUFFER10); - PY_DICT_ADD_INT(GL_DRAW_BUFFER11); - PY_DICT_ADD_INT(GL_DRAW_BUFFER12); - PY_DICT_ADD_INT(GL_DRAW_BUFFER13); - PY_DICT_ADD_INT(GL_DRAW_BUFFER14); - PY_DICT_ADD_INT(GL_DRAW_BUFFER15); - PY_DICT_ADD_INT(GL_DRAW_BUFFER2); - PY_DICT_ADD_INT(GL_DRAW_BUFFER3); - PY_DICT_ADD_INT(GL_DRAW_BUFFER4); - PY_DICT_ADD_INT(GL_DRAW_BUFFER5); - PY_DICT_ADD_INT(GL_DRAW_BUFFER6); - PY_DICT_ADD_INT(GL_DRAW_BUFFER7); - PY_DICT_ADD_INT(GL_DRAW_BUFFER8); - PY_DICT_ADD_INT(GL_DRAW_BUFFER9); - PY_DICT_ADD_INT(GL_FLOAT_MAT2); - PY_DICT_ADD_INT(GL_FLOAT_MAT3); - PY_DICT_ADD_INT(GL_FLOAT_MAT4); - PY_DICT_ADD_INT(GL_FLOAT_VEC2); - PY_DICT_ADD_INT(GL_FLOAT_VEC3); - PY_DICT_ADD_INT(GL_FLOAT_VEC4); - PY_DICT_ADD_INT(GL_FRAGMENT_SHADER); - PY_DICT_ADD_INT(GL_FRAGMENT_SHADER_DERIVATIVE_HINT); - PY_DICT_ADD_INT(GL_INFO_LOG_LENGTH); - PY_DICT_ADD_INT(GL_INT_VEC2); - PY_DICT_ADD_INT(GL_INT_VEC3); - PY_DICT_ADD_INT(GL_INT_VEC4); - PY_DICT_ADD_INT(GL_LINK_STATUS); - PY_DICT_ADD_INT(GL_LOWER_LEFT); - PY_DICT_ADD_INT(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS); - PY_DICT_ADD_INT(GL_MAX_DRAW_BUFFERS); - PY_DICT_ADD_INT(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS); - PY_DICT_ADD_INT(GL_MAX_TEXTURE_IMAGE_UNITS); - PY_DICT_ADD_INT(GL_MAX_VARYING_FLOATS); - PY_DICT_ADD_INT(GL_MAX_VERTEX_ATTRIBS); - PY_DICT_ADD_INT(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS); - PY_DICT_ADD_INT(GL_MAX_VERTEX_UNIFORM_COMPONENTS); - PY_DICT_ADD_INT(GL_POINT_SPRITE_COORD_ORIGIN); - PY_DICT_ADD_INT(GL_SAMPLER_1D); - PY_DICT_ADD_INT(GL_SAMPLER_1D_SHADOW); - PY_DICT_ADD_INT(GL_SAMPLER_2D); - PY_DICT_ADD_INT(GL_SAMPLER_2D_SHADOW); - PY_DICT_ADD_INT(GL_SAMPLER_3D); - PY_DICT_ADD_INT(GL_SAMPLER_CUBE); - PY_DICT_ADD_INT(GL_SHADER_SOURCE_LENGTH); - PY_DICT_ADD_INT(GL_SHADER_TYPE); - PY_DICT_ADD_INT(GL_SHADING_LANGUAGE_VERSION); - PY_DICT_ADD_INT(GL_STENCIL_BACK_FAIL); - PY_DICT_ADD_INT(GL_STENCIL_BACK_FUNC); - PY_DICT_ADD_INT(GL_STENCIL_BACK_PASS_DEPTH_FAIL); - PY_DICT_ADD_INT(GL_STENCIL_BACK_PASS_DEPTH_PASS); - PY_DICT_ADD_INT(GL_STENCIL_BACK_REF); - PY_DICT_ADD_INT(GL_STENCIL_BACK_VALUE_MASK); - PY_DICT_ADD_INT(GL_STENCIL_BACK_WRITEMASK); - PY_DICT_ADD_INT(GL_UPPER_LEFT); - PY_DICT_ADD_INT(GL_VALIDATE_STATUS); - PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_ENABLED); - PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_NORMALIZED); - PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_POINTER); - PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_SIZE); - PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_STRIDE); - PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_TYPE); - PY_DICT_ADD_INT(GL_VERTEX_PROGRAM_POINT_SIZE); - PY_DICT_ADD_INT(GL_VERTEX_SHADER); -} -static void init_bgl_version_2_1_constants(PyObject *dict) -{ - /* GL_VERSION_2_1 */ - PY_DICT_ADD_INT(GL_COMPRESSED_SRGB); - PY_DICT_ADD_INT(GL_COMPRESSED_SRGB_ALPHA); - PY_DICT_ADD_INT(GL_FLOAT_MAT2x3); - PY_DICT_ADD_INT(GL_FLOAT_MAT2x4); - PY_DICT_ADD_INT(GL_FLOAT_MAT3x2); - PY_DICT_ADD_INT(GL_FLOAT_MAT3x4); - PY_DICT_ADD_INT(GL_FLOAT_MAT4x2); - PY_DICT_ADD_INT(GL_FLOAT_MAT4x3); - PY_DICT_ADD_INT(GL_PIXEL_PACK_BUFFER); - PY_DICT_ADD_INT(GL_PIXEL_PACK_BUFFER_BINDING); - PY_DICT_ADD_INT(GL_PIXEL_UNPACK_BUFFER); - PY_DICT_ADD_INT(GL_PIXEL_UNPACK_BUFFER_BINDING); - PY_DICT_ADD_INT(GL_SRGB); - PY_DICT_ADD_INT(GL_SRGB8); - PY_DICT_ADD_INT(GL_SRGB8_ALPHA8); - PY_DICT_ADD_INT(GL_SRGB_ALPHA); -} -static void init_bgl_version_3_0_constants(PyObject *dict) -{ - /* GL_VERSION_3_0 */ - PY_DICT_ADD_INT(GL_BGRA_INTEGER); - PY_DICT_ADD_INT(GL_BGR_INTEGER); - PY_DICT_ADD_INT(GL_BLUE_INTEGER); - PY_DICT_ADD_INT(GL_BUFFER_ACCESS_FLAGS); - PY_DICT_ADD_INT(GL_BUFFER_MAP_LENGTH); - PY_DICT_ADD_INT(GL_BUFFER_MAP_OFFSET); - PY_DICT_ADD_INT(GL_CLAMP_READ_COLOR); - PY_DICT_ADD_INT(GL_CLIP_DISTANCE0); - PY_DICT_ADD_INT(GL_CLIP_DISTANCE1); - PY_DICT_ADD_INT(GL_CLIP_DISTANCE2); - PY_DICT_ADD_INT(GL_CLIP_DISTANCE3); - PY_DICT_ADD_INT(GL_CLIP_DISTANCE4); - PY_DICT_ADD_INT(GL_CLIP_DISTANCE5); -#if 0 - PY_DICT_ADD_INT(GL_CLIP_DISTANCE6); - PY_DICT_ADD_INT(GL_CLIP_DISTANCE7); -#endif - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT0); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT1); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT2); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT3); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT4); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT5); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT6); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT7); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT8); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT9); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT10); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT11); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT12); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT13); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT14); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT15); -#if 0 - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT16); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT17); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT18); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT19); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT20); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT21); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT22); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT23); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT24); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT25); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT26); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT27); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT28); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT29); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT30); - PY_DICT_ADD_INT(GL_COLOR_ATTACHMENT31); -#endif - PY_DICT_ADD_INT(GL_COMPARE_REF_TO_TEXTURE); - PY_DICT_ADD_INT(GL_COMPRESSED_RED); - PY_DICT_ADD_INT(GL_COMPRESSED_RED_RGTC1); - PY_DICT_ADD_INT(GL_COMPRESSED_RG); - PY_DICT_ADD_INT(GL_COMPRESSED_RG_RGTC2); - PY_DICT_ADD_INT(GL_COMPRESSED_SIGNED_RED_RGTC1); - PY_DICT_ADD_INT(GL_COMPRESSED_SIGNED_RG_RGTC2); - PY_DICT_ADD_INT(GL_CONTEXT_FLAGS); - PY_DICT_ADD_INT(GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT); - PY_DICT_ADD_INT(GL_DEPTH24_STENCIL8); - PY_DICT_ADD_INT(GL_DEPTH32F_STENCIL8); - PY_DICT_ADD_INT(GL_DEPTH_ATTACHMENT); - PY_DICT_ADD_INT(GL_DEPTH_COMPONENT32F); - PY_DICT_ADD_INT(GL_DEPTH_STENCIL); - PY_DICT_ADD_INT(GL_DEPTH_STENCIL_ATTACHMENT); - PY_DICT_ADD_INT(GL_DRAW_FRAMEBUFFER); - PY_DICT_ADD_INT(GL_DRAW_FRAMEBUFFER_BINDING); - PY_DICT_ADD_INT(GL_FIXED_ONLY); - PY_DICT_ADD_INT(GL_FLOAT_32_UNSIGNED_INT_24_8_REV); - PY_DICT_ADD_INT(GL_FRAMEBUFFER); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_BINDING); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_COMPLETE); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_DEFAULT); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_SRGB); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_UNDEFINED); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_UNSUPPORTED); - PY_DICT_ADD_INT(GL_GREEN_INTEGER); - PY_DICT_ADD_INT(GL_HALF_FLOAT); - PY_DICT_ADD_INT(GL_INDEX); - PY_DICT_ADD_INT(GL_INTERLEAVED_ATTRIBS); - PY_DICT_ADD_INT(GL_INT_SAMPLER_1D); - PY_DICT_ADD_INT(GL_INT_SAMPLER_1D_ARRAY); - PY_DICT_ADD_INT(GL_INT_SAMPLER_2D); - PY_DICT_ADD_INT(GL_INT_SAMPLER_2D_ARRAY); - PY_DICT_ADD_INT(GL_INT_SAMPLER_3D); - PY_DICT_ADD_INT(GL_INT_SAMPLER_CUBE); - PY_DICT_ADD_INT(GL_INVALID_FRAMEBUFFER_OPERATION); - PY_DICT_ADD_INT(GL_MAJOR_VERSION); - PY_DICT_ADD_INT(GL_MAP_FLUSH_EXPLICIT_BIT); - PY_DICT_ADD_INT(GL_MAP_INVALIDATE_BUFFER_BIT); - PY_DICT_ADD_INT(GL_MAP_INVALIDATE_RANGE_BIT); - PY_DICT_ADD_INT(GL_MAP_READ_BIT); - PY_DICT_ADD_INT(GL_MAP_UNSYNCHRONIZED_BIT); - PY_DICT_ADD_INT(GL_MAP_WRITE_BIT); - PY_DICT_ADD_INT(GL_MAX_ARRAY_TEXTURE_LAYERS); - PY_DICT_ADD_INT(GL_MAX_CLIP_DISTANCES); - PY_DICT_ADD_INT(GL_MAX_COLOR_ATTACHMENTS); - PY_DICT_ADD_INT(GL_MAX_PROGRAM_TEXEL_OFFSET); - PY_DICT_ADD_INT(GL_MAX_RENDERBUFFER_SIZE); - PY_DICT_ADD_INT(GL_MAX_SAMPLES); - PY_DICT_ADD_INT(GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS); - PY_DICT_ADD_INT(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS); - PY_DICT_ADD_INT(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS); - PY_DICT_ADD_INT(GL_MAX_VARYING_COMPONENTS); - PY_DICT_ADD_INT(GL_MINOR_VERSION); - PY_DICT_ADD_INT(GL_MIN_PROGRAM_TEXEL_OFFSET); - PY_DICT_ADD_INT(GL_NUM_EXTENSIONS); - PY_DICT_ADD_INT(GL_PRIMITIVES_GENERATED); - PY_DICT_ADD_INT(GL_PROXY_TEXTURE_1D_ARRAY); - PY_DICT_ADD_INT(GL_PROXY_TEXTURE_2D_ARRAY); - PY_DICT_ADD_INT(GL_QUERY_BY_REGION_NO_WAIT); - PY_DICT_ADD_INT(GL_QUERY_BY_REGION_WAIT); - PY_DICT_ADD_INT(GL_QUERY_NO_WAIT); - PY_DICT_ADD_INT(GL_QUERY_WAIT); - PY_DICT_ADD_INT(GL_R11F_G11F_B10F); - PY_DICT_ADD_INT(GL_R16); - PY_DICT_ADD_INT(GL_R16F); - PY_DICT_ADD_INT(GL_R16I); - PY_DICT_ADD_INT(GL_R16UI); - PY_DICT_ADD_INT(GL_R32F); - PY_DICT_ADD_INT(GL_R32I); - PY_DICT_ADD_INT(GL_R32UI); - PY_DICT_ADD_INT(GL_R8); - PY_DICT_ADD_INT(GL_R8I); - PY_DICT_ADD_INT(GL_R8UI); - PY_DICT_ADD_INT(GL_RASTERIZER_DISCARD); - PY_DICT_ADD_INT(GL_READ_FRAMEBUFFER); - PY_DICT_ADD_INT(GL_READ_FRAMEBUFFER_BINDING); - PY_DICT_ADD_INT(GL_RED_INTEGER); - PY_DICT_ADD_INT(GL_RENDERBUFFER); - PY_DICT_ADD_INT(GL_RENDERBUFFER_ALPHA_SIZE); - PY_DICT_ADD_INT(GL_RENDERBUFFER_BINDING); - PY_DICT_ADD_INT(GL_RENDERBUFFER_BLUE_SIZE); - PY_DICT_ADD_INT(GL_RENDERBUFFER_DEPTH_SIZE); - PY_DICT_ADD_INT(GL_RENDERBUFFER_GREEN_SIZE); - PY_DICT_ADD_INT(GL_RENDERBUFFER_HEIGHT); - PY_DICT_ADD_INT(GL_RENDERBUFFER_INTERNAL_FORMAT); - PY_DICT_ADD_INT(GL_RENDERBUFFER_RED_SIZE); - PY_DICT_ADD_INT(GL_RENDERBUFFER_SAMPLES); - PY_DICT_ADD_INT(GL_RENDERBUFFER_STENCIL_SIZE); - PY_DICT_ADD_INT(GL_RENDERBUFFER_WIDTH); - PY_DICT_ADD_INT(GL_RG); - PY_DICT_ADD_INT(GL_RG16); - PY_DICT_ADD_INT(GL_RG16F); - PY_DICT_ADD_INT(GL_RG16I); - PY_DICT_ADD_INT(GL_RG16UI); - PY_DICT_ADD_INT(GL_RG32F); - PY_DICT_ADD_INT(GL_RG32I); - PY_DICT_ADD_INT(GL_RG32UI); - PY_DICT_ADD_INT(GL_RG8); - PY_DICT_ADD_INT(GL_RG8I); - PY_DICT_ADD_INT(GL_RG8UI); - PY_DICT_ADD_INT(GL_RGB16F); - PY_DICT_ADD_INT(GL_RGB16I); - PY_DICT_ADD_INT(GL_RGB16UI); - PY_DICT_ADD_INT(GL_RGB32F); - PY_DICT_ADD_INT(GL_RGB32I); - PY_DICT_ADD_INT(GL_RGB32UI); - PY_DICT_ADD_INT(GL_RGB8I); - PY_DICT_ADD_INT(GL_RGB8UI); - PY_DICT_ADD_INT(GL_RGB9_E5); - PY_DICT_ADD_INT(GL_RGBA16F); - PY_DICT_ADD_INT(GL_RGBA16I); - PY_DICT_ADD_INT(GL_RGBA16UI); - PY_DICT_ADD_INT(GL_RGBA32F); - PY_DICT_ADD_INT(GL_RGBA32I); - PY_DICT_ADD_INT(GL_RGBA32UI); - PY_DICT_ADD_INT(GL_RGBA8I); - PY_DICT_ADD_INT(GL_RGBA8UI); - PY_DICT_ADD_INT(GL_RGBA_INTEGER); - PY_DICT_ADD_INT(GL_RGB_INTEGER); - PY_DICT_ADD_INT(GL_RG_INTEGER); - PY_DICT_ADD_INT(GL_SAMPLER_1D_ARRAY); - PY_DICT_ADD_INT(GL_SAMPLER_1D_ARRAY_SHADOW); - PY_DICT_ADD_INT(GL_SAMPLER_2D_ARRAY); - PY_DICT_ADD_INT(GL_SAMPLER_2D_ARRAY_SHADOW); - PY_DICT_ADD_INT(GL_SAMPLER_CUBE_SHADOW); - PY_DICT_ADD_INT(GL_SEPARATE_ATTRIBS); - PY_DICT_ADD_INT(GL_STENCIL_ATTACHMENT); - PY_DICT_ADD_INT(GL_STENCIL_INDEX1); - PY_DICT_ADD_INT(GL_STENCIL_INDEX16); - PY_DICT_ADD_INT(GL_STENCIL_INDEX4); - PY_DICT_ADD_INT(GL_STENCIL_INDEX8); - PY_DICT_ADD_INT(GL_TEXTURE_1D_ARRAY); - PY_DICT_ADD_INT(GL_TEXTURE_2D_ARRAY); - PY_DICT_ADD_INT(GL_TEXTURE_ALPHA_TYPE); - PY_DICT_ADD_INT(GL_TEXTURE_BINDING_1D_ARRAY); - PY_DICT_ADD_INT(GL_TEXTURE_BINDING_2D_ARRAY); - PY_DICT_ADD_INT(GL_TEXTURE_BLUE_TYPE); - PY_DICT_ADD_INT(GL_TEXTURE_DEPTH_TYPE); - PY_DICT_ADD_INT(GL_TEXTURE_GREEN_TYPE); - PY_DICT_ADD_INT(GL_TEXTURE_RED_TYPE); - PY_DICT_ADD_INT(GL_TEXTURE_SHARED_SIZE); - PY_DICT_ADD_INT(GL_TEXTURE_STENCIL_SIZE); - PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_BUFFER); - PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_BUFFER_BINDING); - PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_BUFFER_MODE); - PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_BUFFER_SIZE); - PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_BUFFER_START); - PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); - PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_VARYINGS); - PY_DICT_ADD_INT(GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_10F_11F_11F_REV); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_24_8); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_5_9_9_9_REV); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_1D); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_1D_ARRAY); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_2D); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_2D_ARRAY); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_3D); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_CUBE); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_VEC2); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_VEC3); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_VEC4); - PY_DICT_ADD_INT(GL_UNSIGNED_NORMALIZED); - PY_DICT_ADD_INT(GL_VERTEX_ARRAY_BINDING); - PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_INTEGER); -} -static void init_bgl_version_3_1_constants(PyObject *dict) -{ - /* GL_VERSION_3_1 */ - PY_DICT_ADD_INT(GL_ACTIVE_UNIFORM_BLOCKS); - PY_DICT_ADD_INT(GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH); - PY_DICT_ADD_INT(GL_COPY_READ_BUFFER); - PY_DICT_ADD_INT(GL_COPY_WRITE_BUFFER); - PY_DICT_ADD_INT(GL_INT_SAMPLER_2D_RECT); - PY_DICT_ADD_INT(GL_INT_SAMPLER_BUFFER); - PY_DICT_ADD_INT(GL_INVALID_INDEX); - PY_DICT_ADD_INT(GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS); - PY_DICT_ADD_INT(GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS); - PY_DICT_ADD_INT(GL_MAX_COMBINED_UNIFORM_BLOCKS); - PY_DICT_ADD_INT(GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS); - PY_DICT_ADD_INT(GL_MAX_FRAGMENT_UNIFORM_BLOCKS); - PY_DICT_ADD_INT(GL_MAX_GEOMETRY_UNIFORM_BLOCKS); - PY_DICT_ADD_INT(GL_MAX_RECTANGLE_TEXTURE_SIZE); - PY_DICT_ADD_INT(GL_MAX_TEXTURE_BUFFER_SIZE); - PY_DICT_ADD_INT(GL_MAX_UNIFORM_BLOCK_SIZE); - PY_DICT_ADD_INT(GL_MAX_UNIFORM_BUFFER_BINDINGS); - PY_DICT_ADD_INT(GL_MAX_VERTEX_UNIFORM_BLOCKS); - PY_DICT_ADD_INT(GL_PRIMITIVE_RESTART); - PY_DICT_ADD_INT(GL_PRIMITIVE_RESTART_INDEX); - PY_DICT_ADD_INT(GL_PROXY_TEXTURE_RECTANGLE); - PY_DICT_ADD_INT(GL_R16_SNORM); - PY_DICT_ADD_INT(GL_R8_SNORM); - PY_DICT_ADD_INT(GL_RG16_SNORM); - PY_DICT_ADD_INT(GL_RG8_SNORM); - PY_DICT_ADD_INT(GL_RGB16_SNORM); - PY_DICT_ADD_INT(GL_RGB8_SNORM); - PY_DICT_ADD_INT(GL_RGBA16_SNORM); - PY_DICT_ADD_INT(GL_RGBA8_SNORM); - PY_DICT_ADD_INT(GL_SAMPLER_2D_RECT); - PY_DICT_ADD_INT(GL_SAMPLER_2D_RECT_SHADOW); - PY_DICT_ADD_INT(GL_SAMPLER_BUFFER); - PY_DICT_ADD_INT(GL_SIGNED_NORMALIZED); - PY_DICT_ADD_INT(GL_TEXTURE_BINDING_BUFFER); - PY_DICT_ADD_INT(GL_TEXTURE_BINDING_RECTANGLE); - PY_DICT_ADD_INT(GL_TEXTURE_BUFFER); - PY_DICT_ADD_INT(GL_TEXTURE_BUFFER_DATA_STORE_BINDING); - PY_DICT_ADD_INT(GL_TEXTURE_RECTANGLE); - PY_DICT_ADD_INT(GL_UNIFORM_ARRAY_STRIDE); - PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS); - PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES); - PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_BINDING); - PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_DATA_SIZE); - PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_INDEX); - PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_NAME_LENGTH); - PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER); - PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER); - PY_DICT_ADD_INT(GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER); - PY_DICT_ADD_INT(GL_UNIFORM_BUFFER); - PY_DICT_ADD_INT(GL_UNIFORM_BUFFER_BINDING); - PY_DICT_ADD_INT(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT); - PY_DICT_ADD_INT(GL_UNIFORM_BUFFER_SIZE); - PY_DICT_ADD_INT(GL_UNIFORM_BUFFER_START); - PY_DICT_ADD_INT(GL_UNIFORM_IS_ROW_MAJOR); - PY_DICT_ADD_INT(GL_UNIFORM_MATRIX_STRIDE); - PY_DICT_ADD_INT(GL_UNIFORM_NAME_LENGTH); - PY_DICT_ADD_INT(GL_UNIFORM_OFFSET); - PY_DICT_ADD_INT(GL_UNIFORM_SIZE); - PY_DICT_ADD_INT(GL_UNIFORM_TYPE); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_2D_RECT); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_BUFFER); -} -static void init_bgl_version_3_2_constants(PyObject *dict) -/* GL_VERSION_3_2 */ -{ - PY_DICT_ADD_INT(GL_ALREADY_SIGNALED); - PY_DICT_ADD_INT(GL_CONDITION_SATISFIED); - PY_DICT_ADD_INT(GL_CONTEXT_COMPATIBILITY_PROFILE_BIT); - PY_DICT_ADD_INT(GL_CONTEXT_CORE_PROFILE_BIT); - PY_DICT_ADD_INT(GL_CONTEXT_PROFILE_MASK); - PY_DICT_ADD_INT(GL_DEPTH_CLAMP); - PY_DICT_ADD_INT(GL_FIRST_VERTEX_CONVENTION); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_ATTACHMENT_LAYERED); - PY_DICT_ADD_INT(GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS); - PY_DICT_ADD_INT(GL_GEOMETRY_INPUT_TYPE); - PY_DICT_ADD_INT(GL_GEOMETRY_OUTPUT_TYPE); - PY_DICT_ADD_INT(GL_GEOMETRY_SHADER); - PY_DICT_ADD_INT(GL_GEOMETRY_VERTICES_OUT); - PY_DICT_ADD_INT(GL_INT_SAMPLER_2D_MULTISAMPLE); - PY_DICT_ADD_INT(GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY); - PY_DICT_ADD_INT(GL_LAST_VERTEX_CONVENTION); - PY_DICT_ADD_INT(GL_LINES_ADJACENCY); - PY_DICT_ADD_INT(GL_LINE_STRIP_ADJACENCY); - PY_DICT_ADD_INT(GL_MAX_COLOR_TEXTURE_SAMPLES); - PY_DICT_ADD_INT(GL_MAX_DEPTH_TEXTURE_SAMPLES); - PY_DICT_ADD_INT(GL_MAX_FRAGMENT_INPUT_COMPONENTS); - PY_DICT_ADD_INT(GL_MAX_GEOMETRY_INPUT_COMPONENTS); - PY_DICT_ADD_INT(GL_MAX_GEOMETRY_OUTPUT_COMPONENTS); - PY_DICT_ADD_INT(GL_MAX_GEOMETRY_OUTPUT_VERTICES); - PY_DICT_ADD_INT(GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS); - PY_DICT_ADD_INT(GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS); - PY_DICT_ADD_INT(GL_MAX_GEOMETRY_UNIFORM_COMPONENTS); - PY_DICT_ADD_INT(GL_MAX_INTEGER_SAMPLES); - PY_DICT_ADD_INT(GL_MAX_SAMPLE_MASK_WORDS); - PY_DICT_ADD_INT(GL_MAX_SERVER_WAIT_TIMEOUT); - PY_DICT_ADD_INT(GL_MAX_VERTEX_OUTPUT_COMPONENTS); - PY_DICT_ADD_INT(GL_OBJECT_TYPE); - PY_DICT_ADD_INT(GL_PROGRAM_POINT_SIZE); - PY_DICT_ADD_INT(GL_PROVOKING_VERTEX); - PY_DICT_ADD_INT(GL_PROXY_TEXTURE_2D_MULTISAMPLE); - PY_DICT_ADD_INT(GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY); - PY_DICT_ADD_INT(GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION); - PY_DICT_ADD_INT(GL_SAMPLER_2D_MULTISAMPLE); - PY_DICT_ADD_INT(GL_SAMPLER_2D_MULTISAMPLE_ARRAY); - PY_DICT_ADD_INT(GL_SAMPLE_MASK); - PY_DICT_ADD_INT(GL_SAMPLE_MASK_VALUE); - PY_DICT_ADD_INT(GL_SAMPLE_POSITION); - PY_DICT_ADD_INT(GL_SIGNALED); - PY_DICT_ADD_INT(GL_SYNC_CONDITION); - PY_DICT_ADD_INT(GL_SYNC_FENCE); - PY_DICT_ADD_INT(GL_SYNC_FLAGS); - PY_DICT_ADD_INT(GL_SYNC_FLUSH_COMMANDS_BIT); - PY_DICT_ADD_INT(GL_SYNC_GPU_COMMANDS_COMPLETE); - PY_DICT_ADD_INT(GL_SYNC_STATUS); - PY_DICT_ADD_INT(GL_TEXTURE_2D_MULTISAMPLE); - PY_DICT_ADD_INT(GL_TEXTURE_2D_MULTISAMPLE_ARRAY); - PY_DICT_ADD_INT(GL_TEXTURE_BINDING_2D_MULTISAMPLE); - PY_DICT_ADD_INT(GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY); - PY_DICT_ADD_INT(GL_TEXTURE_CUBE_MAP_SEAMLESS); - PY_DICT_ADD_INT(GL_TEXTURE_FIXED_SAMPLE_LOCATIONS); - PY_DICT_ADD_INT(GL_TEXTURE_SAMPLES); - PY_DICT_ADD_INT(GL_TIMEOUT_EXPIRED); - PY_DICT_ADD_INT64(GL_TIMEOUT_IGNORED); - PY_DICT_ADD_INT(GL_TRIANGLES_ADJACENCY); - PY_DICT_ADD_INT(GL_TRIANGLE_STRIP_ADJACENCY); - PY_DICT_ADD_INT(GL_UNSIGNALED); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE); - PY_DICT_ADD_INT(GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY); - PY_DICT_ADD_INT(GL_WAIT_FAILED); -} -static void init_bgl_version_3_3_constants(PyObject *dict) -{ - /* GL_VERSION_3_3 */ - PY_DICT_ADD_INT(GL_ANY_SAMPLES_PASSED); - PY_DICT_ADD_INT(GL_INT_2_10_10_10_REV); - PY_DICT_ADD_INT(GL_MAX_DUAL_SOURCE_DRAW_BUFFERS); - PY_DICT_ADD_INT(GL_ONE_MINUS_SRC1_ALPHA); - PY_DICT_ADD_INT(GL_ONE_MINUS_SRC1_COLOR); - PY_DICT_ADD_INT(GL_RGB10_A2UI); - PY_DICT_ADD_INT(GL_SAMPLER_BINDING); - PY_DICT_ADD_INT(GL_SRC1_COLOR); - PY_DICT_ADD_INT(GL_TEXTURE_SWIZZLE_A); - PY_DICT_ADD_INT(GL_TEXTURE_SWIZZLE_B); - PY_DICT_ADD_INT(GL_TEXTURE_SWIZZLE_G); - PY_DICT_ADD_INT(GL_TEXTURE_SWIZZLE_R); - PY_DICT_ADD_INT(GL_TEXTURE_SWIZZLE_RGBA); - PY_DICT_ADD_INT(GL_TIMESTAMP); - PY_DICT_ADD_INT(GL_TIME_ELAPSED); - PY_DICT_ADD_INT(GL_VERTEX_ATTRIB_ARRAY_DIVISOR); -} - -PyObject *BPyInit_bgl() -{ - PyObject *submodule, *dict; - submodule = PyModule_Create(&BGL_module_def); - dict = PyModule_GetDict(submodule); - - if (PyType_Ready(&BGL_bufferType) < 0) { - return nullptr; /* should never happen */ - } - -/* Building as a Python module loads all modules - * (see code comment around #PyImport_ExtendInittab usage). - * The result of this is the `bgl` warning would always show when importing `bpy`. - * In the case of Blender as a Python module, suppress the warning. */ -#ifndef WITH_PYTHON_MODULE - if (GPU_backend_get_type() != GPU_BACKEND_OPENGL) { - CLOG_WARN(&LOG, - "'bgl' imported without an OpenGL backend. Please update your add-ons to use the " - "'gpu' module."); - } -#else - UNUSED_VARS(LOG); -#endif - - PyModule_AddObjectRef(submodule, "Buffer", (PyObject *)&BGL_bufferType); - - init_bgl_version_1_0_methods(submodule, dict); - init_bgl_version_1_1_methods(submodule, dict); - init_bgl_version_1_2_methods(submodule, dict); - init_bgl_version_1_3_methods(submodule, dict); - init_bgl_version_1_4_methods(submodule, dict); - init_bgl_version_1_5_methods(submodule, dict); - init_bgl_version_2_0_methods(submodule, dict); - init_bgl_version_2_1_methods(submodule, dict); - init_bgl_version_3_0_methods(submodule, dict); - init_bgl_version_3_1_methods(submodule, dict); - init_bgl_version_3_2_methods(submodule, dict); - init_bgl_version_3_3_methods(submodule, dict); - - init_bgl_version_1_1_constants(dict); - init_bgl_version_1_2_constants(dict); - init_bgl_version_1_3_constants(dict); - init_bgl_version_1_4_constants(dict); - init_bgl_version_1_5_constants(dict); - init_bgl_version_2_0_constants(dict); - init_bgl_version_2_1_constants(dict); - init_bgl_version_3_0_constants(dict); - init_bgl_version_3_1_constants(dict); - init_bgl_version_3_2_constants(dict); - init_bgl_version_3_3_constants(dict); - - return submodule; -} - -static PyObject *Method_ShaderSource(PyObject * /*self*/, PyObject *args) -{ - uint shader; - const char *source; - - if (!PyArg_ParseTuple(args, "Is", &shader, &source)) { - return nullptr; - } - -#ifdef WITH_OPENGL - glShaderSource(shader, 1, (const char **)&source, nullptr); - Py_RETURN_NONE; -#else - bgl_no_opengl_error(); - return nullptr; -#endif -} - -/** \} */ diff --git a/source/blender/python/generic/bgl.hh b/source/blender/python/generic/bgl.hh deleted file mode 100644 index 5507a1e88da..00000000000 --- a/source/blender/python/generic/bgl.hh +++ /dev/null @@ -1,61 +0,0 @@ -/* SPDX-FileCopyrightText: 2023 Blender Authors - * - * SPDX-License-Identifier: GPL-2.0-or-later */ - -/** \file - * \ingroup pygen - */ - -#pragma once - -#include - -PyObject *BPyInit_bgl(); - -/* This API is deprecated, currently these are only used in `bgl.cc` - * and there should be no reason to make use of them in the future. - * Use a define to indicate they are part of the public API which is being phased out. */ -#ifdef USE_BGL_DEPRECATED_API - -/** - * Buffer Object - * - * For Python access to OpenGL functions requiring a pointer. - */ -struct Buffer { - PyObject_VAR_HEAD - PyObject *parent; - - int type; /* GL_BYTE, GL_SHORT, GL_INT, GL_FLOAT */ - int ndimensions; - int *dimensions; - - union { - char *asbyte; - short *asshort; - int *asint; - float *asfloat; - double *asdouble; - - void *asvoid; - } buf; -}; - -/** The type object. */ -extern PyTypeObject BGL_bufferType; - -/** - * Create a buffer object - * - * \param dimensions: An array of ndimensions integers representing the size of each dimension. - * \param initbuffer: When not NULL holds a contiguous buffer - * with the correct format from which the buffer will be initialized - */ -struct Buffer *BGL_MakeBuffer(int type, - int ndimensions, - const int *dimensions, - const void *initbuffer); - -int BGL_typeSize(int type); - -#endif /* USE_BGL_DEPRECATED_API */ diff --git a/source/blender/python/gpu/gpu_py_offscreen.cc b/source/blender/python/gpu/gpu_py_offscreen.cc index 4c4fe70c3fc..4639c21029e 100644 --- a/source/blender/python/gpu/gpu_py_offscreen.cc +++ b/source/blender/python/gpu/gpu_py_offscreen.cc @@ -351,19 +351,6 @@ static PyObject *pygpu_offscreen_height_get(BPyGPUOffScreen *self, void * /*type return PyLong_FromLong(GPU_offscreen_height(self->ofs)); } -PyDoc_STRVAR( - /* Wrap. */ - pygpu_offscreen_color_texture_doc, - "OpenGL bindcode for the color texture.\n" - "\n" - ":type: int"); -static PyObject *pygpu_offscreen_color_texture_get(BPyGPUOffScreen *self, void * /*type*/) -{ - BPY_GPU_OFFSCREEN_CHECK_OBJ(self); - GPUTexture *texture = GPU_offscreen_color_texture(self->ofs); - return PyLong_FromLong(GPU_texture_opengl_bindcode(texture)); -} - PyDoc_STRVAR( /* Wrap. */ pygpu_offscreen_texture_color_doc, @@ -477,12 +464,6 @@ static PyObject *pygpu_offscreen_draw_view3d(BPyGPUOffScreen *self, PyObject *ar depsgraph = BKE_scene_ensure_depsgraph(G_MAIN, scene, view_layer); - /* Disable 'bgl' state since it interfere with off-screen drawing, see: #84402. */ - const bool is_bgl = GPU_bgl_get(); - if (is_bgl) { - GPU_bgl_end(); - } - GPU_offscreen_bind(self->ofs, true); /* Cache the #GPUViewport so the frame-buffers and associated textures are @@ -513,10 +494,6 @@ static PyObject *pygpu_offscreen_draw_view3d(BPyGPUOffScreen *self, PyObject *ar GPU_offscreen_unbind(self->ofs, true); - if (is_bgl) { - GPU_bgl_start(); - } - Py_RETURN_NONE; } @@ -555,11 +532,6 @@ static void BPyGPUOffScreen__tp_dealloc(BPyGPUOffScreen *self) } static PyGetSetDef pygpu_offscreen__tp_getseters[] = { - {"color_texture", - (getter)pygpu_offscreen_color_texture_get, - (setter) nullptr, - pygpu_offscreen_color_texture_doc, - nullptr}, {"texture_color", (getter)pygpu_offscreen_texture_color_get, (setter) nullptr, diff --git a/source/blender/python/intern/bpy.cc b/source/blender/python/intern/bpy.cc index af69722bed4..8eabadfdc1c 100644 --- a/source/blender/python/intern/bpy.cc +++ b/source/blender/python/intern/bpy.cc @@ -709,8 +709,6 @@ static PyObject *bpy_import_test(const char *modname) { PyObject *mod = PyImport_ImportModuleLevel(modname, nullptr, nullptr, nullptr, 0); - GPU_bgl_end(); - if (mod) { Py_DECREF(mod); } diff --git a/source/blender/python/intern/bpy_interface.cc b/source/blender/python/intern/bpy_interface.cc index ed3131df7f6..0819d1ce263 100644 --- a/source/blender/python/intern/bpy_interface.cc +++ b/source/blender/python/intern/bpy_interface.cc @@ -57,7 +57,6 @@ /* `inittab` initialization functions. */ #include "../bmesh/bmesh_py_api.hh" -#include "../generic/bgl.hh" #include "../generic/bl_math_py_api.hh" #include "../generic/blf_py_api.hh" #include "../generic/idprop_py_api.hh" @@ -272,7 +271,6 @@ static _inittab bpy_internal_modules[] = { {"mathutils.kdtree", PyInit_mathutils_kdtree}, #endif {"_bpy_path", BPyInit__bpy_path}, - {"bgl", BPyInit_bgl}, {"blf", BPyInit_blf}, {"bl_math", BPyInit_bl_math}, {"imbuf", BPyInit_imbuf}, diff --git a/source/blender/windowmanager/intern/wm_draw.cc b/source/blender/windowmanager/intern/wm_draw.cc index 8c40454e540..4b525a55b83 100644 --- a/source/blender/windowmanager/intern/wm_draw.cc +++ b/source/blender/windowmanager/intern/wm_draw.cc @@ -1185,9 +1185,6 @@ static void wm_draw_window(bContext *C, wmWindow *win) bScreen *screen = WM_window_get_active_screen(win); bool stereo = WM_stereo3d_enabled(win, false); - /* Avoid any BGL call issued before this to alter the window drawing. */ - GPU_bgl_end(); - /* Draw area regions into their own frame-buffer. This way we can redraw * the areas that need it, and blit the rest from existing frame-buffers. */ wm_draw_window_offscreen(C, win, stereo); diff --git a/source/blender/windowmanager/intern/wm_event_system.cc b/source/blender/windowmanager/intern/wm_event_system.cc index d9259125b8e..facd5d8cd25 100644 --- a/source/blender/windowmanager/intern/wm_event_system.cc +++ b/source/blender/windowmanager/intern/wm_event_system.cc @@ -812,7 +812,6 @@ void wm_event_do_notifiers(bContext *C) /* Auto-run warning. */ wm_test_autorun_warning(C); /* Deprecation warning. */ - wm_test_opengl_deprecation_warning(C); wm_test_gpu_backend_fallback(C); GPU_render_end(); diff --git a/source/blender/windowmanager/intern/wm_window.cc b/source/blender/windowmanager/intern/wm_window.cc index 1a81f629d50..e7f0ca4b23a 100644 --- a/source/blender/windowmanager/intern/wm_window.cc +++ b/source/blender/windowmanager/intern/wm_window.cc @@ -2134,12 +2134,6 @@ static uiBlock *block_create_opengl_usage_warning(bContext *C, ARegion *region, messages->label(message1, ICON_NONE); messages->label(message2, ICON_NONE); messages->label(message3, ICON_NONE); - if (G.opengl_deprecation_usage_filename) { - char location[1024]; - SNPRINTF( - location, "%s:%d", G.opengl_deprecation_usage_filename, G.opengl_deprecation_usage_lineno); - messages->label(location, ICON_NONE); - } messages->label(message4, ICON_NONE); col->separator(0.5f, LayoutSeparatorType::Space); @@ -2149,44 +2143,6 @@ static uiBlock *block_create_opengl_usage_warning(bContext *C, ARegion *region, return block; } -void wm_test_opengl_deprecation_warning(bContext *C) -{ - static bool message_shown = false; - - /* Exit when no failure detected. */ - if (!G.opengl_deprecation_usage_detected) { - return; - } - - /* Have we already shown a message during this Blender session. `bgl` calls are done in a draw - * handler that will run many times. */ - if (message_shown) { - return; - } - - wmWindowManager *wm = CTX_wm_manager(C); - wmWindow *win = static_cast((wm->winactive) ? wm->winactive : wm->windows.first); - - BKE_report(&wm->runtime->reports, - RPT_ERROR, - "One of the add-ons or scripts is using OpenGL and will not work correct on Metal. " - "Please contact the developer of the add-on to migrate to use 'gpu' module"); - - if (win) { - /* We want this warning on the Main window, not a child window even if active. See #118765. */ - if (win->parent) { - win = win->parent; - } - - wmWindow *prevwin = CTX_wm_window(C); - CTX_wm_window_set(C, win); - UI_popup_block_invoke(C, block_create_opengl_usage_warning, nullptr, nullptr); - CTX_wm_window_set(C, prevwin); - } - - message_shown = true; -} - static uiBlock *block_create_gpu_backend_fallback(bContext *C, ARegion *region, void * /*arg1*/) { uiBlock *block = UI_block_begin( diff --git a/source/blender/windowmanager/intern/wm_window_private.hh b/source/blender/windowmanager/intern/wm_window_private.hh index 6c34101d18a..ef27ca8b0ee 100644 --- a/source/blender/windowmanager/intern/wm_window_private.hh +++ b/source/blender/windowmanager/intern/wm_window_private.hh @@ -28,5 +28,4 @@ void WM_ghost_show_message_box(const char *title, GHOST_TDrawingContextType wm_ghost_drawing_context_type(const eGPUBackendType gpu_backend); -void wm_test_opengl_deprecation_warning(bContext *C); void wm_test_gpu_backend_fallback(bContext *C); diff --git a/tests/python/bl_rst_completeness.py b/tests/python/bl_rst_completeness.py index cb4406bae51..e04e06dd0a6 100644 --- a/tests/python/bl_rst_completeness.py +++ b/tests/python/bl_rst_completeness.py @@ -23,7 +23,6 @@ import rst_to_doctree_mini # (file, module) modules = ( - ("bgl.rst", "bgl", True), ("gpu.rst", "gpu", False), )