| '''OpenGL extension NV.pixel_data_range |
| |
| This module customises the behaviour of the |
| OpenGL.raw.GL.NV.pixel_data_range to provide a more |
| Python-friendly API |
| |
| Overview (from the spec) |
| |
| The vertex array range extension is intended to improve the |
| efficiency of OpenGL vertex arrays. OpenGL vertex arrays' coherency |
| model and ability to access memory from arbitrary locations in memory |
| prevented implementations from using DMA (Direct Memory Access) |
| operations. |
| |
| Many image-intensive applications, such as those that use dynamically |
| generated textures, face similar problems. These applications would |
| like to be able to sustain throughputs of hundreds of millions of |
| pixels per second through DrawPixels and hundreds of millions of |
| texels per second through TexSubImage. |
| |
| However, the same restrictions that limited vertex throughput also |
| limit pixel throughput. |
| |
| By the time that any pixel operation that reads data from user memory |
| returns, OpenGL requires that it must be safe for the application to |
| start using that memory for a different purpose. This coherency |
| model prevents asynchronous DMA transfers directly out of the user's |
| buffer. |
| |
| There are also no restrictions on the pointer provided to pixel |
| operations or on the size of the data. To facilitate DMA |
| implementations, the driver needs to know in advance what region of |
| the address space to lock down. |
| |
| Vertex arrays faced both of these restrictions already, but pixel |
| operations have one additional complicating factor -- they are |
| bidirectional. Vertex array data is always being transfered from the |
| application to the driver and the HW, whereas pixel operations |
| sometimes transfer data to the application from the driver and HW. |
| Note that the types of memory that are suitable for DMA for reading |
| and writing purposes are often different. For example, on many PC |
| platforms, DMA pulling is best accomplished with write-combined |
| (uncached) AGP memory, while pushing data should use cached memory so |
| that the application can read the data efficiently once it has been |
| read back over the AGP bus. |
| |
| This extension defines an API where an application can specify two |
| pixel data ranges, which are analogous to vertex array ranges, except |
| that one is for operations where the application is reading data |
| (e.g. glReadPixels) and one is for operations where the application |
| is writing data (e.g. glDrawPixels, glTexSubImage2D, etc.). Each |
| pixel data range has a pointer to its start and a length in bytes. |
| |
| When the pixel data range is enabled, and if the pointer specified |
| as the argument to a pixel operation is inside the corresponding |
| pixel data range, the implementation may choose to asynchronously |
| pull data from the pixel data range or push data to the pixel data |
| range. Data pulled from outside the pixel data range is undefined, |
| while pushing data to outside the pixel data range produces undefined |
| results. |
| |
| The application may synchronize with the hardware in one of two ways: |
| by flushing the pixel data range (or causing an implicit flush) or by |
| using the NV_fence extension to insert fences in the command stream. |
| |
| The official definition of this extension is available here: |
| http://www.opengl.org/registry/specs/NV/pixel_data_range.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.pixel_data_range import * |
| from OpenGL.raw.GL.NV.pixel_data_range import _EXTENSION_NAME |
|
|
| def glInitPixelDataRangeNV(): |
| '''Return boolean indicating whether this extension is available''' |
| from OpenGL import extensions |
| return extensions.hasGLExtension( _EXTENSION_NAME ) |
|
|
| glPixelDataRangeNV=wrapper.wrapper(glPixelDataRangeNV).setOutput( |
| 'pointer',size=lambda x:(x,),pnameArg='length',orPassIn=True |
| ) |
| |
