| | '''OpenGL extension NV.vertex_array_range |
| | |
| | This module customises the behaviour of the |
| | OpenGL.raw.WGL.NV.vertex_array_range to provide a more |
| | Python-friendly API |
| | |
| | Overview (from the spec) |
| | |
| | The goal of this extension is to permit extremely high vertex |
| | processing rates via OpenGL vertex arrays even when the CPU lacks |
| | the necessary data movement bandwidth to keep up with the rate |
| | at which the vertex engine can consume vertices. CPUs can keep |
| | up if they can just pass vertex indices to the hardware and |
| | let the hardware "pull" the actual vertex data via Direct Memory |
| | Access (DMA). Unfortunately, the current OpenGL 1.1 vertex array |
| | functionality has semantic constraints that make such an approach |
| | hard. Hence, the vertex array range extension. |
| | |
| | This extension provides a mechanism for deferring the pulling of |
| | vertex array elements to facilitate DMAed pulling of vertices for |
| | fast, efficient vertex array transfers. The OpenGL client need only |
| | pass vertex indices to the hardware which can DMA the actual index's |
| | vertex data directly out of the client address space. |
| | |
| | The OpenGL 1.1 vertex array functionality specifies a fairly strict |
| | coherency model for when OpenGL extracts vertex data from a vertex |
| | array and when the application can update the in memory |
| | vertex array data. The OpenGL 1.1 specification says "Changes |
| | made to array data between the execution of Begin and the |
| | corresponding execution of End may affect calls to ArrayElement |
| | that are made within the same Begin/End period in non-sequential |
| | ways. That is, a call to ArrayElement that precedes a change to |
| | array data may access the changed data, and a call that follows |
| | a change to array data may access the original data." |
| | |
| | This means that by the time End returns (and DrawArrays and |
| | DrawElements return since they have implicit Ends), the actual vertex |
| | array data must be transferred to OpenGL. This strict coherency model |
| | prevents us from simply passing vertex element indices to the hardware |
| | and having the hardware "pull" the vertex data out (which is often |
| | long after the End for the primitive has returned to the application). |
| | |
| | Relaxing this coherency model and bounding the range from which |
| | vertex array data can be pulled is key to making OpenGL vertex |
| | array transfers faster and more efficient. |
| | |
| | The first task of the vertex array range extension is to relax |
| | the coherency model so that hardware can indeed "pull" vertex |
| | data from the OpenGL client's address space long after the application |
| | has completed sending the geometry primitives requiring the vertex |
| | data. |
| | |
| | The second problem with the OpenGL 1.1 vertex array functionality is |
| | the lack of any guidance from the API about what region of memory |
| | vertices can be pulled from. There is no size limit for OpenGL 1.1 |
| | vertex arrays. Any vertex index that points to valid data in all |
| | enabled arrays is fair game. This makes it hard for a vertex DMA |
| | engine to pull vertices since they can be potentially pulled from |
| | anywhere in the OpenGL client address space. |
| | |
| | The vertex array range extension specifies a range of the OpenGL |
| | client's address space where vertices can be pulled. Vertex indices |
| | that access any array elements outside the vertex array range |
| | are specified to be undefined. This permits hardware to DMA from |
| | finite regions of OpenGL client address space, making DMA engine |
| | implementation tractable. |
| | |
| | The extension is specified such that an (error free) OpenGL client |
| | using the vertex array range functionality could no-op its vertex |
| | array range commands and operate equivalently to using (if slower |
| | than) the vertex array range functionality. |
| | |
| | Because different memory types (local graphics memory, AGP memory) |
| | have different DMA bandwidths and caching behavior, this extension |
| | includes a window system dependent memory allocator to allocate |
| | cleanly the most appropriate memory for constructing a vertex array |
| | range. The memory allocator provided allows the application to |
| | tradeoff the desired CPU read frequency, CPU write frequency, and |
| | memory priority while still leaving it up to OpenGL implementation |
| | the exact memory type to be allocated. |
| | |
| | The official definition of this extension is available here: |
| | http://www.opengl.org/registry/specs/NV/vertex_array_range.txt |
| | ''' |
| | from OpenGL import platform, constant, arrays |
| | from OpenGL import extensions, wrapper |
| | import ctypes |
| | from OpenGL.raw.WGL import _types, _glgets |
| | from OpenGL.raw.WGL.NV.vertex_array_range import * |
| | from OpenGL.raw.WGL.NV.vertex_array_range import _EXTENSION_NAME |
| |
|
| | def glInitVertexArrayRangeNV(): |
| | '''Return boolean indicating whether this extension is available''' |
| | from OpenGL import extensions |
| | return extensions.hasGLExtension( _EXTENSION_NAME ) |
| |
|
| |
|
| | |
