void ShaderProgram::BindInts(const std::string& name, int i0, int i1) {
glGetError();
GLint location = glGetUniformLocation(m_program_id, name.c_str());
CHECK_ERROR("ShaderProgram::BindInts", "glGetUniformLocation()");
assert(location != -1 &&
"BindInts() : The named uniform variable does not exist.");
glUniform2i(location, i0, i1);
CHECK_ERROR("ShaderProgram::BindInts", "glUniform2i()");
}
GLSLAttrib& GLSLAttrib::operator=(const glm::bvec2 value) {
if (id >= 0) {
glUniform2i(id, value.x?1:0, value.y?1:0 );
LOG_GL_ERRORS();
} else {
LOG_WARN << "skip setting invalid parameter: " << name << std::endl;
}
return *this;
}
bool Shader::setShaderUniform(const std::string &name, GLint v0, GLint v1)
{
GLint loc;
if(!this->getUniformLoc(name, loc))
return false;
glUniform2i(loc, v0, v1);
return true;
}
//----------------------------------------------------------------------------------------------------------------------
void ShaderProgram::setRegisteredUniform2i( const std::string &_varname, int _v0, int _v1 ) const
{
std::map <std::string, GLuint >::const_iterator uniform=m_registeredUniforms.find(_varname);
// make sure we have a valid shader
if(uniform!=m_registeredUniforms.end())
{
glUniform2i(uniform->second,_v0,_v1);
}
}
void CL_OpenGLProgramObjectProvider::set_uniform2i(const CL_StringRef &name, int p1, int p2)
{
throw_if_disposed();
CL_ProgramObjectStateTracker state_tracker(handle);
int loc = get_uniform_location(name);
if (loc == -1)
return;
glUniform2i(loc, p1, p2);
}
void GLProgram::setUniformLocationWith2i(GLint location, GLint i1, GLint i2)
{
GLint ints[2] = {i1,i2};
bool updated = updateUniformLocation(location, ints, sizeof(ints));
if (updated)
{
glUniform2i( (GLint)location, i1, i2);
}
}
//------------------------------------------------------------------------------
void GL::Program::SetIVec2(const char* name, const GLint* ivec)
{
ERROR_ASSERT(compiled_)
this->Bind();
GLint loc = glGetUniformLocation(program_, name);
ERROR_ASSERT(loc != -1)
glUniform2i(loc, ivec[0], ivec[1]);
}
void
GLSLProgram::setUniform2i(const char *name, int x, int y)
{
GLint loc = glGetUniformLocation(mProg, name);
if (loc >= 0) {
glUniform2i(loc, x, y);
} else {
#if _DEBUG
LOGE("Error setting parameter '%s'\n", name);
#endif
}
}
void shader_set_uniform_2i(GLint unif, int f0, int f1) {
int errorCode;
if (unif != -1) {
glUniform2i(unif, f0, f1);
errorCode = glGetError();
if (errorCode != GL_NO_ERROR) {
fprintf (stderr, "[E] shader_set_uniform_2i: %s\n", gluErrorString(errorCode));
exit(1);
}
}
}
/** * Sets an uniform vector parameter. * \warning uses glGetError(); * \param name - name of the parameter * \param x,y,z,w - up to four bool components of the vector to set. * \return void * \author <a href="mailto:[email protected]">Jens Schneider</a> * \date Mar.2005 */ void GLSLProgram::SetUniformVector(const char *name,bool x, bool y, bool z, bool w) const { assert(m_bEnabled); CheckGLError(); GLenum iType; GLint iLocation; try { iLocation = get_uniform_vector(name, m_hProgram, &iType); } catch(tuvok::GLError gl) { T_ERROR("Error (%d) obtaining uniform %s in '%s' or '%s'.", gl.errno(), name, m_sVS.c_str(), m_sFS.c_str()); return; } switch (iType) { case GL_BOOL: glUniform1i(iLocation,(x ? 1 : 0)); break; case GL_BOOL_VEC2: glUniform2i(iLocation,(x ? 1 : 0),(y ? 1 : 0)); break; case GL_BOOL_VEC3: glUniform3i(iLocation,(x ? 1 : 0),(y ? 1 : 0),(z ? 1 : 0)); break; case GL_BOOL_VEC4: glUniform4i(iLocation,(x ? 1 : 0),(y ? 1 : 0),(z ? 1 : 0),(w ? 1 : 0)); break; #ifdef GLSL_ALLOW_IMPLICIT_CASTS case GL_FLOAT: glUniform1f(iLocation,(x ? 1.0f : 0.0f)); break; case GL_FLOAT_VEC2: glUniform2f(iLocation,(x ? 1.0f : 0.0f),(y ? 1.0f : 0.0f)); break; case GL_FLOAT_VEC3: glUniform3f(iLocation,(x ? 1.0f : 0.0f),(y ? 1.0f : 0.0f),(z ? 1.0f : 0.0f)); break; case GL_FLOAT_VEC4: glUniform4f(iLocation,(x ? 1.0f : 0.0f),(y ? 1.0f : 0.0f),(z ? 1.0f : 0.0f),(w ? 1.0f : 0.0f)); break; case GL_INT: glUniform1i(iLocation,(x ? 1 : 0)); break; case GL_INT_VEC2: glUniform2i(iLocation,(x ? 1 : 0),(y ? 1 : 0)); break; case GL_INT_VEC3: glUniform3i(iLocation,(x ? 1 : 0),(y ? 1 : 0),(z ? 1 : 0)); break; case GL_INT_VEC4: glUniform4i(iLocation,(x ? 1 : 0),(y ? 1 : 0),(z ? 1 : 0),(w ? 1 : 0)); break; #endif default: T_ERROR("Unknown type (%d) for %s.", iType, name); break; } #ifdef GLSL_DEBUG CheckGLError("SetUniformVector(%s,bool,...)",name); #endif }
void Display::updateCamera()
{
vec3 cpos = camera->getPos();
mat4 cmat = camera->getMat4();
glUseProgram(shaderProgram);
glUniformMatrix4fv(u_projMatrixLocation, 1, GL_FALSE, &cmat[0][0]);
glUniform3f(u_camPositionLocation, cpos.x, cpos.y, cpos.z );
glUseProgram(raymarchShaderProgram);
glUniform2i(u_resolutionLocation, camera->getWidth(), camera->getHeight() );
glUniform3f(u_rayCamPositionLocation, cpos.x, cpos.y, cpos.z );
}
void
program::set_uniform2i(char const* varname, GLint v0, GLint v1) const
{
GLint location = get_uniform_location(varname);
if (location >= 0)
{
#if GPUCAST_GL_DIRECT_STATE_ACCESS
glProgramUniform2i(id_, location, v0, v1);
#else
glUniform2i(location, v0, v1);
#endif
}
}
/** * Sets an uniform vector parameter. * \warning uses glGetError(); * \param name - name of the parameter * \param x,y,z,w - up to four float components of the vector to set. * \return void * \author <a href="mailto:[email protected]">Jens Schneider</a> * \date Aug.2004 */ void GLSLProgram::SetUniformVector(const char *name, float x, float y, float z, float w) const { assert(m_bEnabled); CheckGLError(); GLenum iType; GLint iLocation; try { iLocation = get_uniform_vector(name, m_hProgram, &iType); } catch(tuvok::GLError gl) { T_ERROR("Error (%d) obtaining uniform %s in '%s' or '%s'.", gl.errno(), name, m_sVS.c_str(), m_sFS.c_str()); return; } switch (iType) { case GL_FLOAT: glUniform1f(iLocation,x); break; case GL_FLOAT_VEC2: glUniform2f(iLocation,x,y); break; case GL_FLOAT_VEC3: glUniform3f(iLocation,x,y,z); break; case GL_FLOAT_VEC4: glUniform4f(iLocation,x,y,z,w); break; #ifdef GLSL_ALLOW_IMPLICIT_CASTS case GL_INT: 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_2D_RECT_ARB: case GL_SAMPLER_2D_RECT_SHADOW_ARB: glUniform1i(iLocation,int(x)); break; case GL_INT_VEC2: glUniform2i(iLocation,int(x),int(y)); break; case GL_INT_VEC3: glUniform3i(iLocation,int(x),int(y),int(z)); break; case GL_INT_VEC4: glUniform4i(iLocation,int(x),int(y),int(z),int(w)); break; case GL_BOOL: glUniform1f(iLocation,x); break; case GL_BOOL_VEC2: glUniform2f(iLocation,x,y); break; case GL_BOOL_VEC3: glUniform3f(iLocation,x,y,z); break; case GL_BOOL_VEC4: glUniform4f(iLocation,x,y,z,w); break; #endif default: T_ERROR("Unknown type (%d) for %s.", iType, name); break; } #ifdef GLSL_DEBUG CheckGLError("SetUniformVector(%s,float,...)",name); #endif }
void ApplyShader( struct Shader * shader, struct UniformMatch * m )
{
glUseProgramObjectARB( shader->program );
CurrentShader = shader;
while( m )
{
int place = glGetUniformLocationARB( shader->program, m->name );
if( m->intcount == 1 )
{
glUniform1i( place, m->data[0] );
}
else if( m->intcount == 2 )
{
glUniform2i( place, m->data[0], m->data[1] );
}
else if( m->intcount == 3 )
{
glUniform3i( place, m->data[0], m->data[1], m->data[2] );
}
else if( m->intcount == 4 )
{
glUniform4i( place, m->data[0], m->data[1], m->data[2], m->data[3] );
}
else if( m->floatcount == 1 )
{
glUniform1f( place, m->data[0] );
}
else if( m->floatcount == 2 )
{
glUniform2f( place, m->data[0], m->data[1] );
}
else if( m->floatcount == 3 )
{
glUniform3f( place, m->data[0], m->data[1], m->data[2] );
}
else if( m->floatcount == 4 )
{
glUniform4f( place, m->data[0], m->data[1], m->data[2], m->data[3] );
}
m = m->next;
}
//Need to bind things...
}
void Shader::setUniform(int location, int type, const GLint* val) const
{
switch(type)
{
case GL_INT:
glUniform1i(location,val[0]);
break;
case GL_INT_VEC2:
glUniform2i(location,val[0],val[1]);
break;
case GL_INT_VEC3:
glUniform3i(location,val[0],val[1],val[2]);
break;
case GL_INT_VEC4:
glUniform4i(location,val[0],val[1],val[2],val[3]);
break;
}
}
enum piglit_result
piglit_display(void)
{
int l, q;
bool pass = true;
float red[4] = {1.0, 0.0, 0.0, 1.0};
float green[4] = {0.0, 1.0, 0.0, 1.0};
float blue[4] = {0.0, 0.0, 1.0, 1.0};
float white[4] = {1.0, 1.0, 1.0, 1.0};
glClearColor(0.5, 0.5, 0.5, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
for (l = 0; (tex_size >> l) > 0; l++) {
const int width = tex_size >> l;
const int height = max(width / 2, 1);
const int y = 10 + 20 * l;
glUniform1i(lod_location, l);
/* Draw 4 squares with a color sample for each quad */
for (q = 0; q < 4; q++) {
const int tex_x = (q / 2) * ((width / 2));
const int tex_y = (q % 2) * ((height / 2));
float *c;
const int x = 10+20*q;
if (q == 0) c = red;
else if (q == 1) c = blue;
else if (q == 2) c = green;
else if (q == 3) c = white;
glUniform2i(pos_location, tex_x, tex_y);
piglit_draw_rect(x, y, 10, 10);
if (width > 2) /* below 1 wide no test */
pass &= piglit_probe_rect_rgba(x, y, 10, 10, c);
}
}
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
void Image::renderRandom (RendererRandom *renderer, VertexBuffer *buf, GLenum mode)
{
glEnable( GL_MULTISAMPLE );
glEnable( GL_SAMPLE_SHADING );
glMinSampleShading( 1.0f );
//glEnable( GL_BLEND );
//glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
Shader *shader = renderer->shader;
shader->use();
Int32 uModelview = shader->program->getUniform( "modelview" );
glUniformMatrix4fv( uModelview, 1, false, (GLfloat*) matModelView.top().m );
Int32 uProjection = shader->program->getUniform( "projection" );
glUniformMatrix4fv( uProjection, 1, false, (GLfloat*) matProjection.top().m );
Int32 uMatTexture = shader->program->getUniform( "matTexture" );
glUniformMatrix4fv( uMatTexture, 1, false, (GLfloat*) matTexture.top().m );
Int32 uPtrGrid = shader->program->getUniform( "ptrGrid" );
glUniformui64( uPtrGrid, bufGpuGrid.getAddress() );
Int32 uPtrStream = shader->program->getUniform( "ptrStream" );
glUniformui64( uPtrStream, bufGpuStream.getAddress() );
Int32 uPtrObjects = shader->program->getUniform( "ptrObjects" );
glUniformui64( uPtrObjects, bufObjInfos.getAddress() );
Int32 uCellSize = shader->program->getUniform( "cellSize" );
glUniform2f( uCellSize, cellSize.x, cellSize.y );
Int32 uGridSize = shader->program->getUniform( "gridSize" );
glUniform2i( uGridSize, gridSize.x, gridSize.y );
Int32 uGridOrigin = shader->program->getUniform( "gridOrigin" );
glUniform2f( uGridOrigin, min.x, min.y );
buf->render( shader, mode );
//glDisable( GL_BLEND );
}
void Uniform::send_value(GLuint program_id) {
switch(type) {
case UNIFORM_BOOL:
if(bval) {
glUniform1i(uniform_locations[program_id],1);
} else {
glUniform1i(uniform_locations[program_id],0);
}
break;
case UNIFORM_INT:
glUniform1i(uniform_locations[program_id],ival);
break;
case UNIFORM_FLOAT:
glUniform1f(uniform_locations[program_id],fval);
break;
case UNIFORM_FLOAT3:
glUniform3f(uniform_locations[program_id],f3val.x,f3val.y,f3val.z);
break;
case UNIFORM_FLOAT2:
glUniform2f(uniform_locations[program_id],f2val.x,f2val.y);
break;
case UNIFORM_INT3:
glUniform3i(uniform_locations[program_id],i3val.x,i3val.y,i3val.z);
break;
case UNIFORM_INT2:
glUniform2i(uniform_locations[program_id],i2val.x,i2val.y);
break;
case UNIFORM_MAT4:
glUniformMatrix4fv(uniform_locations[program_id],1,GL_TRUE,mval.adress());
break;
case UNIFORM_SAMPLER:
break;
}
}
void scene_buildings::gpu_draw(base::frame_context * const ctx){
base::hptimer timer;
timer.start();
if (base::cfg().no_cull){
glDisable(GL_CULL_FACE);
}
glUseProgram(_prg);
// this is only needed on AMD cards due to driver bug wich needs
// to have attr0 array anabled
//base::set_attr0_vbo_amd_wa();
glQueryCounter(ctx->_time_queries[0], GL_TIMESTAMP);
glUniformMatrix4fv(_prg_mvp, 1, GL_FALSE, glm::value_ptr(ctx->_mvp));
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indices_vbo);
glUniform1i(_prg_tb_blocks, 0);
glActiveTexture(GL_TEXTURE0);
// bind scene texture buffers
for (uint32 i = 0; i < _tiles.size(); i++){
int x = _tiles[i]._tile_pos.x;
int y = _tiles[i]._tile_pos.y;
glUniform2i(_prg_tile_offset, x,y);
glUniform1ui(_prg_total_count, _tiles[i]._blocks_count);
glBindTexture(GL_TEXTURE_BUFFER, _tiles[i]._blocks_tb);
glDrawElementsInstanced(GL_TRIANGLES,
10 * 3 * base::cfg().blocks_per_idc,
GL_UNSIGNED_INT,
0,
(_tiles[i]._blocks_count + base::cfg().blocks_per_idc - 1) / base::cfg().blocks_per_idc);
}
ctx->_cpu_render_time = timer.elapsed_time();
glQueryCounter(ctx->_time_queries[1], GL_TIMESTAMP);
}
void CGLSLProgram::loadUniformi(const string name, const GLint size, const GLint *pointer){
switch (size){
case nGLSLProgram::GLSLUniform::UNIFORM_SIZE_1D:
glUniform1i(getUniform(name), pointer[0]);
break;
case nGLSLProgram::GLSLUniform::UNIFORM_SIZE_2D:
glUniform2i(getUniform(name), pointer[0], pointer[1]);
break;
case nGLSLProgram::GLSLUniform::UNIFORM_SIZE_3D:
glUniform3i(getUniform(name), pointer[0], pointer[1], pointer[2]);
break;
case nGLSLProgram::GLSLUniform::UNIFORM_SIZE_4D:
glUniform4i(getUniform(name), pointer[0], pointer[1], pointer[2], pointer[3]);
break;
}
}
void Shader::SetUniformXi(string name, GLint len, GLint arr[])
{
glUseProgram(_prog);
switch (len) {
case 1:
glUniform1i(GetUniformLocation(name), arr[0]);
break;
case 2:
glUniform2i(GetUniformLocation(name), arr[0], arr[1]);
break;
case 3:
glUniform3i(GetUniformLocation(name), arr[0], arr[1], arr[2]);
break;
case 4:
glUniform4i(GetUniformLocation(name), arr[0], arr[1], arr[2], arr[3]);
break;
}
glUseProgram(0);
}
void OpenGL::setProgramIntUniformData(GLuint position, const std::vector<int32_t> &data)
{
switch (data.size())
{
case 1:
glUniform1i(position, data[0]);
break;
case 2:
glUniform2i(position, data[0], data[1]);
break;
case 3:
glUniform3i(position, data[0], data[1], data[2]);
break;
case 4:
glUniform4i(position, data[0], data[1], data[2], data[3]);
break;
default:
Console::error << "[OpenGL] wrong int uniform data size." << Console::endl;
break;
}
}
void ShaderInterface::handleUniforms(PhysicalObject* object, bool usePostProgram)
{
ProgIter thisProg = usePostProgram ? postProgram : runningProgram;
int textureOffset = 0;
UniformInfos unis = thisProg->second->getUniforms();
for(ConstUniformInfosIter iter = unis.begin();
iter != unis.end(); iter++)
{
if(iter->ID == Uniform_Num_Lights)
glUniform1i(iter->glID, simgraphics->getNumLightsOn());
else if(iter->ID == Uniform_ImageDimensions)
{
int dimensions[2]; // x is width
simgraphics->getCurrentImageDimensions(dimensions[1], dimensions[0]);
glUniform2i(iter->glID, dimensions[0], dimensions[1]);
}
else if(iter->ID == Uniform_ExposureTime)
glUniform1f(iter->glID, simgraphics->getExposureTime());
else if(iter->ID == Uniform_ShadowMap)
glUniform1i(iter->glID, ++textureOffset);
}
thisProg->second->handleUniforms(object, textureOffset);
}
void Shader::uniform(GLint i, GLint i1, GLint i2)
{
use();
glUniform2i(i, i1, i2);
}
void rglUniform2i(GLint location, GLint v0, GLint v1)
{
glUniform2i(location, v0, v1);
}
static int find_and_pass_uniforms(SceneData* sceneData, SceneObject* so, GLuint program) {
GLint num;
GLint size_i;
GLenum type_i;
char name_i[MAX_NAME_LENGTH];
GLint location_i;
Uniform* uniform = NULL;
void* data = NULL;
char texKey[KEYSIZE];
GLuint textureHandle;
size_t textureIndex = 0;
uint i;
glGetProgramiv(program, GL_ACTIVE_UNIFORMS, &num);
for (i = 0; i < num; i++) {
glGetActiveUniform(program, i, MAX_NAME_LENGTH, NULL, &size_i, &type_i, name_i);
location_i = glGetUniformLocation(program, name_i);
if ( -1 == location_i) {
log_message ("error: could not find name: [%s] in shader program.", name_i);
return -1;
}
uniform = hashmap_find(name_i, so->uniforms);
if ( !uniform ) {
log_message ("error: could not find [%s] in scene object's uniform map", name_i);
return -1;
}
data = uniform->data;
switch (type_i) {
case GL_BOOL:
if ( 1 == size_i ) glUniform1i(location_i, ((GLint*)data)[0]);
else glUniform1iv(location_i, size_i, ((const GLint*)data));
break;
case GL_BOOL_VEC2:
if ( 1 == size_i ) glUniform2i(location_i, ((GLint*)data)[0], ((GLint*)data)[1]);
else glUniform2iv(location_i, size_i, ((const GLint*)data));
break;
case GL_BOOL_VEC3:
if ( 1 == size_i ) glUniform3i(location_i, ((GLint*)data)[0], ((GLint*)data)[1], ((GLint*)data)[2]);
else glUniform3iv(location_i, size_i, ((const GLint*)data));
break;
case GL_BOOL_VEC4:
if ( 1 == size_i ) glUniform4i(location_i, ((GLint*)data)[0], ((GLint*)data)[1], ((GLint*)data)[2], ((GLint*)data)[3]);
else glUniform4iv(location_i, size_i, ((const GLint*)data));
break;
case GL_INT:
if ( 1 == size_i ) glUniform1i(location_i, (GLint)data);
else glUniform1iv(location_i, size_i, ((const GLint*)data));
break;
case GL_INT_VEC2:
if ( 1 == size_i ) glUniform2i(location_i, ((GLint*)data)[0], ((GLint*)data)[1]);
else glUniform2iv(location_i, size_i, ((const GLint*)data));
break;
case GL_INT_VEC3:
if ( 1 == size_i ) glUniform3i(location_i, ((GLint*)data)[0], ((GLint*)data)[1], ((GLint*)data)[2]);
else glUniform3iv(location_i, size_i, ((const GLint*)data));
break;
case GL_INT_VEC4:
if ( 1 == size_i ) glUniform4i(location_i, ((GLint*)data)[0], ((GLint*)data)[1], ((GLint*)data)[2], ((GLint*)data)[3]);
else glUniform4iv(location_i, size_i, ((const GLint*)data));
break;
case GL_FLOAT:
if ( 1 == size_i ) glUniform1f(location_i, ((GLfloat*)data)[0]);
else glUniform1fv(location_i, size_i, ((const GLfloat*)data));
break;
case GL_FLOAT_VEC2:
if ( 1 == size_i ) glUniform2f(location_i, ((GLfloat*)data)[0], ((GLfloat*)data)[1]);
else glUniform2fv(location_i, size_i, ((const GLfloat*)data));
break;
case GL_FLOAT_VEC3:
if ( 1 == size_i ) glUniform3f(location_i, ((GLfloat*)data)[0], ((GLfloat*)data)[1], ((GLfloat*)data)[2]);
else glUniform3fv(location_i, size_i, ((const GLfloat*)data));
break;
case GL_FLOAT_VEC4:
if ( 1 == size_i ) glUniform4f(location_i, ((GLfloat*)data)[0], ((GLfloat*)data)[1], ((GLfloat*)data)[2], ((GLfloat*)data)[3]);
else glUniform4fv(location_i, size_i, ((const GLfloat*)data));
break;
case GL_FLOAT_MAT2:
glUniformMatrix2fv(location_i, size_i, GL_FALSE, (const GLfloat*)data);
break;
case GL_FLOAT_MAT3:
glUniformMatrix3fv(location_i, size_i, GL_FALSE, (const GLfloat*)data);
break;
case GL_FLOAT_MAT4:
glUniformMatrix4fv(location_i, size_i, GL_FALSE, (const GLfloat*)data);
break;
case GL_SAMPLER_2D:
snprintf( texKey, KEYSIZE, "%p", uniform );
textureHandle = (GLuint)hashmap_find ( texKey, sceneData->mapTexture2Handle );
if ( !textureHandle ) {
log_message ( "error: could not bind texture. handle not found");
return -1;
}
if (textureIndex > 7) {
log_message ( "error: cannot use more than 8 texture units per scene object" );
return -1;
}
glActiveTexture(get_texture_unit(textureIndex));
glBindTexture (GL_TEXTURE_2D, textureHandle);
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, uniform->sampleMode );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, uniform->sampleMode );
glUniform1i ( location_i, textureIndex );
textureIndex++;
break;
case GL_SAMPLER_CUBE:
log_message ( "error: cube maps are not supported" );
break;
}
}
return 0;
}
//--------------------------------------------------------------
void ofShader::setUniform2i(const string & name, int v1, int v2) const{
if(bLoaded) {
int loc = getUniformLocation(name);
if (loc != -1) glUniform2i(loc, v1, v2);
}
}
void OpenGLPostProcessing::BlitToScreen()
{
if (!m_enable) return;
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
glViewport(0, 0, m_width, m_height);
m_shader.Bind();
glUniform4f(m_uniform_resolution, (float)m_width, (float)m_height, 1.0f/(float)m_width, 1.0f/(float)m_height);
glUniform1ui(m_uniform_time, (GLuint)m_timer.GetTimeElapsed());
if (m_config.IsDirty())
{
for (auto& it : m_config.GetOptions())
{
if (it.second.m_dirty)
{
switch (it.second.m_type)
{
case PostProcessingShaderConfiguration::ConfigurationOption::OptionType::OPTION_BOOL:
glUniform1i(m_uniform_bindings[it.first], it.second.m_bool_value);
break;
case PostProcessingShaderConfiguration::ConfigurationOption::OptionType::OPTION_INTEGER:
switch (it.second.m_integer_values.size())
{
case 1:
glUniform1i(m_uniform_bindings[it.first], it.second.m_integer_values[0]);
break;
case 2:
glUniform2i(m_uniform_bindings[it.first],
it.second.m_integer_values[0],
it.second.m_integer_values[1]);
break;
case 3:
glUniform3i(m_uniform_bindings[it.first],
it.second.m_integer_values[0],
it.second.m_integer_values[1],
it.second.m_integer_values[2]);
break;
case 4:
glUniform4i(m_uniform_bindings[it.first],
it.second.m_integer_values[0],
it.second.m_integer_values[1],
it.second.m_integer_values[2],
it.second.m_integer_values[3]);
break;
}
break;
case PostProcessingShaderConfiguration::ConfigurationOption::OptionType::OPTION_FLOAT:
switch (it.second.m_float_values.size())
{
case 1:
glUniform1f(m_uniform_bindings[it.first], it.second.m_float_values[0]);
break;
case 2:
glUniform2f(m_uniform_bindings[it.first],
it.second.m_float_values[0],
it.second.m_float_values[1]);
break;
case 3:
glUniform3f(m_uniform_bindings[it.first],
it.second.m_float_values[0],
it.second.m_float_values[1],
it.second.m_float_values[2]);
break;
case 4:
glUniform4f(m_uniform_bindings[it.first],
it.second.m_float_values[0],
it.second.m_float_values[1],
it.second.m_float_values[2],
it.second.m_float_values[3]);
break;
}
break;
}
it.second.m_dirty = false;
}
}
m_config.SetDirty(false);
}
glActiveTexture(GL_TEXTURE0+9);
glBindTexture(GL_TEXTURE_2D, m_texture);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
void ShaderProgram::setUniformi(const std::string& _name, int _value0, int _value1) {
use();
GLint location = getUniformLocation(_name);
glUniform2i(location, _value0, _value1);
}
void Shader::uniform2i(const std::string& name, int value0, int value1) const {
int paramLocation = glGetUniformLocation(this->programId, name.c_str());
glUniform2i(paramLocation, value0, value1);
}
