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); }