| '''OpenGL extension NV.float_buffer |
| |
| This module customises the behaviour of the |
| OpenGL.raw.GLX.NV.float_buffer to provide a more |
| Python-friendly API |
| |
| Overview (from the spec) |
| |
| This extension builds upon NV_fragment_program to provide a framebuffer |
| and texture format that allows fragment programs to read and write |
| unconstrained floating point data. |
| |
| In unextended OpenGL, most computations dealing with color or depth |
| buffers are typically constrained to operate on values in the range [0,1]. |
| Computational results are also typically clamped to the range [0,1]. |
| Color, texture, and depth buffers themselves also hold values mapped to |
| the range [0,1]. |
| |
| The NV_fragment_program extension provides a general computational model |
| that supports floating-point numbers constrained only by the precision of |
| the underlying data types. The quantites computed by fragment programs do |
| not necessarily correspond in number or in range to conventional |
| attributes such as RGBA colors or depth values. Because of the range and |
| precision constraints imposed by conventional fixed-point color buffers, |
| it may be difficult (if not impossible) to use them to implement certain |
| multi-pass algorithms. |
| |
| To enhance the extended range and precision available through fragment |
| programs, this extension provides floating-point RGBA color buffers that |
| can be used instead of conventional fixed-point RGBA color buffers. A |
| floating-point RGBA color buffer consists of one to four floating-point |
| components stored in the 16- or 32-bit floating-point formats (fp16 or |
| fp32) defined in the NV_half_float and NV_fragment_program extensions. |
| |
| When a floating-point color buffer is used, the results of fragment |
| programs, as written to the "x", "y", "z", and "w" components of the |
| o[COLR] or o[COLH] output registers, are written directly to the color |
| buffer without any clamping or modification. Certain per-fragment |
| operations are bypassed when rendering to floating-point color buffers. |
| |
| A floating-point color buffer can also be used as a texture map, either by |
| reading back the contents and then using conventional TexImage calls, or |
| by using the buffer directly via the ARB_render_texture extension or |
| the EXT_framebuffer_object extension. |
| |
| This extension has many uses. Some possible uses include: |
| |
| (1) Multi-pass algorithms with arbitrary intermediate results that |
| don't have to be artifically forced into the range [0,1]. In |
| addition, intermediate results can be written without having to |
| worry about out-of-range values. |
| |
| (2) Deferred shading algorithms where an expensive fragment program is |
| executed only after depth testing is fully complete. Instead, a |
| simple program is executed, which stores the parameters necessary |
| to produce a final result. After the entire scene is rendered, a |
| second pass is executed over the entire frame buffer to execute |
| the complex fragment program using the results written to the |
| floating-point color buffer in the first pass. This will save the |
| cost of applying complex fragment programs to fragments that will |
| not appear in the final image. |
| |
| (3) Use floating-point texture maps to evaluate functions with |
| arbitrary ranges. Arbitrary functions with a finite domain can be |
| approximated using a texture map holding sample results and |
| piecewise linear approximation. |
| |
| There are several significant limitations on the use of floating-point |
| color buffers. First, floating-point color buffers do not support frame |
| buffer blending. Second, floating-point texture maps do not support |
| mipmapping or any texture filtering other than NEAREST. Third, |
| floating-point texture maps must be 2D, and must use the |
| NV_texture_rectangle extension. |
| |
| The official definition of this extension is available here: |
| http://www.opengl.org/registry/specs/NV/float_buffer.txt |
| ''' |
| from OpenGL import platform, constant, arrays |
| from OpenGL import extensions, wrapper |
| import ctypes |
| from OpenGL.raw.GLX import _types, _glgets |
| from OpenGL.raw.GLX.NV.float_buffer import * |
| from OpenGL.raw.GLX.NV.float_buffer import _EXTENSION_NAME |
|
|
| def glInitFloatBufferNV(): |
| '''Return boolean indicating whether this extension is available''' |
| from OpenGL import extensions |
| return extensions.hasGLExtension( _EXTENSION_NAME ) |
|
|
|
|
| |
