void Uniform2uiv(
const GLint Location,
const GLsizei Count,
const GLuint* const Value)
{
glUniform2uiv(Location, Count, Value);
}
inline void VL_glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
{
if (glUniform2uiv)
glUniform2uiv(location, count, value);
else
if (glUniform2uivEXT)
glUniform2uivEXT(location, count, value);
else
VL_UNSUPPORTED_FUNC();
}
void Shader::setUniform<glm::uvec2>(const std::string& name, const glm::uvec2& data) {
int prev_bound_program;
glGetIntegerv(GL_CURRENT_PROGRAM, &prev_bound_program);
if(name_to_location.count(name) == 0) {
throw Exceptions::InvalidUniformNameException(name);
}
if(prev_bound_program != program_object)
useProgram();
glUniform2uiv(name_to_location[name], 1, glm::value_ptr(data));
if(prev_bound_program != program_object)
glUseProgram(prev_bound_program);
}
bool Shader::setShaderUniform(const std::string &name, GLsizei uniSize, GLsizei len, const GLuint *value)
{
GLint loc;
if(!this->getUniformLoc(name, loc))
return false;
switch(uniSize)
{
case 1: glUniform1uiv(loc, len, value); break;
case 2: glUniform2uiv(loc, len, value);break;
case 3: glUniform3uiv(loc, len, value);break;
case 4: glUniform4uiv(loc, len, value);break;
default: return false;
}
return true;
}
void Cube::Draw()
{
glUseProgram(Cube::CubeShaderProgram);
glBindVertexArray(Cube::CubeVAO);
this->transMat = this->camera->GetMatrix();
this->transMat *= glm::translate(glm::vec3(this->posX, this->posY, this->posZ));
this->transMat *= glm::scale(glm::vec3(0.5f, 0.5f, 0.5f));
this->transMat *= glm::rotate(glm::radians(this->rotation), glm::vec3(1.0f, 1.0f, 1.0f));
glUniformMatrix4fv(Cube::transMatUniform, 1, GL_FALSE, (GLfloat*)&transMat);
glUniform2uiv(Cube::windowDimUniform, 1, (GLuint*)&(this->camera->GetWindowDimensions()));
glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
glUseProgram(0);
}
void Shader::BindUInt(const std::string &name, int size, int count, const unsigned int *value)
{
int id = GetUniformLocation(name);
if (id == -1) return;
switch (size)
{
case 1:
glUniform1uiv(id, count, value);
break;
case 2:
glUniform2uiv(id, count, value);
break;
case 3:
glUniform3uiv(id, count, value);
break;
case 4:
glUniform4uiv(id, count, value);
break;
default:
FURYW << "Incorrect unfirom size!";
break;
}
}
void shader_gl3::uniform(const char* name, const uint2* arg1, const size_t& count) const {
A2E_CHECK_UNIFORM_EXISTENCE(name);
A2E_CHECK_UNIFORM_TYPE(name, GL_UNSIGNED_INT_VEC2);
glUniform2uiv(A2E_SHADER_GET_UNIFORM_POSITION(name), (GLsizei)count, (GLuint*)arg1);
}
/*
* Sets the given uniform variable to the given value.
*/
void sstSetUniformData( sstProgram *program, char *name, GLvoid *data ) {
uniform *un;
int i;
/* Find our data */
for( i = 0; i < program->un_count; i++ ) {
un = &program->uniforms[i];
if( strcmp(un->name, name) == 0 ) {
break;
}
}
/* Lookup failure */
if( i >= program->un_count ) {
printf("WARN: Uniform variable [%s] does not exist!\n", name);
return;
}
switch( un->first ) {
case 1:
switch( un->type ) {
case GL_FLOAT:
glUniform1fv(un->location, un->count, (const GLfloat*)data);
return;
case GL_INT:
glUniform1iv(un->location, un->count, (const GLint*)data);
return;
case GL_UNSIGNED_INT:
glUniform1uiv(un->location, un->count, (const GLuint*)data);
return;
default:
printf("WARN: Invalid type for uniform value [%s]!\n", name);
return;
}
case 2:
switch( un->second ) {
case 0:
case 1:
switch( un->type ) {
case GL_FLOAT:
glUniform2fv(un->location, un->count, (const GLfloat*)data);
return;
case GL_INT:
glUniform2iv(un->location, un->count, (const GLint*)data);
return;
case GL_UNSIGNED_INT:
glUniform2uiv(un->location, un->count, (const GLuint*)data);
return;
default:
printf("WARN: Invalid type for uniform value [%s]!\n", name);
return;
}
case 2:
glUniformMatrix2fv(un->location, un->count, un->transpose,
(const GLfloat*)data);
return;
case 3:
glUniformMatrix2x3fv(un->location, un->count, un->transpose,
(const GLfloat*)data);
return;
case 4:
glUniformMatrix2x4fv(un->location, un->count, un->transpose,
(const GLfloat*)data);
return;
default:
printf("WARN: Invalid second matrix component: %d!\n", un->second);
return;
}
case 3:
switch( un->second ) {
case 0:
case 1:
switch( un->type ) {
case GL_FLOAT:
glUniform3fv(un->location, un->count, (const GLfloat*)data);
return;
case GL_INT:
glUniform3iv(un->location, un->count, (const GLint*)data);
return;
case GL_UNSIGNED_INT:
glUniform3uiv(un->location, un->count, (const GLuint*)data);
return;
default:
printf("WARN: Invalid type for uniform value [%s]!\n", name);
return;
}
case 2:
glUniformMatrix3x2fv(un->location, un->count, un->transpose,
(const GLfloat*)data);
return;
case 3:
glUniformMatrix3fv(un->location, un->count, un->transpose,
(const GLfloat*)data);
return;
case 4:
glUniformMatrix3x4fv(un->location, un->count, un->transpose,
(const GLfloat*)data);
return;
default:
printf("WARN: Invalid second matrix component: %d!\n", un->second);
return;
}
case 4:
switch( un->second ) {
case 0:
case 1:
switch( un->type ) {
case GL_FLOAT:
glUniform4fv(un->location, un->count, (const GLfloat*)data);
return;
case GL_INT:
glUniform4iv(un->location, un->count, (const GLint*)data);
return;
case GL_UNSIGNED_INT:
glUniform4uiv(un->location, un->count, (const GLuint*)data);
return;
default:
printf("WARN: Invalid type for uniform value [%s]!\n", name);
return;
}
case 2:
glUniformMatrix4x2fv(un->location, un->count, un->transpose,
(const GLfloat*)data);
return;
case 3:
glUniformMatrix4x3fv(un->location, un->count, un->transpose,
(const GLfloat*)data);
return;
case 4:
glUniformMatrix4fv(un->location, un->count, un->transpose,
(const GLfloat*)data);
return;
default:
printf("WARN: Invalid second matrix component: %d!\n", un->second);
return;
}
default:
printf("WARN: Invalid first matrix component: %d!\n", un->first);
return;
}
}
void operator()(GLint location, GLsizei count, const GLuint *value_ptr) {
glUniform2uiv(location, count, value_ptr);
}
void operator()(GLint location, const glm::uvec4 &value) {
glUniform2uiv(location, 1, glm::value_ptr(value));
}
bool Shader :: setUniformVec<glm::uvec2>(const char *name, const glm::uvec2 &value)
{ int loc = glGetUniformLocation(program, name);
if(loc < 0) return false;
glUniform2uiv(loc, 1, glm::value_ptr(value));
return true;
}
void Shader::SetUniform(Int32 loc, const glm::uvec2 &xy) {
glUniform2uiv(loc, 1, glm::value_ptr(xy));
}
void UniformImplementation_Legacy::set(const Program * program, const GLint location, const std::vector<glm::uvec2> & value) const
{
program->use();
glUniform2uiv(location, static_cast<GLint>(value.size()), reinterpret_cast<const unsigned*>(value.data()));
}
void Z3DShaderProgram::setUniformValueArray(GLint loc, const glm::uvec2 *values, int count)
{
if (loc != -1) {
glUniform2uiv(loc, count, &(values[0][0]));
}
}
void Z3DShaderProgram::setUniformValue(GLint loc, const glm::uvec2 &value)
{
if (loc != -1) {
glUniform2uiv(loc, 1, &value[0]);
}
}
void shader_set_parameter(shader_t *s, char *nm, void *value, size_t sz)
{
char buf[64];
GLint current_program;
glGetIntegerv(GL_CURRENT_PROGRAM, ¤t_program);
glUseProgram(s->program);
int location = glGetUniformLocation(s->program, nm);
GLuint index; //Why is there a distinction between location/index?
glGetUniformIndices(s->program, 1, (const GLchar * const*)&nm, &index);
if(location < 0 || location == GL_INVALID_INDEX) // ERROR uniform does not exist
{
shader_set_block(s, nm, value, sz); // try with uniform block
goto CLEANUP;
}
GLenum type;
glGetActiveUniform(s->program, index, 0, NULL, NULL, &type, NULL);
//void (*uniform_func)(GLint loc, GLsizei count, const GLuint *val) = 0;
switch(type)
{
case GL_FLOAT_VEC4:
glUniform4fv(location, sz/(sizeof(float) * 4), value);
break;
case GL_FLOAT_VEC3:
glUniform3fv(location, sz/(sizeof(float) * 3), value);
break;
case GL_FLOAT_VEC2:
glUniform2fv(location, sz/(sizeof(float) * 2), value);
break;
case GL_FLOAT:
glUniform1fv(location, sz/sizeof(float), value);
break;
case GL_INT_VEC4:
glUniform4iv(location, (sz/sizeof(int) * 4), value);
break;
case GL_INT_VEC3:
glUniform3iv(location, (sz/sizeof(int) * 3), value);
break;
case GL_INT_VEC2:
glUniform2iv(location, (sz/sizeof(int) * 2), value);
break;
case GL_INT:
case GL_BOOL:
case GL_SAMPLER_2D:
case GL_SAMPLER_3D:
case GL_SAMPLER_CUBE:
glUniform1iv(location, sz/sizeof(int), value);
break;
case GL_UNSIGNED_INT_VEC4:
glUniform4uiv(location, (sz/sizeof(unsigned int) * 4), value);
break;
case GL_UNSIGNED_INT_VEC3:
glUniform3uiv(location, (sz/sizeof(unsigned int) * 3), value);
break;
case GL_UNSIGNED_INT_VEC2:
glUniform2uiv(location, (sz/sizeof(unsigned int) * 2), value);
break;
case GL_UNSIGNED_INT:
glUniform1uiv(location, sz/sizeof(unsigned int), value);
break;
case GL_FLOAT_MAT4:
glUniformMatrix4fv(location, sz/(sizeof(float) * 16), true, value);
break;
case GL_FLOAT_MAT3:
glUniformMatrix3fv(location, sz/(sizeof(float) * 9), true, value);
break;
default:
assert(0 && "invalid parameter type");
}
CLEANUP:
glUseProgram(current_program);
}
bool Shader :: setUniformVec<glm::uvec2>(int loc, const glm::uvec2 &value)
{ if(loc < 0) return false;
glUniform2uiv(loc, 1, glm::value_ptr(value));
return true;
}
void UniformImplementation_Legacy::set(const Program * program, const GLint location, const glm::uvec2 & value) const
{
program->use();
glUniform2uiv(location, 1, glm::value_ptr(value));
}
void GLState::UniformFuncs::glsUniform2uiv(const GLint location,
const GLsizei count, const GLuint* value) {
glUniform2uiv(location, count, value);
ERROR_CHECK;
}
void kore::BindUniform::doExecute(void) const {
if(!_componentUniform) {
Log::getInstance()->write("[ERROR] Uniform binding undefined");
return;
}
GLerror::gl_ErrorCheckStart();
_renderManager->
useShaderProgram(_shaderUniform->shader->getProgramLocation());
switch (_componentUniform->type) {
case GL_FLOAT:
glUniform1fv(_shaderUniform->location, _componentUniform->size,
static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_VEC2:
glUniform2fv(_shaderUniform->location, _componentUniform->size,
static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_VEC3:
glUniform3fv(_shaderUniform->location, _componentUniform->size,
static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_VEC4:
glUniform4fv(_shaderUniform->location, _componentUniform->size,
static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_DOUBLE:
glUniform1d(_shaderUniform->location,
*static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_VEC2:
glUniform2dv(_shaderUniform->location, _componentUniform->size,
static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_VEC3:
glUniform3dv(_shaderUniform->location, _componentUniform->size,
static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_VEC4:
glUniform4dv(_shaderUniform->location, _componentUniform->size,
static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_BOOL:
case GL_INT:
glUniform1i(_shaderUniform->location,
*static_cast<GLint*>(_componentUniform->data));
break;
case GL_BOOL_VEC2:
case GL_INT_VEC2:
glUniform2iv(_shaderUniform->location, _componentUniform->size,
static_cast<GLint*>(_componentUniform->data));
break;
case GL_BOOL_VEC3:
case GL_INT_VEC3:
glUniform3iv(_shaderUniform->location, _componentUniform->size,
static_cast<GLint*>(_componentUniform->data));
break;
case GL_BOOL_VEC4:
case GL_INT_VEC4:
glUniform4iv(_shaderUniform->location, _componentUniform->size,
static_cast<GLint*>(_componentUniform->data));
break;
case GL_UNSIGNED_INT:
glUniform1ui(_shaderUniform->location,
*static_cast<GLuint*>(_componentUniform->data));
break;
case GL_UNSIGNED_INT_VEC2:
glUniform2uiv(_shaderUniform->location, _componentUniform->size,
static_cast<GLuint*>(_componentUniform->data));
break;
case GL_UNSIGNED_INT_VEC3:
glUniform3uiv(_shaderUniform->location, _componentUniform->size,
static_cast<GLuint*>(_componentUniform->data));
break;
case GL_UNSIGNED_INT_VEC4:
glUniform4uiv(_shaderUniform->location, _componentUniform->size,
static_cast<GLuint*>(_componentUniform->data));
break;
case GL_FLOAT_MAT2:
glUniformMatrix2fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT3:
glUniformMatrix3fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT4:
glUniformMatrix4fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT2x3:
glUniformMatrix2x3fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT2x4:
glUniformMatrix2x4fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE,
static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT3x2:
glUniformMatrix3x2fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE,
static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT3x4:
glUniformMatrix3x4fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT4x2:
glUniformMatrix4x2fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_FLOAT_MAT4x3:
glUniformMatrix3x4fv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLfloat*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT2:
glUniformMatrix2dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT3:
glUniformMatrix3dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT4:
glUniformMatrix4dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT2x3:
glUniformMatrix2x3dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT2x4:
glUniformMatrix2x4dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT3x2:
glUniformMatrix3x2dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT3x4:
glUniformMatrix3x4dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT4x2:
glUniformMatrix4x2dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
case GL_DOUBLE_MAT4x3:
glUniformMatrix4x3dv(_shaderUniform->location, _componentUniform->size,
GL_FALSE, static_cast<GLdouble*>(_componentUniform->data));
break;
// Note(dlazarek): Currently, we handle texture-bindings outside of
// Uniform-bindigs for sorting and performance-reasons.
case GL_SAMPLER_1D:
case GL_SAMPLER_2D:
case GL_SAMPLER_3D:
case GL_SAMPLER_CUBE:
case GL_SAMPLER_1D_SHADOW:
case GL_SAMPLER_2D_SHADOW:
case GL_SAMPLER_CUBE_SHADOW:
case GL_SAMPLER_1D_ARRAY:
case GL_SAMPLER_2D_ARRAY:
case GL_SAMPLER_1D_ARRAY_SHADOW:
case GL_SAMPLER_2D_ARRAY_SHADOW:
case GL_SAMPLER_2D_MULTISAMPLE:
case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
case GL_SAMPLER_BUFFER:
case GL_SAMPLER_2D_RECT:
case GL_SAMPLER_2D_RECT_SHADOW:
case GL_INT_SAMPLER_1D:
case GL_INT_SAMPLER_2D:
case GL_INT_SAMPLER_3D:
case GL_INT_SAMPLER_CUBE:
case GL_INT_SAMPLER_1D_ARRAY:
case GL_INT_SAMPLER_2D_ARRAY:
case GL_INT_SAMPLER_2D_MULTISAMPLE:
case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
case GL_INT_SAMPLER_BUFFER:
case GL_INT_SAMPLER_2D_RECT:
case GL_UNSIGNED_INT_SAMPLER_1D:
case GL_UNSIGNED_INT_SAMPLER_2D:
case GL_UNSIGNED_INT_SAMPLER_3D:
case GL_UNSIGNED_INT_SAMPLER_CUBE:
case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
case GL_UNSIGNED_INT_SAMPLER_BUFFER:
case GL_UNSIGNED_INT_SAMPLER_2D_RECT:
//glActiveTexture(GL_TEXTURE0 + _componentUniform->texUnit);
//glProgramUniform1i(_shaderID, _shaderUniform->location, _componentUniform->texUnit);
kore::Log::getInstance()->write("[ERROR] sampler type was adressed"
"as uniform");
break;
/*
break;
case GL_IMAGE_1D:
break;
case GL_IMAGE_2D:
break;
case GL_IMAGE_3D:
break;
case GL_IMAGE_2D_RECT:
break;
case GL_IMAGE_CUBE:
break;
case GL_IMAGE_BUFFER:
break;
case GL_IMAGE_1D_ARRAY:
break;
case GL_IMAGE_2D_ARRAY:
break;
case GL_IMAGE_2D_MULTISAMPLE:
break;
case GL_IMAGE_2D_MULTISAMPLE_ARRAY:
break;
case GL_INT_IMAGE_1D:
break;
case GL_INT_IMAGE_2D:
break;
case GL_INT_IMAGE_3D:
break;
case GL_INT_IMAGE_2D_RECT:
break;
case GL_INT_IMAGE_CUBE:
break;
case GL_INT_IMAGE_BUFFER:
break;
case GL_INT_IMAGE_1D_ARRAY:
break;
case GL_INT_IMAGE_2D_ARRAY:
break;
case GL_INT_IMAGE_2D_MULTISAMPLE:
break;
case GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY:
break;
case GL_UNSIGNED_INT_IMAGE_1D:
break;
case GL_UNSIGNED_INT_IMAGE_2D:
break;
case GL_UNSIGNED_INT_IMAGE_3D:
break;
case GL_UNSIGNED_INT_IMAGE_2D_RECT:
break;
case GL_UNSIGNED_INT_IMAGE_CUBE:
break;
case GL_UNSIGNED_INT_IMAGE_BUFFER:
break;
case GL_UNSIGNED_INT_IMAGE_1D_ARRAY:
break;
case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:
break;
case GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE:
break;
case GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY:
break; */
default:
kore::Log::getInstance()->write("[ERROR] Unknown uniform binding\n");
break;
}
GLerror::gl_ErrorCheckFinish("BindUniformOperation: " +
_shaderUniform->name);
}
void Shader::SetUniform(Int32 loc, const glm::uvec2 *xy, UInt32 size) {
glUniform2uiv(loc, size, (GLuint*)xy);
}
