| Name |
| |
| NV_parameter_buffer_object |
| |
| Name Strings |
| |
| None (implied by NV_gpu_program4) |
| |
| Contact |
| |
| Pat Brown, NVIDIA Corporation (pbrown 'at' nvidia.com) |
| Eric Werness, NVIDIA Corporation (ewerness 'at' nvidia.com) |
| |
| Status |
| |
| Shipping for GeForce 8 Series (November 2006) |
| |
| Version |
| |
| Last Modified Date: 03/09/2011 |
| NVIDIA Revision: 9 |
| |
| Number |
| |
| 339 |
| |
| Dependencies |
| |
| OpenGL 2.0 is required. |
| |
| NV_gpu_program4 is required. |
| |
| This extension is written against the OpenGL 2.0 specification. |
| |
| NV_transform_feedback affects this extension. |
| |
| OpenGL 3.0 affects this extension. |
| |
| Overview |
| |
| This extension, in conjunction with NV_gpu_program4, provides a new type |
| of program parameter than can be used as a constant during vertex, |
| fragment, or geometry program execution. Each program target has a set of |
| parameter buffer binding points to which buffer objects can be attached. |
| |
| A vertex, fragment, or geometry program can read data from the attached |
| buffer objects using a binding of the form "program.buffer[a][b]". This |
| binding reads data from the buffer object attached to binding point <a>. |
| The buffer object attached is treated either as an array of 32-bit words |
| or an array of four-component vectors, and the binding above reads the |
| array element numbered <b>. |
| |
| The use of buffer objects allows applications to change large blocks of |
| program parameters at once, simply by binding a new buffer object. It |
| also provides a number of new ways to load parameter values, including |
| readback from the frame buffer (EXT_pixel_buffer_object), transform |
| feedback (NV_transform_feedback), buffer object loading functions such as |
| MapBuffer and BufferData, as well as dedicated parameter buffer update |
| functions provided by this extension. |
| |
| New Procedures and Functions |
| |
| void BindBufferRangeNV(enum target, uint index, uint buffer, |
| intptr offset, sizeiptr size); |
| void BindBufferOffsetNV(enum target, uint index, uint buffer, |
| intptr offset); |
| void BindBufferBaseNV(enum target, uint index, uint buffer); |
| void ProgramBufferParametersfvNV(enum target, uint bindingIndex, uint wordIndex, |
| sizei count, const float *params); |
| void ProgramBufferParametersIivNV(enum target, uint bindingIndex, uint wordIndex, |
| sizei count, const int *params); |
| void ProgramBufferParametersIuivNV(enum target, uint bindingIndex, uint wordIndex, |
| sizei count, const uint *params); |
| void GetIntegerIndexedvEXT(enum value, uint index, int *data); |
| |
| New Tokens |
| |
| Accepted by the <pname> parameter of GetProgramivARB: |
| |
| MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV 0x8DA0 |
| MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV 0x8DA1 |
| |
| Accepted by the <target> parameter of ProgramBufferParametersfvNV, |
| ProgramBufferParametersIivNV, and ProgramBufferParametersIuivNV, |
| BindBufferRangeNV, BindBufferOffsetNV, BindBufferBaseNV, and BindBuffer |
| and the <value> parameter of GetIntegerv and GetIntegerIndexedvEXT: |
| |
| VERTEX_PROGRAM_PARAMETER_BUFFER_NV 0x8DA2 |
| GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV 0x8DA3 |
| FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV 0x8DA4 |
| |
| Additions to Chapter 2 of the OpenGL 2.0 Specification (OpenGL Operation) |
| |
| Modify "Section 2.14.1" of the ARB_vertex_program specification. |
| |
| (Add after the discussion of environment parameters.) |
| |
| Additionally, each program target has an array of parameter buffer binding |
| points, to which a buffer object (Section 2.9) can be bound. The number |
| of available binding points is given by the implementation-dependent |
| constant MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV. These binding points |
| are shared by all programs of a given type. All bindings are initialized |
| to the name zero, which indicates that no valid binding is present. |
| |
| A program parameter binding is associated with a buffer object using |
| BindBufferOffsetNV with a <target> of VERTEX_PROGRAM_PARAMETER_BUFFER_NV, |
| GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV, or |
| FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV and <index> corresponding to the |
| number of the desired binding point. The error INVALID_VALUE is generated |
| if the value of <index> is greater than or equal to |
| MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS. |
| |
| Buffer objects are made to be sources of program parameter buffers by |
| calling one of |
| |
| void BindBufferRangeNV(enum target, uint index, uint buffer, |
| intptr offset, sizeiptr size) |
| void BindBufferOffsetNV(enum target, uint index, uint buffer, |
| intptr offset) |
| void BindBufferBaseNV(enum target, uint index, uint buffer) |
| |
| where <target> is set to VERTEX_PROGRAM_PARAMETER_BUFFER_NV, |
| GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV, or |
| FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV. Any of the three BindBuffer* |
| commands perform the equivalent of BindBuffer(target, buffer). <buffer> |
| specifies which buffer object to bind to the target at index number |
| <index>. <index> must be less than the value of |
| MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV. <offset> specifies a starting |
| offset into the buffer object <buffer>. <size> specifies the number of |
| elements in the bound portion of the buffer. Both <offset> and <size> are |
| in basic machine units. The error INVALID_VALUE is generated if the value |
| of <size> is less than or equal to zero. The error INVALID_VALUE is |
| generated if <offset> or <size> are not word-aligned. For program |
| parameter buffers, the error INVALID_VALUE is generated if <offset> is |
| non-zero. |
| |
| BindBufferBaseNV is equivalent to calling BindBufferOffsetNV with an |
| <offset> of 0. BindBufferOffsetNV is the equivalent of calling |
| BindBufferRangeNV with <size> = sizeof(buffer) - <offset> and rounding |
| <size> down so that it is word-aligned. |
| |
| All program parameter buffer parameters are either single-component 32-bit |
| words or four-component vectors made up of 32-bit words. The program |
| parameter buffers may hold signed integer, unsigned integer, or |
| floating-point data. There is a limit on the maximum number of words of a |
| buffer object that can be accessed using any single parameter buffer |
| binding point, given by the implementation-dependent constant |
| MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV. Buffer objects larger than this |
| size may be used, but the results of accessing portions of the buffer |
| object beyond the limit are undefined. |
| |
| The commands |
| |
| void ProgramBufferParametersfvNV(enum target, uint bindingIndex, uint wordIndex, |
| sizei count, const float *params); |
| void ProgramBufferParametersIivNV(enum target, uint bindingIndex, uint wordIndex, |
| sizei count, const int *params); |
| void ProgramBufferParametersIuivNV(enum target, uint bindingIndex, uint wordIndex, |
| sizei count, const uint *params); |
| |
| update words <wordIndex> through <wordIndex>+<count>-1 in the buffer object bound |
| to the binding point numbered <bindingIndex> for the program target <target>. |
| The new data is referenced by <params>. The error INVALID_OPERATION is |
| generated if no buffer object is bound to the binding point numbered |
| <bindingIndex>. The error INVALID_VALUE is generated if <wordIndex>+<count> is |
| greater than either the number of words in the buffer object or the |
| maximum parameter buffer size MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV. These |
| functions perform an operation functionally equivalent to calling |
| BufferSubData, but possibly with higher performance. |
| |
| Additions to Chapter 3 of the OpenGL 2.0 Specification (Rasterization) |
| |
| None. |
| |
| Additions to Chapter 4 of the OpenGL 2.0 Specification (Per-Fragment |
| Operations and the Frame Buffer) |
| |
| None. |
| |
| Additions to Chapter 5 of the OpenGL 2.0 Specification (Special Functions) |
| |
| None. |
| |
| Additions to Chapter 6 of the OpenGL 2.0 Specification (State and |
| State Requests) |
| |
| Modify the second paragraph of section 6.1.1 (Simple Queries) p. 244 to |
| read as follows: |
| |
| ...<data> is a pointer to a scalar or array of the indicated type in which |
| to place the returned data. |
| |
| void GetIntegerIndexedvEXT(enum target, uint index, |
| int *data); |
| |
| are used to query indexed state. <target> is the name of the indexed |
| state and <index> is the index of the particular element being queried. |
| <data> is a pointer to a scalar or array of the indicated type in which to |
| place the returned data. |
| |
| When <target> is one of VERTEX_PROGRAM_PARAMETER_BUFFER_NV, |
| GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV, or |
| FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV, the <index> is a buffer |
| binding index; the error INVALID_VALUE is generated if <index> |
| is greater or equal to the implementation-dependent value of |
| MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS. |
| |
| Additions to the AGL/GLX/WGL Specifications |
| |
| None |
| |
| GLX Protocol |
| |
| TBD |
| |
| Dependencies on NV_transform_feedback |
| |
| Both NV_transform_feedback and this extension define the behavior of |
| BindBuffer{Range, Offset, Base}NV. Both definitions should be functionally |
| identical. |
| |
| Dependencies on OpenGL 3.0 |
| |
| GetIntegeri_v accepts the same target parameters GetIntegerIndexedvEXT |
| and the two queries return identical results. |
| |
| Errors |
| |
| The error INVALID_VALUE is generated by BindBufferRangeNV, |
| BindBufferOffsetNV, or BindBufferBaseNV if <target> is |
| VERTEX_PROGRAM_PARAMETER_BUFFER_NV, GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV, |
| or FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV, and <index> is greater than or |
| equal to MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS. |
| |
| The error INVALID_VALUE is generated by BindBufferRangeNV or |
| BindBufferOffsetNV if <offset> or <size> is not word-aligned. |
| |
| The error INVALID_VALUE is generated by BindBufferRangeNV if <size> is |
| less than zero. |
| |
| The error INVALID_VALUE is generated by BindBufferRangeNV or |
| BindBufferOffsetNV if <target> is VERTEX_PROGRAM_PARAMETER_BUFFER_NV, |
| GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV, or |
| FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV, and <offset> is non-zero. |
| |
| The error INVALID_OPERATION is generated by ProgramBufferParametersfvNV, |
| ProgramBufferParametersIivNV, or ProgramBufferParametersIuivNV if no |
| buffer object is bound to the binding point numbered <bindingIndex> for program |
| target <target>. |
| |
| The error INVALID_VALUE is generated by ProgramBufferParametersfvNV, |
| ProgramBufferParametersIivNV, or ProgramBufferParametersIuivNV if the sum |
| of <wordIndex> and <count> is greater than either the number of words in the |
| buffer object bound to <bindingIndex> or the maximum parameter buffer size |
| MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV. |
| |
| The error INVALID_VALUE is generated by GetIntegerIndexedvEXT |
| when <target> is one of VERTEX_PROGRAM_PARAMETER_BUFFER_NV, |
| GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV, or |
| FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV, and the <index> is greater |
| than or equal to MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS. |
| |
| New State |
| |
| (Modify ARB_vertex_program, Table X.6 -- Program State) |
| |
| Initial |
| Get Value Type Get Command Value Description Sec. Attribute |
| --------- ------- ----------- ------- ------------------------ ------ --------- |
| VERTEX_PROGRAM_PARAMETER_ Z+ GetIntegerv 0 Active vertex program 2.14.1 - |
| BUFFER_NV buffer object binding |
| VERTEX_PROGRAM_PARAMETER_ nxZ+ GetInteger- 0 Buffer objects bound for 2.14.1 - |
| BUFFER_NV IndexedvEXT vertex program use |
| GEOMETRY_PROGRAM_PARAMETER_ Z+ GetIntegerv 0 Active geometry program 2.14.1 - |
| BUFFER_NV buffer object binding |
| GEOMETRY_PROGRAM_PARAMETER_ nxZ+ GetInteger- 0 Buffer objects bound for 2.14.1 - |
| BUFFER_NV IndexedvEXT geometry program use |
| FRAGMENT_PROGRAM_PARAMETER_ Z+ GetIntegerv 0 Active fragment program 2.14.1 - |
| BUFFER_NV buffer object binding |
| FRAGMENT_PROGRAM_PARAMETER_ nxZ+ GetInteger- 0 Buffer objects bound for 2.14.1 - |
| BUFFER_NV IndexedvEXT fragment program use |
| |
| New Implementation Dependent State |
| |
| Minimum |
| Get Value Type Get Command Value Description Sec. Attribute |
| --------- ------- ----------- ------- ---------------- ------ --------- |
| MAX_PROGRAM_PARAMETER_ Z GetProgram- 8 size of program 2.14.1 - |
| BUFFER_BINDINGS_NV ivARB parameter binding |
| tables |
| MAX_PROGRAM_PARAMETER_ Z GetProgram- 4096 maximum usable 2.14.1 - |
| BUFFER_SIZE_NV ivARB size of program |
| parameter buffers |
| |
| Examples |
| |
| !!NVfp4.0 |
| # Legal |
| BUFFER bones[] = { program.buffer[0] }; |
| ALIAS funBone = bones[69]; |
| MOV t, bones[1]; |
| # Illegal |
| ALIAS numLights = program.buffer[5][6]; |
| MOV t, program.buffer[3][x]; |
| END |
| |
| Issues |
| |
| (1) PBO is already taken as an acronym? What do we call this? |
| |
| RESOLVED: PaBO. |
| |
| (2) How should the ability to simultaneously access multiple parameter |
| buffers be exposed? |
| |
| RESOLVED: In the program text (see NV_gpu_program4), the buffers are |
| referred to using a buffer binding statement which is dereferenced in |
| the instructions. In the rest of the APIs, an array of internal binding |
| points is provided, which are dereferenced using the index parameter of |
| BindBufferBaseNV and associated functions. |
| |
| (3) Should program parameter buffer bindings be provided per-target (i.e., |
| environment parameters), per-program (i.e., local parameters), or some |
| combination of the two? |
| |
| RESOLVED: Per-target. That fits most naturally with the ARB program |
| model, similar to textures. Having both per-program and per-target add |
| complexity with no benefit. |
| |
| (4) Should references to the parameter buffer be scalar or vector? |
| |
| RESOLVED: Scalar. Having vector is more consistent with the legacy APIs, |
| but is more difficult to build the arbitrary data structures that are |
| interesting to store in a parameter buffer. A future extension can |
| define an alternate keyword in the program text to specify accesses of a |
| different size. |
| |
| (5) Should parameter buffers be editable using the ProgramEnvParameter |
| API? |
| |
| RESOLVED: No. There is a new parallel API for the bindable buffers, |
| including the ability to update multiple parameters at a time. These are |
| more convenient than having to rebind for BufferData and potentially |
| faster. |
| |
| (6) Should parameter buffers be editable outside the ProgramBufferParameters |
| API? |
| |
| RESOLVED: Yes. The use of buffer objects allows the buffers to be |
| naturally manipulated using normal buffer object mechanisms. That |
| includes CPU mapping, loading via BufferData or BufferSubData, and even |
| reading data back using the ARB_pixel_buffer_object extension. |
| |
| (7) Will buffer object updates from different sources cause potential |
| synchronization problems? If so, how will they be resolved. |
| |
| RESOLVED: If reads and write occur in the course of the same call |
| (e.g. reading from a buffer using parameter buffer binding while writing |
| to it using transform feedback. All other cases are allowed and occur in |
| command order. Any synchronization is handled by the GL. |
| |
| (8) Is there an implementation-dependent limit to the size of program |
| parameter buffers? |
| |
| RESOLVED: Yes, limited-size buffers are provided to reduce the |
| complexity of the GPU design that supports program parameter buffer |
| access and updates. However, the minimum limit is 16K scalar |
| parameters, or 64KB. A larger buffer object can be provided, but only |
| the first 64KB is accessible. The limit is queryable with |
| GetProgramivARB with <pname> MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV. |
| |
| (9) With scalar buffers, which parameter setting routines do we need? |
| |
| UNRESOLVED: A function to set N scalars is very important. It might be |
| nice to have convenience functions that take 1 or 4 parameters directly. |
| |
| (10) Do we need GetProgramBufferParameter functions? |
| |
| UNRESOLVED: Probably not - they aren't performance critical and offer no |
| functionality beyond getting the buffer object data any of the standard |
| ways. |
| |
| (11) What happens if a value written using ProgramBufferParametersfNV is |
| read as an integer or the other way around? |
| |
| RESOLVED: Undefined - likely just a raw bit cast between whatever |
| internal representations are used by the GL. |
| |
| (12) What's the differece between the "GLuint buffer" |
| in BindBuffer*NV commands and the "GLuint bindingIndex" |
| in ProgramBufferParameter*NV commands? |
| |
| RESOLVED: The "GLuint buffer" parameter is a buffer object name |
| created with glBindBuffer or glGenBuffers. |
| |
| The "GLuint bindingIndex" parameter is an unsigned index into the target's |
| array of buffer bindings. |
| |
| The index used by GetIntegerIndexvEXT for NV_parameter_buffer_object |
| query tokens is an index into the query token's array of buffer |
| bindings (similar to bindingIndex). |
| |
| Revision History |
| |
| Rev. Date Author Changes |
| ---- -------- -------- ----------------------------------------- |
| 9 03/09/11 mjk Fix glGetIntegerIndexedvEXT prototype |
| Note about glGetIntegeri_v |
| Rename buffer and index parameters and |
| add Issue #12 to clarify the API |
| |
| 8 10/02/08 mjk Fix New Tokens to note glGetIntegerv works |
| for *_PROGRAM_PARAMETER_NV (matching the table); |
| NVIDIA drivers before 180.00 fail to implement |
| this get, later drivers do |
| 7 04/18/07 pbrown Fixed state table to include the buffer |
| object binding array for each program type. |
| |
| 6 02/07/07 ewerness Updated inconsistent prototypes in spec - |
| <count> for ProgramBufferParameters* is |
| a <sizei>, not a <uint>. |
| |
| 1-5 Internal revisions. |
