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>

Public Member Functions

 GLSLProgram ()
 
virtual ~GLSLProgram ()
 
General Methods
void Delete ()
 
GLuint GetID () const
 
bool IsNull () const
 
void Bind () const
 
void CreateProgram ()
 
void AttachShader (const GLSLShader &shader)
 
void AttachShader (GLuint shaderID)
 
bool Link (std::ostream *outStream=&std::cout)
 
Build Methods
bool Build (const GLSLShader *vertexShader, const GLSLShader *fragmentShader, const GLSLShader *geometryShader=nullptr, const GLSLShader *tessControlShader=nullptr, const GLSLShader *tessEvaluationShader=nullptr, std::ostream *outStream=&std::cout)
 
bool BuildFiles (const char *vertexShaderFile, const char *fragmentShaderFile, const char *geometryShaderFile=nullptr, const char *tessControlShaderFile=nullptr, const char *tessEvaluationShaderFile=nullptr, std::ostream *outStream=&std::cout)
 
bool BuildFiles (const char *vertexShaderFile, const char *fragmentShaderFile, const char *geometryShaderFile, const char *tessControlShaderFile, const char *tessEvaluationShaderFile, const char *prependSource, std::ostream *outStream=&std::cout)
 
bool BuildFiles (const char *vertexShaderFile, const char *fragmentShaderFile, const char *geometryShaderFile, const char *tessControlShaderFile, const char *tessEvaluationShaderFile, int prependSourceCount, const char **prependSource, std::ostream *outStream=&std::cout)
 
bool BuildSources (const char *vertexShaderSourceCode, const char *fragmentShaderSourceCode, const char *geometryShaderSourceCode=nullptr, const char *tessControlShaderSourceCode=nullptr, const char *tessEvaluationShaderSourceCode=nullptr, std::ostream *outStream=&std::cout)
 
bool BuildSources (const char *vertexShaderSourceCode, const char *fragmentShaderSourceCode, const char *geometryShaderSourceCode, const char *tessControlShaderSourceCode, const char *tessEvaluationShaderSourceCode, const char *prependSource, std::ostream *outStream=&std::cout)
 
bool BuildSources (const char *vertexShaderSourceCode, const char *fragmentShaderSourceCode, const char *geometryShaderSourceCode, const char *tessControlShaderSourceCode, const char *tessEvaluationShaderSourceCode, int prependSourceCount, const char **prependSource, std::ostream *outStream=&std::cout)
 
Uniform Parameter Methods
void RegisterUniform (unsigned int index, const char *name, std::ostream *outStream=&std::cout)
 
void RegisterUniforms (const char *names, unsigned int startingIndex=0, std::ostream *outStream=&std::cout)
 
void SetUniform (int index, float x)
 
void SetUniform (int index, float x, float y)
 
void SetUniform (int index, float x, float y, float z)
 
void SetUniform (int index, float x, float y, float z, float w)
 
void SetUniform1 (int index, int count, const float *data)
 
void SetUniform2 (int index, int count, const float *data)
 
void SetUniform3 (int index, int count, const float *data)
 
void SetUniform4 (int index, int count, const float *data)
 
void SetUniform (int index, int x)
 
void SetUniform (int index, int x, int y)
 
void SetUniform (int index, int x, int y, int z)
 
void SetUniform (int index, int x, int y, int z, int w)
 
void SetUniform1 (int index, int count, const int *data)
 
void SetUniform2 (int index, int count, const int *data)
 
void SetUniform3 (int index, int count, const int *data)
 
void SetUniform4 (int index, int count, const int *data)
 
void SetUniform (int index, GLuint x)
 
void SetUniform (int index, GLuint x, GLuint y)
 
void SetUniform (int index, GLuint x, GLuint y, GLuint z)
 
void SetUniform (int index, GLuint x, GLuint y, GLuint z, GLuint w)
 
void SetUniform1 (int index, int count, const GLuint *data)
 
void SetUniform2 (int index, int count, const GLuint *data)
 
void SetUniform3 (int index, int count, const GLuint *data)
 
void SetUniform4 (int index, int count, const GLuint *data)
 
void SetUniform (int index, double x)
 
void SetUniform (int index, double x, double y)
 
void SetUniform (int index, double x, double y, double z)
 
void SetUniform (int index, double x, double y, double z, double w)
 
void SetUniform1 (int index, int count, const double *data)
 
void SetUniform2 (int index, int count, const double *data)
 
void SetUniform3 (int index, int count, const double *data)
 
void SetUniform4 (int index, int count, const double *data)
 
void SetUniformMatrix2 (int index, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix3 (int index, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix4 (int index, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix2x3 (int index, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix2x4 (int index, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix3x2 (int index, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix3x4 (int index, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix4x2 (int index, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix4x3 (int index, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix2 (int index, const double *m, int count=1, bool transpose=false)
 
void SetUniformMatrix3 (int index, const double *m, int count=1, bool transpose=false)
 
void SetUniformMatrix4 (int index, const double *m, int count=1, bool transpose=false)
 
void SetUniformMatrix2x3 (int index, const double *m, int count=1, bool transpose=false)
 
void SetUniformMatrix2x4 (int index, const double *m, int count=1, bool transpose=false)
 
void SetUniformMatrix3x2 (int index, const double *m, int count=1, bool transpose=false)
 
void SetUniformMatrix3x4 (int index, const double *m, int count=1, bool transpose=false)
 
void SetUniformMatrix4x2 (int index, const double *m, int count=1, bool transpose=false)
 
void SetUniformMatrix4x3 (int index, const double *m, int count=1, bool transpose=false)
 
void SetUniform (const char *name, float x)
 
void SetUniform (const char *name, float x, float y)
 
void SetUniform (const char *name, float x, float y, float z)
 
void SetUniform (const char *name, float x, float y, float z, float w)
 
void SetUniform1 (const char *name, int count, const float *data)
 
void SetUniform2 (const char *name, int count, const float *data)
 
void SetUniform3 (const char *name, int count, const float *data)
 
void SetUniform4 (const char *name, int count, const float *data)
 
void SetUniform (const char *name, int x)
 
void SetUniform (const char *name, int x, int y)
 
void SetUniform (const char *name, int x, int y, int z)
 
void SetUniform (const char *name, int x, int y, int z, int w)
 
void SetUniform1 (const char *name, int count, const int *data)
 
void SetUniform2 (const char *name, int count, const int *data)
 
void SetUniform3 (const char *name, int count, const int *data)
 
void SetUniform4 (const char *name, int count, const int *data)
 
void SetUniform (const char *name, GLuint x)
 
void SetUniform (const char *name, GLuint x, GLuint y)
 
void SetUniform (const char *name, GLuint x, GLuint y, GLuint z)
 
void SetUniform (const char *name, GLuint x, GLuint y, GLuint z, GLuint w)
 
void SetUniform1 (const char *name, int count, const GLuint *data)
 
void SetUniform2 (const char *name, int count, const GLuint *data)
 
void SetUniform3 (const char *name, int count, const GLuint *data)
 
void SetUniform4 (const char *name, int count, const GLuint *data)
 
void SetUniform (const char *name, double x)
 
void SetUniform (const char *name, double x, double y)
 
void SetUniform (const char *name, double x, double y, double z)
 
void SetUniform (const char *name, double x, double y, double z, double w)
 
void SetUniform1 (const char *name, int count, const double *data)
 
void SetUniform2 (const char *name, int count, const double *data)
 
void SetUniform3 (const char *name, int count, const double *data)
 
void SetUniform4 (const char *name, int count, const double *data)
 
void SetUniformMatrix2 (const char *name, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix3 (const char *name, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix4 (const char *name, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix2x3 (const char *name, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix2x4 (const char *name, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix3x2 (const char *name, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix3x4 (const char *name, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix4x2 (const char *name, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix4x3 (const char *name, const float *m, int count=1, bool transpose=false)
 
void SetUniformMatrix2 (const char *name, const double *m, int count=1, bool transpose=false)
 
void SetUniformMatrix3 (const char *name, const double *m, int count=1, bool transpose=false)
 
void SetUniformMatrix4 (const char *name, const double *m, int count=1, bool transpose=false)
 
void SetUniformMatrix2x3 (const char *name, const double *m, int count=1, bool transpose=false)
 
void SetUniformMatrix2x4 (const char *name, const double *m, int count=1, bool transpose=false)
 
void SetUniformMatrix3x2 (const char *name, const double *m, int count=1, bool transpose=false)
 
void SetUniformMatrix3x4 (const char *name, const double *m, int count=1, bool transpose=false)
 
void SetUniformMatrix4x2 (const char *name, const double *m, int count=1, bool transpose=false)
 
void SetUniformMatrix4x3 (const char *name, const double *m, int count=1, bool transpose=false)
 

Constructor & Destructor Documentation

§ GLSLProgram()

Constructor.

§ ~GLSLProgram()

virtual ~GLSLProgram ( )
virtual

Destructor that deletes the program.

Member Function Documentation

§ Delete()

void Delete ( )

Deletes the program.

§ GetID()

GLuint GetID ( ) const

Returns the program ID.

§ IsNull()

bool IsNull ( ) const

Returns true if the OpenGL program object is not generated, i.e. the program id is invalid.

§ Bind()

void Bind ( ) const

Binds the program for rendering.

§ CreateProgram()

void CreateProgram ( )

Attaches the given shader to the program. This function must be called before calling Link.

§ AttachShader() [1/2]

void AttachShader ( const GLSLShader shader)

Attaches the given shader to the program. This function must be called before calling Link.

§ AttachShader() [2/2]

void AttachShader ( GLuint  shaderID)

Attaches the given shader to the program. This function must be called before calling Link.

§ 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()

bool Build ( const GLSLShader vertexShader,
const GLSLShader fragmentShader,
const GLSLShader geometryShader = nullptr,
const GLSLShader tessControlShader = nullptr,
const GLSLShader 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.

§ BuildFiles() [1/3]

bool BuildFiles ( const char *  vertexShaderFile,
const char *  fragmentShaderFile,
const char *  geometryShaderFile = nullptr,
const char *  tessControlShaderFile = nullptr,
const char *  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.

§ BuildFiles() [2/3]

bool BuildFiles ( const char *  vertexShaderFile,
const char *  fragmentShaderFile,
const char *  geometryShaderFile,
const char *  tessControlShaderFile,
const char *  tessEvaluationShaderFile,
const char *  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.

§ BuildFiles() [3/3]

bool BuildFiles ( const char *  vertexShaderFile,
const char *  fragmentShaderFile,
const char *  geometryShaderFile,
const char *  tessControlShaderFile,
const char *  tessEvaluationShaderFile,
int  prependSourceCount,
const char **  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.

§ BuildSources() [1/3]

bool BuildSources ( const char *  vertexShaderSourceCode,
const char *  fragmentShaderSourceCode,
const char *  geometryShaderSourceCode = nullptr,
const char *  tessControlShaderSourceCode = nullptr,
const char *  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.

§ BuildSources() [2/3]

bool BuildSources ( const char *  vertexShaderSourceCode,
const char *  fragmentShaderSourceCode,
const char *  geometryShaderSourceCode,
const char *  tessControlShaderSourceCode,
const char *  tessEvaluationShaderSourceCode,
const char *  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.

§ BuildSources() [3/3]

bool BuildSources ( const char *  vertexShaderSourceCode,
const char *  fragmentShaderSourceCode,
const char *  geometryShaderSourceCode,
const char *  tessControlShaderSourceCode,
const char *  tessEvaluationShaderSourceCode,
int  prependSourceCount,
const char **  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.

§ RegisterUniform()

void RegisterUniform ( unsigned int  index,
const char *  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.

§ RegisterUniforms()

void RegisterUniforms ( const char *  names,
unsigned int  startingIndex = 0,
std::ostream *  outStream = &std::cout 
)

Registers multiple parameters. The names should be separated by a space character.

§ SetUniform() [1/32]

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.

§ SetUniform() [2/32]

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.

§ SetUniform() [3/32]

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.

§ SetUniform() [4/32]

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.

§ SetUniform1() [1/8]

void SetUniform1 ( int  index,
int  count,
const float *  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.

§ SetUniform2() [1/8]

void SetUniform2 ( int  index,
int  count,
const float *  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.

§ SetUniform3() [1/8]

void SetUniform3 ( int  index,
int  count,
const float *  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.

§ SetUniform4() [1/8]

void SetUniform4 ( int  index,
int  count,
const float *  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.

§ SetUniform() [5/32]

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.

§ SetUniform() [6/32]

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.

§ SetUniform() [7/32]

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.

§ SetUniform() [8/32]

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.

§ SetUniform1() [2/8]

void SetUniform1 ( int  index,
int  count,
const int *  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.

§ SetUniform2() [2/8]

void SetUniform2 ( int  index,
int  count,
const int *  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.

§ SetUniform3() [2/8]

void SetUniform3 ( int  index,
int  count,
const int *  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.

§ SetUniform4() [2/8]

void SetUniform4 ( int  index,
int  count,
const int *  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.

§ SetUniform() [9/32]

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.

§ SetUniform() [10/32]

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.

§ SetUniform() [11/32]

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.

§ SetUniform() [12/32]

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.

§ SetUniform1() [3/8]

void SetUniform1 ( int  index,
int  count,
const GLuint *  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.

§ SetUniform2() [3/8]

void SetUniform2 ( int  index,
int  count,
const GLuint *  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.

§ SetUniform3() [3/8]

void SetUniform3 ( int  index,
int  count,
const GLuint *  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.

§ SetUniform4() [3/8]

void SetUniform4 ( int  index,
int  count,
const GLuint *  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.

§ SetUniform() [13/32]

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.

§ SetUniform() [14/32]

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.

§ SetUniform() [15/32]

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.

§ SetUniform() [16/32]

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.

§ SetUniform1() [4/8]

void SetUniform1 ( int  index,
int  count,
const double *  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.

§ SetUniform2() [4/8]

void SetUniform2 ( int  index,
int  count,
const double *  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.

§ SetUniform3() [4/8]

void SetUniform3 ( int  index,
int  count,
const double *  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.

§ SetUniform4() [4/8]

void SetUniform4 ( int  index,
int  count,
const double *  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.

§ SetUniformMatrix2() [1/4]

void SetUniformMatrix2 ( int  index,
const float *  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.

§ SetUniformMatrix3() [1/4]

void SetUniformMatrix3 ( int  index,
const float *  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.

§ SetUniformMatrix4() [1/4]

void SetUniformMatrix4 ( int  index,
const float *  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.

§ SetUniformMatrix2x3() [1/4]

void SetUniformMatrix2x3 ( int  index,
const float *  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.

§ SetUniformMatrix2x4() [1/4]

void SetUniformMatrix2x4 ( int  index,
const float *  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.

§ SetUniformMatrix3x2() [1/4]

void SetUniformMatrix3x2 ( int  index,
const float *  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.

§ SetUniformMatrix3x4() [1/4]

void SetUniformMatrix3x4 ( int  index,
const float *  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.

§ SetUniformMatrix4x2() [1/4]

void SetUniformMatrix4x2 ( int  index,
const float *  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.

§ SetUniformMatrix4x3() [1/4]

void SetUniformMatrix4x3 ( int  index,
const float *  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.

§ SetUniformMatrix2() [2/4]

void SetUniformMatrix2 ( int  index,
const double *  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.

§ SetUniformMatrix3() [2/4]

void SetUniformMatrix3 ( int  index,
const double *  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.

§ SetUniformMatrix4() [2/4]

void SetUniformMatrix4 ( int  index,
const double *  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.

§ SetUniformMatrix2x3() [2/4]

void SetUniformMatrix2x3 ( int  index,
const double *  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.

§ SetUniformMatrix2x4() [2/4]

void SetUniformMatrix2x4 ( int  index,
const double *  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.

§ SetUniformMatrix3x2() [2/4]

void SetUniformMatrix3x2 ( int  index,
const double *  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.

§ SetUniformMatrix3x4() [2/4]

void SetUniformMatrix3x4 ( int  index,
const double *  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.

§ SetUniformMatrix4x2() [2/4]

void SetUniformMatrix4x2 ( int  index,
const double *  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.

§ SetUniformMatrix4x3() [2/4]

void SetUniformMatrix4x3 ( int  index,
const double *  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.

§ SetUniform() [17/32]

void SetUniform ( const char *  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.

§ SetUniform() [18/32]

void SetUniform ( const char *  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.

§ SetUniform() [19/32]

void SetUniform ( const char *  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.

§ SetUniform() [20/32]

void SetUniform ( const char *  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.

§ SetUniform1() [5/8]

void SetUniform1 ( const char *  name,
int  count,
const float *  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.

§ SetUniform2() [5/8]

void SetUniform2 ( const char *  name,
int  count,
const float *  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.

§ SetUniform3() [5/8]

void SetUniform3 ( const char *  name,
int  count,
const float *  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.

§ SetUniform4() [5/8]

void SetUniform4 ( const char *  name,
int  count,
const float *  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.

§ SetUniform() [21/32]

void SetUniform ( const char *  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.

§ SetUniform() [22/32]

void SetUniform ( const char *  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.

§ SetUniform() [23/32]

void SetUniform ( const char *  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.

§ SetUniform() [24/32]

void SetUniform ( const char *  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.

§ SetUniform1() [6/8]

void SetUniform1 ( const char *  name,
int  count,
const int *  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.

§ SetUniform2() [6/8]

void SetUniform2 ( const char *  name,
int  count,
const int *  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.

§ SetUniform3() [6/8]

void SetUniform3 ( const char *  name,
int  count,
const int *  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.

§ SetUniform4() [6/8]

void SetUniform4 ( const char *  name,
int  count,
const int *  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.

§ SetUniform() [25/32]

void SetUniform ( const char *  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.

§ SetUniform() [26/32]

void SetUniform ( const char *  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.

§ SetUniform() [27/32]

void SetUniform ( const char *  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.

§ SetUniform() [28/32]

void SetUniform ( const char *  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.

§ SetUniform1() [7/8]

void SetUniform1 ( const char *  name,
int  count,
const GLuint *  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.

§ SetUniform2() [7/8]

void SetUniform2 ( const char *  name,
int  count,
const GLuint *  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.

§ SetUniform3() [7/8]

void SetUniform3 ( const char *  name,
int  count,
const GLuint *  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.

§ SetUniform4() [7/8]

void SetUniform4 ( const char *  name,
int  count,
const GLuint *  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.

§ SetUniform() [29/32]

void SetUniform ( const char *  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.

§ SetUniform() [30/32]

void SetUniform ( const char *  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.

§ SetUniform() [31/32]

void SetUniform ( const char *  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.

§ SetUniform() [32/32]

void SetUniform ( const char *  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.

§ SetUniform1() [8/8]

void SetUniform1 ( const char *  name,
int  count,
const double *  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.

§ SetUniform2() [8/8]

void SetUniform2 ( const char *  name,
int  count,
const double *  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.

§ SetUniform3() [8/8]

void SetUniform3 ( const char *  name,
int  count,
const double *  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.

§ SetUniform4() [8/8]

void SetUniform4 ( const char *  name,
int  count,
const double *  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.

§ SetUniformMatrix2() [3/4]

void SetUniformMatrix2 ( const char *  name,
const float *  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.

§ SetUniformMatrix3() [3/4]

void SetUniformMatrix3 ( const char *  name,
const float *  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.

§ SetUniformMatrix4() [3/4]

void SetUniformMatrix4 ( const char *  name,
const float *  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.

§ SetUniformMatrix2x3() [3/4]

void SetUniformMatrix2x3 ( const char *  name,
const float *  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.

§ SetUniformMatrix2x4() [3/4]

void SetUniformMatrix2x4 ( const char *  name,
const float *  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.

§ SetUniformMatrix3x2() [3/4]

void SetUniformMatrix3x2 ( const char *  name,
const float *  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.

§ SetUniformMatrix3x4() [3/4]

void SetUniformMatrix3x4 ( const char *  name,
const float *  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.

§ SetUniformMatrix4x2() [3/4]

void SetUniformMatrix4x2 ( const char *  name,
const float *  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.

§ SetUniformMatrix4x3() [3/4]

void SetUniformMatrix4x3 ( const char *  name,
const float *  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.

§ SetUniformMatrix2() [4/4]

void SetUniformMatrix2 ( const char *  name,
const double *  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.

§ SetUniformMatrix3() [4/4]

void SetUniformMatrix3 ( const char *  name,
const double *  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.

§ SetUniformMatrix4() [4/4]

void SetUniformMatrix4 ( const char *  name,
const double *  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.

§ SetUniformMatrix2x3() [4/4]

void SetUniformMatrix2x3 ( const char *  name,
const double *  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.

§ SetUniformMatrix2x4() [4/4]

void SetUniformMatrix2x4 ( const char *  name,
const double *  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.

§ SetUniformMatrix3x2() [4/4]

void SetUniformMatrix3x2 ( const char *  name,
const double *  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.

§ SetUniformMatrix3x4() [4/4]

void SetUniformMatrix3x4 ( const char *  name,
const double *  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.

§ SetUniformMatrix4x2() [4/4]

void SetUniformMatrix4x2 ( const char *  name,
const double *  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.

§ SetUniformMatrix4x3() [4/4]

void SetUniformMatrix4x3 ( const char *  name,
const double *  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.