| GL_NV_parameter_buffer_object |
NV_parameter_buffer_object
None (impled by NV_GPU_program4)
Pat Brown, NVIDIA Corporation (pbrown 'at' nvidia.com)
Eric Werness, NVIDIA Corporation (ewerness 'at' nvidia.com)
Shipping for GeForce 8 Series (November 2006)
Last Modified Date: 04/18/2007
NVIDIA Revision: 7
339
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.
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 buffer, uint index,
sizei count, const float *params);
void ProgramBufferParametersIivNV(enum target, uint buffer, uint index,
sizei count, const int *params);
void ProgramBufferParametersIuivNV(enum target, uint buffer, uint index,
sizei count, const uint *params);
void GetIntegerIndexedvEXT(enum value, uint index, boolean *data);
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 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
BindBufferOffset 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 buffer, uint index,
sizei count, const float *params);
void ProgramBufferParametersIivNV(enum target, uint buffer, uint index,
sizei count, const int *params);
void ProgramBufferParametersIuivNV(enum target, uint buffer, uint index,
sizei count, const uint *params);
update words <index> through <index>+<count>-1 in the buffer object bound
to the binding point numbered <buffer> 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
<buffer>. The error INVALID_VALUE is generated if <index>+<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,
boolean *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.
| Additions to the AGL/GLX/WGL Specifications |
None
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.
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 <buffer> for program
target <target>.
The error INVALID_VALUE is generated by ProgramBufferParametersfvNV,
ProgramBufferParametersIivNV, or ProgramBufferParametersIuivNV if the sum
of <index> and <count> is greater than either the number of words in the
buffer object boudn to <buffer> or the maximum parameter buffer size
MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV.
(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
(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
BindBufferBase 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 perf 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.
Rev. Date Author Changes
---- -------- -------- -----------------------------------------
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.
1-5 Internal revisions.
 |  | Last update: November 14, 2006.
Cette page doit être lue avec un navigateur récent respectant le standard XHTML 1.1.
|
