CUGL 2.3
Cornell University Game Library
|
#include <CUUniformBuffer.h>
Public Member Functions | |
UniformBuffer () | |
~UniformBuffer () | |
void | dispose () |
bool | init (GLsizei capacity) |
bool | init (GLsizei capacity, GLuint blocks) |
void | setName (std::string name) |
const std::string | getName () const |
GLenum | getDrawType () const |
void | setDrawType (GLenum type) |
bool | isReady () const |
GLuint | getBlockCount () const |
GLsizei | getBlockSize () const |
GLsizei | getBlockStride () const |
char * | getData () |
bool | getAutoflush () const |
void | setAutoflush (bool style) |
GLuint | getBuffer () const |
GLuint | getBindPoint () const |
void | setBindPoint (GLuint point) |
void | bind (bool activate=true) |
void | unbind () |
void | activate () |
void | deactivate () |
bool | isBound () const |
bool | isActive () const |
GLuint | getBlock () const |
void | setBlock (GLuint block) |
void | flush () |
void | setOffset (const std::string name, GLsizei offset) |
GLsizei | getOffset (const std::string name) const |
std::vector< std::string > | getOffsets () const |
void | setUniformVec2 (GLint block, GLsizei offset, const Vec2 vec) |
void | setUniformVec2 (GLint block, const std::string name, const Vec2 vec) |
bool | getUniformVec2 (GLuint block, GLsizei offset, Vec2 &vec) const |
bool | getUniformVec2 (GLuint block, const std::string name, Vec2 &vec) const |
void | setUniformVec3 (GLint block, GLsizei offset, const Vec3 vec) |
void | setUniformVec3 (GLint block, const std::string name, const Vec3 vec) |
bool | getUniformVec3 (GLuint block, GLsizei offset, Vec3 &vec) const |
bool | getUniformVec3 (GLuint block, const std::string name, Vec3 &vec) const |
void | setUniformVec4 (GLint block, GLsizei offset, const Vec4 vec) |
void | setUniformVec4 (GLint block, const std::string name, const Vec4 vec) |
bool | getUniformVec4 (GLuint block, GLsizei offset, Vec4 &vec) const |
bool | getUniformVec4 (GLuint block, const std::string name, Vec4 &vec) const |
void | setUniformColor4 (GLint block, GLsizei offset, const Color4 color) |
void | setUniformColor4 (GLint block, const std::string name, const Color4 color) |
bool | getUniformColor4 (GLuint block, GLsizei offset, Color4 &color) const |
bool | getUniformColor4 (GLuint block, const std::string name, Color4 &color) const |
void | setUniformColor4f (GLint block, GLsizei offset, const Color4f color) |
void | setUniformColor4f (GLint block, const std::string name, const Color4f color) |
bool | getUniformColor4f (GLuint block, GLsizei offset, Color4f &color) const |
bool | getUniformColor4f (GLuint block, const std::string name, Color4f &color) const |
void | setUniformMat4 (GLint block, GLsizei offset, const Mat4 &mat) |
void | setUniformMat4 (GLint block, const std::string name, const Mat4 &mat) |
bool | getUniformMat4 (GLuint block, GLsizei offset, Mat4 &mat) const |
bool | getUniformMat4 (GLuint block, const std::string name, Mat4 &mat) const |
void | setUniformAffine2 (GLint block, GLsizei offset, const Affine2 &mat) |
void | setUniformAffine2 (GLint block, const std::string name, const Affine2 &mat) |
bool | getUniformAffine2 (GLuint block, GLsizei offset, Affine2 &mat) const |
bool | getUniformAffine2 (GLuint block, const std::string name, Affine2 &mat) const |
void | setUniformQuaternion (GLint block, GLsizei offset, const Quaternion &quat) |
void | setUniformQuaternion (GLint block, const std::string name, const Quaternion &quat) |
bool | getUniformQuaternion (GLuint block, GLsizei offset, Quaternion &quat) const |
bool | getUniformQuaternion (GLuint block, const std::string name, Quaternion &quat) const |
void | setUniformfv (GLint block, GLsizei offset, GLsizei size, const GLfloat *values) |
void | setUniformfv (GLint block, const std::string name, GLsizei size, const GLfloat *values) |
bool | getUniformfv (GLuint block, GLsizei offset, GLsizei size, GLfloat *values) const |
bool | getUniformfv (GLuint block, const std::string name, GLsizei size, GLfloat *values) const |
void | setUniformiv (GLint block, GLsizei offset, GLsizei size, const GLint *values) |
void | setUniformiv (GLint block, const std::string name, GLsizei size, const GLint *values) |
bool | getUniformiv (GLuint block, GLsizei offset, GLsizei size, GLint *values) const |
bool | getUniformiv (GLuint block, const std::string name, GLsizei size, GLint *values) const |
void | setUniformuiv (GLint block, GLsizei offset, GLsizei size, const GLuint *values) |
void | setUniformuiv (GLint block, const std::string name, GLsizei size, const GLuint *values) |
bool | getUniformuiv (GLuint block, GLsizei offset, GLsizei size, GLuint *values) const |
bool | getUniformuiv (GLuint block, const std::string name, GLsizei size, GLuint *values) const |
Static Public Member Functions | |
static std::shared_ptr< UniformBuffer > | alloc (GLsizei capacity) |
static std::shared_ptr< UniformBuffer > | alloc (GLsizei capacity, GLuint blocks) |
Static Public Attributes | |
static GLsizei | INVALID_OFFSET |
This class defines a uniform block buffer for shader optimization.
Like Texture
, shaders and uniform buffers have a many-to-many relationship. This many-to-many relationship is captured by bind points. A uniform buffer is associated with a bind point and a shader associates a binding point with a uniform struct. That uniform struct then pulls data from the uniform buffer.
When discussing the relationship between a shader and a uniform buffer, we talk about a buffer being bound and a buffer being active. A bound buffer is one that is associated with a shader; the shader will pull from the uniform buffer to populate its uniform variables. An active buffer is one that is capable of receiving data from the CPU. A buffer must be active if the user wants to change any of the data in the buffer. These are two separate concepts and are treated separately in this class.
Technically, a shader is associated with a uniform block, not a uniform buffer, since a uniform buffer may have multiple blocks. In the case of a uniform buffer with multiple blocks, the current block is managed by the method setBlock
.
Uniform buffers are ideal in two use cases. First of all, they are great for uniforms that are shared across multiple shaders. But it is also worthwhile to have a buffer for a single shader if (1) that shader has a large number of uniforms and (2) those uniforms change semi-frequently through out a render pass. In that case, the uniform buffer should be allocated with enough blocks so that all of the possible uniform values can be assigned at the start of the render pass, each to a different block. Once the shader starts to receive vertices, the uniforms should be managed via the setBlock
method.
cugl::UniformBuffer::UniformBuffer | ( | ) |
Creates an uninitialized uniform buffer.
You must initialize the uniform buffer to allocate memory.
cugl::UniformBuffer::~UniformBuffer | ( | ) |
Deletes this uniform buffer, disposing all resources.
void cugl::UniformBuffer::activate | ( | ) |
Activates this uniform block so that if can receive data.
This method makes this uniform block the active uniform buffer. This means that changes made to the data in this uniform buffer will be pushed to the graphics card. If there were are any pending changes to the uniform buffer (made when it was not active), they will be pushed immediately when this method is called.
This method does not bind the uniform block to a bind point. That must be done with a call to bind
.
This call is reentrant. If can be safely called multiple times.
|
inlinestatic |
Returns a new uniform block to support a block of the given capacity.
This uniform buffer will only support a single block. The block capacity is measured in bytes. In std140 format, all scalars are 4 bytes, vectors are 8 or 16 bytes, and matrices are treated as an array of 8 or 16 byte column vectors.
The drawtype is GL_STATIC_DRAW, GL_DYNAMIC_DRAW, or GL_STREAM_DRAW. If the uniform values change often, the difference between GL_STATIC_DRAW and GL_STREAM_DRAW is 1-2 orders of magnitude.
capacity | The block capacity in bytes |
|
inlinestatic |
Returns a new uniform buffer to support multiple blocks of the given capacity.
The block capacity is measured in bytes. In std140 format, all scalars are 4 bytes, vectors are 8 or 16 bytes, and matrices are treated as an array of 8 or 16 byte column vectors.
Keep in mind that uniform buffer blocks must be aligned, and so this may take significantly more memory than the number of blocks times the capacity. If the graphics card cannot support that many blocks, this method will return nullptr.
The drawtype is GL_STATIC_DRAW, GL_DYNAMIC_DRAW, or GL_STREAM_DRAW. If the uniform values change often, the difference between GL_STATIC_DRAW and GL_STREAM_DRAW is 1-2 orders of magnitude.
capacity | The block capacity in bytes |
blocks | The number of blocks to support |
void cugl::UniformBuffer::bind | ( | bool | activate = true | ) |
Binds this uniform buffer to its bind point.
Unlike Texture
, it is possible to bind a uniform buffer to its bind point without making it the active uniform buffer. An inactive buffer will still stream data to the shader, though its data cannot be altered without making it active.
Binding a buffer to a bind point replaces the uniform block originally there. So this buffer can be unbound without a call to unbind
. However, if another buffer is bound to a different bind point than this block, it will not affect this buffer's relationship with the shader.
For compatibility reasons with Texture
we allow this method to both bind and activate the uniform buffer in one call.
This call is reentrant. If can be safely called multiple times.
activate | Whether to activate this buffer in addition to binding. |
void cugl::UniformBuffer::deactivate | ( | ) |
Deactivates this uniform block, making it no longer active.
This method will not unbind the buffer from its bind point (assuming it is bound to one). It simply means that it is no longer the active uniform buffer and cannot receive new data. Data sent to this buffer will be cached and sent to the graphics card once the buffer is reactivated. However, the shader will use the current graphics card data until that happens.
This call is reentrant. If can be safely called multiple times.
void cugl::UniformBuffer::dispose | ( | ) |
Deletes the uniform buffer, freeing all resources.
You must reinitialize the uniform buffer to use it.
void cugl::UniformBuffer::flush | ( | ) |
Flushes any changes in the backing byte buffer to the graphics card.
This method must be called if any changes have been made to the buffer data and auto-flush is not turned on (which is the default). Even if auto-flush is turned on, it must be called if the user has accessed the backing byte buffer directly via getData
.
This method requires the byte buffer to be active.
|
inline |
Returns true if this uniform buffer supports autoflushing.
Active, auto-flushed buffers write data directly to the graphics card as soon as it is provided to the buffer. A buffer than does not auto-flush will not write to the graphics card until flush
is called, even if it is active.
By default, autoflushing is turned off.
|
inline |
Returns the bind point for this uniform buffer.
Uniform buffers and shaders have a many-to-many relationship. This means that connecting them requires an intermediate table. The positions in this table are called bind points. A uniform buffer is associated with a bind point and a shader associates a bind point with a uniform struct. That uniform struct then pulls data from the active block of the uniform buffer. By default this value is 0.
|
inline |
Returns the active uniform block in this buffer.
The active uniform block is the block from which the shader will pull uniform values. This value can be altered even if the buffer is not active (or even bound)
|
inline |
Returns the number of blocks supported by this buffer.
A uniform buffer can support multiple uniform blocks at once. The active block is identify by the method getBlock
.
|
inline |
Returns the capacity of a single block in this uniform buffer.
The block size is the amount of data necessary to populate the uniforms for a single block. It is measured in bytes.
|
inline |
Returns the stride of a single block in this uniform buffer.
The stride measures the alignment (in bytes) of a block. It is at least as large as the block capacity, but may be more.
|
inline |
Returns the OpenGL buffer for this uniform buffer.
The buffer is a value assigned by OpenGL when the uniform buffer was allocated. This method will return 0 if the block is not initialized. This method is provided to allow the user direct access to the buffer for maximum flexibility.
|
inline |
Returns the backing byte-buffer for the uniform buffer
The byte buffer is used to store pending changes while the buffer is active (and is kept synchronized when it is active). This method allows direct access for bulk writes the buffer. However, the graphics card will not be aware of any of these changes until flush()
is called.
The buffer returned will have a capacity of (block count) x (block stride).
|
inline |
Returns the draw type for this buffer
The drawtype is GL_STATIC_DRAW, GL_DYNAMIC_DRAW, or GL_STREAM_DRAW. If the uniform values change often, the difference between GL_STATIC_DRAW and GL_STREAM_DRAW is 1-2 orders of magnitude.
By default, the draw type is GL_STREAM_DRAW.
|
inline |
Returns the name of this uniform buffer.
A name is a user-defined way of identifying a buffer. It is typically the appropriate shader variable name, but this is not necessary for it to function properly.
GLsizei cugl::UniformBuffer::getOffset | ( | const std::string | name | ) | const |
Returns the byte offset for the given name.
This method requires that name be previously associated with an offset via setOffset
. If it has not been associated with an offset, then this method will return INVALID_OFFSET
instead.
name | The variable name to query for an offset |
std::vector< std::string > cugl::UniformBuffer::getOffsets | ( | ) | const |
Returns the offsets defined for this buffer
The vector returned will include the name of every variable set by the method setOffset
.
bool cugl::UniformBuffer::getUniformAffine2 | ( | GLuint | block, |
const std::string | name, | ||
Affine2 & | mat | ||
) | const |
Returns true if it can access the given uniform variable as an affine transform.
Affine transforms are read from a uniform block as a 4x3 matrix on homogenous coordinates. That is because the columns must be 4*sizeof(float) bytes for alignment reasons. The buffer must have 12*sizeof(float) bytes available for this read.
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
mat | The matrix to store the result |
bool cugl::UniformBuffer::getUniformAffine2 | ( | GLuint | block, |
GLsizei | offset, | ||
Affine2 & | mat | ||
) | const |
Returns true if it can access the given uniform variable as an affine transform.
Affine transforms are read from a uniform block as a 4x3 matrix on homogenous coordinates. That is because the columns must be 4*sizeof(float) bytes for alignment reasons. The buffer must have 12*sizeof(float) bytes available for this read.
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
offset | The offset within the block |
mat | The matrix to store the result |
bool cugl::UniformBuffer::getUniformColor4 | ( | GLuint | block, |
const std::string | name, | ||
Color4 & | color | ||
) | const |
Returns true if it can access the given uniform variable as a color.
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. This method will read the color as 4*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
color | The color to store the result |
bool cugl::UniformBuffer::getUniformColor4 | ( | GLuint | block, |
GLsizei | offset, | ||
Color4 & | color | ||
) | const |
Returns true if it can access the given uniform variable as a color.
This method will read the color as 4*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
offset | The offset within the block |
color | The color to store the result |
bool cugl::UniformBuffer::getUniformColor4f | ( | GLuint | block, |
const std::string | name, | ||
Color4f & | color | ||
) | const |
Returns true if it can access the given uniform variable as a color.
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. This method will read the color as 4*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
color | The color to store the result |
bool cugl::UniformBuffer::getUniformColor4f | ( | GLuint | block, |
GLsizei | offset, | ||
Color4f & | color | ||
) | const |
Returns true if it can access the given uniform variable as a color.
This method will read the color as 4*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
offset | The offset within the block |
color | The color to store the result |
bool cugl::UniformBuffer::getUniformfv | ( | GLuint | block, |
const std::string | name, | ||
GLsizei | size, | ||
GLfloat * | values | ||
) | const |
Returns true if it can access the given buffer location as an array of floats
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
size | The available size of the value array |
values | The array to receive the values |
bool cugl::UniformBuffer::getUniformfv | ( | GLuint | block, |
GLsizei | offset, | ||
GLsizei | size, | ||
GLfloat * | values | ||
) | const |
Returns true if it can access the given buffer offset as an array of floats
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
offset | The offset within the block |
size | The available size of the value array |
values | The array to receive the values |
bool cugl::UniformBuffer::getUniformiv | ( | GLuint | block, |
const std::string | name, | ||
GLsizei | size, | ||
GLint * | values | ||
) | const |
Returns true if it can access the given buffer location as an array of integers
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
size | The available size of the value array |
values | The array to receive the values |
bool cugl::UniformBuffer::getUniformiv | ( | GLuint | block, |
GLsizei | offset, | ||
GLsizei | size, | ||
GLint * | values | ||
) | const |
Returns true if it can access the given buffer offset as an array of integers
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
offset | The offset within the block |
size | The available size of the value array |
values | The array to receive the values |
bool cugl::UniformBuffer::getUniformMat4 | ( | GLuint | block, |
const std::string | name, | ||
Mat4 & | mat | ||
) | const |
Returns true if it can access the given uniform variable as a matrix.
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. This method will read the matrix as 16*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
mat | The matrix to store the result |
bool cugl::UniformBuffer::getUniformMat4 | ( | GLuint | block, |
GLsizei | offset, | ||
Mat4 & | mat | ||
) | const |
Returns true if it can access the given uniform variable as a matrix.
This method will read the matrix as 16*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
offset | The offset within the block |
mat | The matrix to store the result |
bool cugl::UniformBuffer::getUniformQuaternion | ( | GLuint | block, |
const std::string | name, | ||
Quaternion & | quat | ||
) | const |
Returns true if it can access the given uniform variable as a quaternion.
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. This method will read the quaternion as 4*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
quat | The quaternion to store the result |
bool cugl::UniformBuffer::getUniformQuaternion | ( | GLuint | block, |
GLsizei | offset, | ||
Quaternion & | quat | ||
) | const |
Returns true if it can access the given uniform variable as a quaternion.
This method will read the quaternion as 4*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
offset | The offset within the block |
quat | The quaternion to store the result |
bool cugl::UniformBuffer::getUniformuiv | ( | GLuint | block, |
const std::string | name, | ||
GLsizei | size, | ||
GLuint * | values | ||
) | const |
Returns true if it can access the buffer location as an array of unsigned integers
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
size | The available size of the value array |
values | The array to receive the values |
bool cugl::UniformBuffer::getUniformuiv | ( | GLuint | block, |
GLsizei | offset, | ||
GLsizei | size, | ||
GLuint * | values | ||
) | const |
Returns true if it can access the buffer offset as an array of unsigned integers
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
offset | The offset within the block |
size | The available size of the value array |
values | The array to receive the values |
bool cugl::UniformBuffer::getUniformVec2 | ( | GLuint | block, |
const std::string | name, | ||
Vec2 & | vec | ||
) | const |
Returns true if it can access the given uniform variable as a vector.
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. This method will read the vector as 2*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
vec | The vector to store the result |
bool cugl::UniformBuffer::getUniformVec2 | ( | GLuint | block, |
GLsizei | offset, | ||
Vec2 & | vec | ||
) | const |
Returns true if it can access the given uniform variable as a vector.
This method will read the vector as 2*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
offset | The offset within the block |
vec | The vector to store the result |
bool cugl::UniformBuffer::getUniformVec3 | ( | GLuint | block, |
const std::string | name, | ||
Vec3 & | vec | ||
) | const |
Returns true if it can access the given uniform variable as a vector.
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. This method will read the vector as 3*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
vec | The vector to store the result |
bool cugl::UniformBuffer::getUniformVec3 | ( | GLuint | block, |
GLsizei | offset, | ||
Vec3 & | vec | ||
) | const |
Returns true if it can access the given uniform variable as a vector.
This method will read the vector as 3*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
offset | The offset within the block |
vec | The vector to store the result |
bool cugl::UniformBuffer::getUniformVec4 | ( | GLuint | block, |
const std::string | name, | ||
Vec4 & | vec | ||
) | const |
Returns true if it can access the given uniform variable as a vector.
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. This method will read the vector as 4*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
vec | The vector to store the result |
bool cugl::UniformBuffer::getUniformVec4 | ( | GLuint | block, |
GLsizei | offset, | ||
Vec4 & | vec | ||
) | const |
Returns true if it can access the given uniform variable as a vector.
This method will read the vector as 4*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
The buffer does not have to be active to call this method. If it is not active and there are pending changes to this uniform variable, this method will read those changes and not the current value in the graphics card.
block | The block in this uniform buffer to access |
offset | The offset within the block |
vec | The vector to store the result |
bool cugl::UniformBuffer::init | ( | GLsizei | capacity | ) |
Initializes this uniform buffer to support a block of the given capacity.
This uniform buffer will only support a single block. The block capacity is measured in bytes. In std140 format, all scalars are 4 bytes, vectors are 8 or 16 bytes, and matrices are treated as an array of 8 or 16 byte column vectors.
capacity | The block capacity in bytes |
bool cugl::UniformBuffer::init | ( | GLsizei | capacity, |
GLuint | blocks | ||
) |
Initializes this uniform buffer to support multiple blocks of the given capacity.
The block capacity is measured in bytes. In std140 format, all scalars are 4 bytes, vectors are 8 or 16 bytes, and matrices are treated as an array of 8 or 16 byte column vectors.
Keep in mind that uniform buffer blocks must be aligned, and so this may take significantly more memory than the number of blocks times the capacity. If the graphics card cannot support that many blocks, this method will return false.
The drawtype is GL_STATIC_DRAW, GL_DYNAMIC_DRAW, or GL_STREAM_DRAW. If the uniform values change often, the difference between GL_STATIC_DRAW and GL_STREAM_DRAW is 1-2 orders of magnitude.
capacity | The block capacity in bytes |
blocks | The number of blocks to support |
bool cugl::UniformBuffer::isActive | ( | ) | const |
Returns true if this uniform buffer is currently active.
An active uniform block is the one that pushes changes in data directly to the graphics card. If the buffer is not active, then many of the setter methods in this class will cache changes but delay applying them until the buffer is reactivated.
Unlike Texture
, it is possible for a uniform buffer to be active but not bound.
bool cugl::UniformBuffer::isBound | ( | ) | const |
Returns true if this uniform buffer is currently bound.
A uniform buffer is bound if it is attached to a bind point. That means that the shader will pull its data for that bind point from this buffer. A uniform block can be bound without being active.
|
inline |
Returns true if this uniform buffer has been properly initialized.
|
inline |
Sets whether this uniform buffer supports autoflushing.
Active, auto-flushed buffers write data directly to the graphics card as soon as it is provided to the buffer. A buffer than does not auto-flush will not write to the graphics card until flush
is called, even if it is active.
By default, autoflushing is turned off.
style | Whether this uniform buffer supports autoflushing. |
void cugl::UniformBuffer::setBindPoint | ( | GLuint | point | ) |
Sets the bind point for this uniform buffer.
Uniform buffers and shaders have a many-to-many relationship. This means that connecting them requires an intermediate table. The positions in this table are called bind points. A uniform buffer is associated with a bind point and a shader associates a bind point with a uniform struct. That uniform struct then pulls data from the active block of the uniform buffer. By default this value is 0.
The uniform buffer does not need to be active to call this method. This method only sets the bind point preference and does not actually bind
the buffer. However, if the buffer is bound to another bind point, then it will be unbound from that point.
point | The bind point for for this uniform buffer. |
void cugl::UniformBuffer::setBlock | ( | GLuint | block | ) |
Sets the active uniform block in this buffer.
The active uniform block is the block from which the shader will pull uniform values. This value can only be altered if this buffer is bound (though it need not be active).
block | The active uniform block in this buffer. |
|
inline |
Sets the draw type for this buffer
The drawtype is GL_STATIC_DRAW, GL_DYNAMIC_DRAW, or GL_STREAM_DRAW. If the uniform values change often, the difference between GL_STATIC_DRAW and GL_STREAM_DRAW is 1-2 orders of magnitude.
By default, the draw type is GL_STREAM_DRAW.
type | The draw type for this buffer |
|
inline |
Sets the name of this uniform buffer.
A name is a user-defined way of identifying a buffer. It is typically the appropriate shader variable name, but this is not necessary for it to function properly.
name | The name of this uniform block. |
void cugl::UniformBuffer::setOffset | ( | const std::string | name, |
GLsizei | offset | ||
) |
Defines the byte offset of the given buffer variable.
It is not necessary to call this method to use the uniform buffer. It is always possible to pass data to the uniform block by specifying the byte offset. The shader uses byte offsets to pull data from the uniform buffer and assign it to the appropriate struct variable.
However, this method makes use of the uniform buffer easier to follow. It explicitly assigns a variable name to a byte offset. This variable name can now be used in place of the byte offset with passing data to this uniform block.
Use of this method does not require the uniform buffer to be bound or even active.
name | The variable name to use for this offset |
offset | The buffer offset in bytes |
void cugl::UniformBuffer::setUniformAffine2 | ( | GLint | block, |
const std::string | name, | ||
const Affine2 & | mat | ||
) |
Sets the given uniform variable to an affine transform.
Affine transforms are passed to a uniform block as a 4x3 matrix on homogenous coordinates. That is because the columns must be 4*sizeof(float) bytes for alignment reasons. The buffer must have 12*sizeof(float) bytes available for this write.
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
mat | The value for the uniform |
void cugl::UniformBuffer::setUniformAffine2 | ( | GLint | block, |
GLsizei | offset, | ||
const Affine2 & | mat | ||
) |
Sets the given uniform variable to an affine transform.
Affine transforms are passed to a uniform block as a 4x3 matrix on homogenous coordinates. That is because the columns must be 4*sizeof(float) bytes for alignment reasons. The buffer must have 12*sizeof(float) bytes available for this write.
Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
offset | The offset within the block |
mat | The value for the uniform |
void cugl::UniformBuffer::setUniformColor4 | ( | GLint | block, |
const std::string | name, | ||
const Color4 | color | ||
) |
Sets the given uniform variable to a color value.
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. This method will write the color as 4*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
color | The value for the uniform |
void cugl::UniformBuffer::setUniformColor4 | ( | GLint | block, |
GLsizei | offset, | ||
const Color4 | color | ||
) |
Sets the given uniform variable to a color value.
This method will write the color as 4*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
offset | The offset within the block |
color | The value for the uniform |
void cugl::UniformBuffer::setUniformColor4f | ( | GLint | block, |
const std::string | name, | ||
const Color4f | color | ||
) |
Sets the given uniform variable to a color value.
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. This method will write the color as 4*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
color | The value for the uniform |
void cugl::UniformBuffer::setUniformColor4f | ( | GLint | block, |
GLsizei | offset, | ||
const Color4f | color | ||
) |
Sets the given uniform variable to a color value.
This method will write the color as 4*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
offset | The offset within the block |
color | The value for the uniform |
void cugl::UniformBuffer::setUniformfv | ( | GLint | block, |
const std::string | name, | ||
GLsizei | size, | ||
const GLfloat * | values | ||
) |
Sets the given buffer location to an array of float values
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
size | The number of values to write to the buffer |
values | The values to write |
void cugl::UniformBuffer::setUniformfv | ( | GLint | block, |
GLsizei | offset, | ||
GLsizei | size, | ||
const GLfloat * | values | ||
) |
Sets the given buffer offset to an array of float values
Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
offset | The offset within the block |
size | The number of values to write to the buffer |
values | The values to write |
void cugl::UniformBuffer::setUniformiv | ( | GLint | block, |
const std::string | name, | ||
GLsizei | size, | ||
const GLint * | values | ||
) |
Sets the given buffer location to an array of integer values
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
size | The number of values to write to the buffer |
values | The values to write |
void cugl::UniformBuffer::setUniformiv | ( | GLint | block, |
GLsizei | offset, | ||
GLsizei | size, | ||
const GLint * | values | ||
) |
Sets the given buffer offset to an array of integer values
Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
offset | The offset within the block |
size | The number of values to write to the buffer |
values | The values to write |
void cugl::UniformBuffer::setUniformMat4 | ( | GLint | block, |
const std::string | name, | ||
const Mat4 & | mat | ||
) |
Sets the given uniform variable to a matrix value.
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. This method will write the matrix as 16*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
mat | The value for the uniform |
void cugl::UniformBuffer::setUniformMat4 | ( | GLint | block, |
GLsizei | offset, | ||
const Mat4 & | mat | ||
) |
Sets the given uniform variable to a matrix value.
This method will write the matrix as 16*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
offset | The offset within the block |
mat | The value for the uniform |
void cugl::UniformBuffer::setUniformQuaternion | ( | GLint | block, |
const std::string | name, | ||
const Quaternion & | quat | ||
) |
Sets the given uniform variable to a quaternion
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. This method will write the quaternion as 4*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
quat | The value for the uniform |
void cugl::UniformBuffer::setUniformQuaternion | ( | GLint | block, |
GLsizei | offset, | ||
const Quaternion & | quat | ||
) |
Sets the given uniform variable to a quaternion.
This method will write the quaternion as 4*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
offset | The offset within the block |
quat | The value for the uniform |
void cugl::UniformBuffer::setUniformuiv | ( | GLint | block, |
const std::string | name, | ||
GLsizei | size, | ||
const GLuint * | values | ||
) |
Sets the given buffer location to an array of unsigned integer values
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
size | The number of values to write to the buffer |
values | The values to write |
void cugl::UniformBuffer::setUniformuiv | ( | GLint | block, |
GLsizei | offset, | ||
GLsizei | size, | ||
const GLuint * | values | ||
) |
Sets the given buffer offset to an array of unsigned integer values
Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
offset | The offset within the block |
size | The number of values to write to the buffer |
values | The values to write |
void cugl::UniformBuffer::setUniformVec2 | ( | GLint | block, |
const std::string | name, | ||
const Vec2 | vec | ||
) |
Sets the given uniform variable to a vector value.
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. This method will write the vector as 2*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
vec | The value for the uniform |
void cugl::UniformBuffer::setUniformVec2 | ( | GLint | block, |
GLsizei | offset, | ||
const Vec2 | vec | ||
) |
Sets the given uniform variable to a vector value.
This method will write the vector as 2*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
offset | The offset within the block |
vec | The value for the uniform |
void cugl::UniformBuffer::setUniformVec3 | ( | GLint | block, |
const std::string | name, | ||
const Vec3 | vec | ||
) |
Sets the given uniform variable to a vector value.
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. This method will write the vector as 3*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
The buffer does not need to be active to call this method. However, changes made while the buffer is inactive will be cached and not applied until the buffer is reactivated.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
vec | The value for the uniform |
void cugl::UniformBuffer::setUniformVec3 | ( | GLint | block, |
GLsizei | offset, | ||
const Vec3 | vec | ||
) |
Sets the given uniform variable to a vector value.
This method will write the vector as 3*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
offset | The offset within the block |
vec | The value for the uniform |
void cugl::UniformBuffer::setUniformVec4 | ( | GLint | block, |
const std::string | name, | ||
const Vec4 | vec | ||
) |
Sets the given uniform variable to a vector value.
This method requires that the uniform name be previously bound to a byte offset with the call setOffset
. This method will write the vector as 4*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
name | The name of the uniform variable |
vec | The value for the uniform |
void cugl::UniformBuffer::setUniformVec4 | ( | GLint | block, |
GLsizei | offset, | ||
const Vec4 | vec | ||
) |
Sets the given uniform variable to a vector value.
This method will write the vector as 4*sizeof(float) bytes to the appropriate buffer location (and the buffer must have the appropriate capacity).
Values set by this method will not be sent to the graphics card until the buffer is flushed. However, if the buffer is active and auto-flush is turned on, it will be written immediately.
If block is -1, it sets this value in every block in this uniform buffer. This is a potentially expensive operation if the block is active. For mass changes, it is better to deactivate the buffer, and have them apply once the buffer is reactivated.
block | The block in this uniform buffer to access |
offset | The offset within the block |
vec | The value for the uniform |
void cugl::UniformBuffer::unbind | ( | ) |
Unbinds this uniform buffer disassociating it from its bind point.
This call will have no affect on the active buffer (e.g. which buffer is receiving data from the program). This method simply removes this buffer from its bind point.
Once unbound, the bind point for this buffer will no longer send data to the appropriate uniform(s) in the shader. In that case the shader will use default values according to the variable types.
This call is reentrant. If can be safely called multiple times.
|
static |
The byte position of an invalid offset