Files Class List
GLSLProgram Class Reference

Detailed Description

GLSL program class.

This class provides basic functionality for building GLSL programs using vertex and fragment shaders, along with optionally geometry and tessellation shaders. The shader sources can be provides as GLSLShader class objects, source strings, or file names. This class also stores a vector of registered uniform parameter IDs.

#include <cyGL.h>

Classes

class  Param
 

Public Member Functions

 GLSLProgram ()
 Constructor.
 
virtual ~GLSLProgram ()
 Destructor that deletes the program.
 
Param operator[] (char const *name)
 
GLint AttribLocation (char const *name) const
 
void SetAttribBuffer (char const *name, GLint arrayBufferID, int dimensions, GLenum type=GL_FLOAT)
 
void EnableAttrib (char const *name)
 
void DisableAttrib (char const *name)
 
General Methods
void Delete ()
 Deletes the program.
 
GLuint GetID () const
 Returns the program ID.
 
bool IsNull () const
 Returns true if the OpenGL program object is not generated, i.e. the program id is invalid.
 
void Bind () const
 Binds the program for rendering.
 
void CreateProgram ()
 Attaches the given shader to the program. This function must be called before calling Link.
 
void AttachShader (GLSLShader const &shader)
 Attaches the given shader to the program. This function must be called before calling Link.
 
void AttachShader (GLuint shaderID)
 Attaches the given shader to the program. This function must be called before calling Link.
 
bool Link (std::ostream *outStream=&std::cout)
 Links the program. The shaders must be attached before calling this function. Returns true if the link operation is successful. Writes any error or warning messages to the given output stream.
 
Build Methods
bool Build (GLSLShader const *vertexShader, GLSLShader const *fragmentShader, GLSLShader const *geometryShader=nullptr, GLSLShader const *tessControlShader=nullptr, GLSLShader const *tessEvaluationShader=nullptr, std::ostream *outStream=&std::cout)
 Creates a program, compiles the given shaders, and links them. Returns true if all compilation and link operations are successful. Writes any error or warning messages to the given output stream.
 
bool BuildFiles (char const *vertexShaderFile, char const *fragmentShaderFile, char const *geometryShaderFile=nullptr, char const *tessControlShaderFile=nullptr, char const *tessEvaluationShaderFile=nullptr, std::ostream *outStream=&std::cout)
 Creates a program, compiles the given shaders, and links them. Returns true if all compilation and link operations are successful. Writes any error or warning messages to the given output stream.
 
bool BuildFiles (char const *vertexShaderFile, char const *fragmentShaderFile, char const *geometryShaderFile, char const *tessControlShaderFile, char const *tessEvaluationShaderFile, char const *prependSource, std::ostream *outStream=&std::cout)
 Creates a program, compiles the given shaders, and links them. Returns true if all compilation and link operations are successful. Writes any error or warning messages to the given output stream. The prependSource string is added to the beginning of each shader code, so it must begin with the "#version" statement.
 
bool BuildFiles (char const *vertexShaderFile, char const *fragmentShaderFile, char const *geometryShaderFile, char const *tessControlShaderFile, char const *tessEvaluationShaderFile, int prependSourceCount, char const **prependSource, std::ostream *outStream=&std::cout)
 Creates a program, compiles the given shaders, and links them. Returns true if all compilation and link operations are successful. Writes any error or warning messages to the given output stream. The prependSources strings are added to the beginning of each shader code, so the first string must begin with "#version" statement.
 
bool BuildSources (char const *vertexShaderSourceCode, char const *fragmentShaderSourceCode, char const *geometryShaderSourceCode=nullptr, char const *tessControlShaderSourceCode=nullptr, char const *tessEvaluationShaderSourceCode=nullptr, std::ostream *outStream=&std::cout)
 Creates a program, compiles the given shaders, and links them. Returns true if all compilation and link operations are successful. Writes any error or warning messages to the given output stream.
 
bool BuildSources (char const *vertexShaderSourceCode, char const *fragmentShaderSourceCode, char const *geometryShaderSourceCode, char const *tessControlShaderSourceCode, char const *tessEvaluationShaderSourceCode, char const *prependSource, std::ostream *outStream=&std::cout)
 Creates a program, compiles the given shaders, and links them. Returns true if all compilation and link operations are successful. Writes any error or warning messages to the given output stream. The prependSource string is added to the beginning of each shader code, so it must begin with the "#version" statement.
 
bool BuildSources (char const *vertexShaderSourceCode, char const *fragmentShaderSourceCode, char const *geometryShaderSourceCode, char const *tessControlShaderSourceCode, char const *tessEvaluationShaderSourceCode, int prependSourceCount, char const **prependSource, std::ostream *outStream=&std::cout)
 Creates a program, compiles the given shaders, and links them. Returns true if all compilation and link operations are successful. Writes any error or warning messages to the given output stream. The prependSources strings are added to the beginning of each shader code, so the first string must begin with "#version" statement.
 
Uniform Parameter Methods
void RegisterUniform (unsigned int index, char const *name, std::ostream *outStream=&std::cout)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void RegisterUniforms (char const *names, unsigned int startingIndex=0, std::ostream *outStream=&std::cout)
 Registers multiple parameters. The names should be separated by a space character.
 
void SetUniform (int index, float x)
 Sets the value of the uniform parameter with the given index. The uniform parameter must be registered before using RegisterUniform() or RegisterUniforms(). The program must be bind by calling Bind() before calling this method.
 
void SetUniform (int index, float x, float y)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, float x, float y, float z)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, float x, float y, float z, float w)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform1 (int index, int count, float const *data)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform2 (int index, int count, float const *data)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform3 (int index, int count, float const *data)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform4 (int index, int count, float const *data)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, int x)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, int x, int y)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, int x, int y, int z)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, int x, int y, int z, int w)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform1 (int index, int count, int const *data)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform2 (int index, int count, int const *data)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform3 (int index, int count, int const *data)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform4 (int index, int count, int const *data)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, GLuint x)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, GLuint x, GLuint y)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, GLuint x, GLuint y, GLuint z)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, GLuint x, GLuint y, GLuint z, GLuint w)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform1 (int index, int count, GLuint const *data)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform2 (int index, int count, GLuint const *data)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform3 (int index, int count, GLuint const *data)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform4 (int index, int count, GLuint const *data)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, double x)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, double x, double y)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, double x, double y, double z)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, double x, double y, double z, double w)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform1 (int index, int count, double const *data)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform2 (int index, int count, double const *data)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform3 (int index, int count, double const *data)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform4 (int index, int count, double const *data)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix2 (int index, float const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix3 (int index, float const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix4 (int index, float const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix2x3 (int index, float const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix2x4 (int index, float const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix3x2 (int index, float const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix3x4 (int index, float const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix4x2 (int index, float const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix4x3 (int index, float const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix2 (int index, double const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix3 (int index, double const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix4 (int index, double const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix2x3 (int index, double const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix2x4 (int index, double const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix3x2 (int index, double const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix3x4 (int index, double const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix4x2 (int index, double const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniformMatrix4x3 (int index, double const *m, int count=1, bool transpose=false)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec2< float > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec3< float > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec4< float > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec2< int > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec3< int > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec4< int > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec2< float > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec3< float > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec4< float > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec2< int > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec3< int > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec4< int > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec2< GLuint > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec3< GLuint > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec4< GLuint > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec2< GLuint > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec3< GLuint > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec4< GLuint > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec2< double > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec3< double > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec4< double > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec2< double > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec3< double > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Vec4< double > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, IVec2< int > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, IVec3< int > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, IVec4< int > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, IVec2< int > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, IVec3< int > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, IVec4< int > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, IVec2< GLuint > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, IVec3< GLuint > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, IVec4< GLuint > const &p)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, IVec2< GLuint > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, IVec3< GLuint > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, IVec4< GLuint > const *p, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Matrix2< float > const &m)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Matrix3< float > const &m)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Matrix4< float > const &m)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Matrix2< float > const *m, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Matrix3< float > const *m, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Matrix4< float > const *m, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Matrix34< float > const &m)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Matrix34< float > const *m, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Matrix2< double > const &m)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Matrix3< double > const &m)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Matrix4< double > const &m)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Matrix34< double > const &m)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Matrix2< double > const *m, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Matrix3< double > const *m, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Matrix4< double > const *m, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (int index, Matrix34< double > const *m, int count=1)
 Registers a single uniform parameter. The index must be unique and the name should match a uniform parameter name in one of the shaders. The index values for different parameters don't have to be consecutive, but unused index values waste memory.
 
void SetUniform (char const *name, float x)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, float x, float y)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, float x, float y, float z)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, float x, float y, float z, float w)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform1 (char const *name, int count, float const *data)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform2 (char const *name, int count, float const *data)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform3 (char const *name, int count, float const *data)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform4 (char const *name, int count, float const *data)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, int x)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, int x, int y)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, int x, int y, int z)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, int x, int y, int z, int w)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform1 (char const *name, int count, int const *data)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform2 (char const *name, int count, int const *data)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform3 (char const *name, int count, int const *data)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform4 (char const *name, int count, int const *data)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, GLuint x)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, GLuint x, GLuint y)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, GLuint x, GLuint y, GLuint z)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, GLuint x, GLuint y, GLuint z, GLuint w)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform1 (char const *name, int count, GLuint const *data)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform2 (char const *name, int count, GLuint const *data)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform3 (char const *name, int count, GLuint const *data)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform4 (char const *name, int count, GLuint const *data)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, double x)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, double x, double y)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, double x, double y, double z)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, double x, double y, double z, double w)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform1 (char const *name, int count, double const *data)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform2 (char const *name, int count, double const *data)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform3 (char const *name, int count, double const *data)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform4 (char const *name, int count, double const *data)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix2 (char const *name, float const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix3 (char const *name, float const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix4 (char const *name, float const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix2x3 (char const *name, float const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix2x4 (char const *name, float const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix3x2 (char const *name, float const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix3x4 (char const *name, float const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix4x2 (char const *name, float const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix4x3 (char const *name, float const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix2 (char const *name, double const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix3 (char const *name, double const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix4 (char const *name, double const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix2x3 (char const *name, double const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix2x4 (char const *name, double const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix3x2 (char const *name, double const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix3x4 (char const *name, double const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix4x2 (char const *name, double const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniformMatrix4x3 (char const *name, double const *m, int count=1, bool transpose=false)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec2< float > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec3< float > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec4< float > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec2< int > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec3< int > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec4< int > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec2< float > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec3< float > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec4< float > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec2< int > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec3< int > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec4< int > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec2< GLuint > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec3< GLuint > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec4< GLuint > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec2< GLuint > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec3< GLuint > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec4< GLuint > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec2< double > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec3< double > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec4< double > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec2< double > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec3< double > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Vec4< double > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, IVec2< int > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, IVec3< int > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, IVec4< int > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, IVec2< int > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, IVec3< int > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, IVec4< int > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, IVec2< GLuint > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, IVec3< GLuint > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, IVec4< GLuint > const &p)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, IVec2< GLuint > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, IVec3< GLuint > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, IVec4< GLuint > const *p, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Matrix2< float > const &m)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Matrix3< float > const &m)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Matrix4< float > const &m)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Matrix2< float > const *m, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Matrix3< float > const *m, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Matrix4< float > const *m, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Matrix34< float > const &m)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Matrix34< float > const *m, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Matrix2< double > const &m)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Matrix3< double > const &m)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Matrix4< double > const &m)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Matrix34< double > const &m)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Matrix2< double > const *m, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Matrix3< double > const *m, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Matrix4< double > const *m, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.
 
void SetUniform (char const *name, Matrix34< double > const *m, int count=1)
 glUseProgram(programID); int id = glGetUniformLocation( programID, name ); if ( id >= 0 ) Sets the value of the uniform parameter with the given name, if the uniform parameter is found. Since it searches for the uniform parameter first, it is not as efficient as setting the uniform parameter using a previously registered id. There is no need to bind the program before calling this method.