| '''OpenGL extension APPLE.object_purgeable |
| |
| This module customises the behaviour of the |
| OpenGL.raw.GL.APPLE.object_purgeable to provide a more |
| Python-friendly API |
| |
| Overview (from the spec) |
| |
| This extension provides the ability to mark the storage of OpenGL |
| objects as "purgeable". |
| |
| Many of today's modern virtual memory systems include the concept of |
| purgeability in order to avoid unnecessary paging when the object |
| contents are no longer needed. In OpenGL, objects such as textures, |
| vertex buffers, pixel buffers, and renderbuffers all have |
| significant storage requirements. By default, the OpenGL is |
| required to preserve the contents of these objects regardless of |
| system resource stress, such as vram shortage or physical memory |
| shortage. Often this is accomplished by temporarily paging the |
| contents of objects that are not currently needed to some kind of |
| secondary storage area. This paging operation can be an unnecessary |
| computational expense in the cases where the data is not going to be |
| used again or where the content can be reproduced by the application |
| with less expense than the paging operation would require. |
| |
| This extension defines a mechanism for the application to mark the |
| storage of OpenGL objects as "purgeable" in order to influence these |
| paging operations. The application can further control the |
| semantics of making object storage "purgeable" with two options |
| ("volatile" and "released") and "unpurgeable" with two options |
| ("undefined" and "retained") |
| |
| Applications that use this extension will typically follow one of |
| two operational models. The typical model for most applications is |
| to mark an object storage as "purgeable" with the "volatile" option, |
| and then later mark the storage as "unpurgeable" with the "retained" |
| option. When this happens, the application may or may not need to |
| respecify the object contents, depending on the whether the object |
| storage was actually released. The application can find out whether |
| the storage was released by examining the return value of the |
| function which marks the storage as "unpurgeable". This model is |
| useful when the application does not know at the time it marks the |
| object storage as "purgeable" whether it will later need those |
| contents to be valid. |
| |
| Another operational model is for an application to mark the storage |
| for an object as "purgeable" with the "released" option, and then |
| later mark the object "unpurgeable" with the "undefined" option. In |
| this latter model, the application intends to unconditionally reload |
| the object contents later on, and so it tells the GL that it is okay |
| if the contents are "undefined" when the storage is re-allocated. |
| |
| Note that in both models, it is possible for the contents to become |
| undefined since they could have actually been purged from the system |
| in either case. The various options are still useful, however, |
| since they give more information to the GL about what the |
| application expects to happen and the GL can use this information to |
| make better predictions about which paging choices will be more |
| efficient. |
| |
| The official definition of this extension is available here: |
| http://www.opengl.org/registry/specs/APPLE/object_purgeable.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.APPLE.object_purgeable import * |
| from OpenGL.raw.GL.APPLE.object_purgeable import _EXTENSION_NAME |
|
|
| def glInitObjectPurgeableAPPLE(): |
| '''Return boolean indicating whether this extension is available''' |
| from OpenGL import extensions |
| return extensions.hasGLExtension( _EXTENSION_NAME ) |
|
|
| glGetObjectParameterivAPPLE=wrapper.wrapper(glGetObjectParameterivAPPLE).setOutput( |
| 'params',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True |
| ) |
| |
