| '''OpenGL extension NV.bindless_texture |
| |
| This module customises the behaviour of the |
| OpenGL.raw.GL.NV.bindless_texture to provide a more |
| Python-friendly API |
| |
| Overview (from the spec) |
| |
| This extension allows OpenGL applications to access texture objects in |
| shaders without first binding each texture to one of a limited number of |
| texture image units. Using this extension, an application can query an |
| 64-bit unsigned integer texture handle for each texture that it wants to |
| access and then use that handle directly in GLSL or assembly-based |
| shaders. The ability to access textures without having to bind and/or |
| re-bind them is similar to the capability provided by the |
| NV_shader_buffer_load extension that allows shaders to access buffer |
| objects without binding them. In both cases, these extensions |
| significantly reduce the amount of API and internal GL driver overhead |
| needed to manage resource bindings. |
| |
| This extension also provides similar capability for the image load, store, |
| and atomic functionality provided by OpenGL 4.2 and the |
| ARB_shader_image_load_store and EXT_shader_image_load_store extensions, |
| where a texture can be accessed without first binding it to an image unit. |
| An image handle can be extracted from a texture object using an API with a |
| set of parameters similar to those for BindImageTextureEXT. |
| |
| This extension adds no new data types to GLSL. Instead, it uses existing |
| sampler and image data types and allows them to be populated with texture |
| and image handles. This extension does permit sampler and image data |
| types to be used in more contexts than in unextended GLSL 4.00. In |
| particular, sampler and image types may be used as shader inputs/outputs, |
| temporary variables, and uniform block members, and may be assigned to by |
| shader code. Constructors are provided to convert 64-bit unsigned integer |
| handles to and from sampler and image data types. Additionally, new APIs |
| are provided to load values for sampler and image uniforms with 64-bit |
| handle inputs. The use of existing integer-based Uniform* APIs is still |
| permitted, in which case the integer specified will identify a texture |
| image or image unit. For samplers and images with values specified as |
| texture image or image units, the GL implemenation will translate the unit |
| number to an internal handle as required. |
| |
| To access texture or image resources using handles, the handles must first |
| be made resident. Accessing a texture or image by handle without first |
| making it resident can result in undefined results, including program |
| termination. Since the amount of texture memory required by an |
| application may exceed the amount of memory available to the system, this |
| extension provides API calls allowing applications to manage overall |
| texture memory consumption by making a texture resident and non-resident |
| as required. |
| |
| |
| The official definition of this extension is available here: |
| http://www.opengl.org/registry/specs/NV/bindless_texture.txt |
| ''' |
| from OpenGL import platform, constant, arrays |
| from OpenGL import extensions, wrapper |
| import ctypes |
| from OpenGL.raw.GL import _types, _glgets |
| from OpenGL.raw.GL.NV.bindless_texture import * |
| from OpenGL.raw.GL.NV.bindless_texture import _EXTENSION_NAME |
|
|
| def glInitBindlessTextureNV(): |
| '''Return boolean indicating whether this extension is available''' |
| from OpenGL import extensions |
| return extensions.hasGLExtension( _EXTENSION_NAME ) |
|
|
| |
| glUniformHandleui64vNV=wrapper.wrapper(glUniformHandleui64vNV).setInputArraySize( |
| 'value', None |
| ) |
| |
| glProgramUniformHandleui64vNV=wrapper.wrapper(glProgramUniformHandleui64vNV).setInputArraySize( |
| 'values', None |
| ) |
| |
