EffectDrawRegistry::ConfigType * EffectDrawRegistry::_CreateDrawConfig( DescType const & desc, SourceConfigType const * sconfig) { ConfigType * config = BaseRegistry::_CreateDrawConfig(desc.first, sconfig); assert(config); // XXXdyu can use layout(binding=) with GLSL 4.20 and beyond g_transformBinding = 0; glUniformBlockBinding(config->program, glGetUniformBlockIndex(config->program, "Transform"), g_transformBinding); g_tessellationBinding = 1; glUniformBlockBinding(config->program, glGetUniformBlockIndex(config->program, "Tessellation"), g_tessellationBinding); g_lightingBinding = 2; glUniformBlockBinding(config->program, glGetUniformBlockIndex(config->program, "Lighting"), g_lightingBinding); CHECK_GL_ERROR("CreateDrawConfig B \n"); GLint loc; if ((loc = glGetUniformLocation(config->program, "OsdVertexBuffer")) != -1) { glProgramUniform1i(config->program, loc, 0); // GL_TEXTURE0 } if ((loc = glGetUniformLocation(config->program, "OsdValenceBuffer")) != -1) { glProgramUniform1i(config->program, loc, 1); // GL_TEXTURE1 } if ((loc = glGetUniformLocation(config->program, "OsdQuadOffsetBuffer")) != -1) { glProgramUniform1i(config->program, loc, 2); // GL_TEXTURE2 } if ((loc = glGetUniformLocation(config->program, "OsdPatchParamBuffer")) != -1) { glProgramUniform1i(config->program, loc, 3); // GL_TEXTURE3 } CHECK_GL_ERROR("CreateDrawConfig leave\n"); return config; }
void ShaderManager::ApplyUBOToAllShaders(std::string blockName, int binding) { for (auto& shaderPair : _shaderMap) { GLuint program = shaderPair.second->GetProgram(); int blockIndex = glGetUniformBlockIndex(program, blockName.c_str()); if (blockIndex != GL_INVALID_INDEX) glUniformBlockBinding(program, blockIndex, binding); } }
int GL3ProgramObjectProvider::get_uniform_buffer_index(const std::string &block_name) const { throw_if_disposed(); OpenGL::set_active(); if (!glGetUniformBlockIndex) throw Exception("incorrect OpenGL version"); return glGetUniformBlockIndex(handle, StringHelp::text_to_local8(block_name).c_str()); }
/* * * Core in: * * OpenGLES : 3.0 */ GLuint rglGetUniformBlockIndex( GLuint program, const GLchar *uniformBlockName) { #if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES3) return glGetUniformBlockIndex(program, uniformBlockName); #else printf("WARNING! Not implemented.\n"); return 0; #endif }
bool initProgram() { bool Validated(true); compiler Compiler; if(Validated) { ShaderName[shader::VERT_TEXTURE] = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE_TEXTURE, "--version 400 --profile core"); ShaderName[shader::FRAG_TEXTURE] = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE_TEXTURE, "--version 400 --profile core"); Validated = Validated && Compiler.check(); ProgramName[program::TEXTURE] = glCreateProgram(); glAttachShader(ProgramName[program::TEXTURE], ShaderName[shader::VERT_TEXTURE]); glAttachShader(ProgramName[program::TEXTURE], ShaderName[shader::FRAG_TEXTURE]); glBindAttribLocation(ProgramName[program::TEXTURE], semantic::attr::POSITION, "Position"); glBindAttribLocation(ProgramName[program::TEXTURE], semantic::attr::TEXCOORD, "Texcoord"); glBindFragDataLocation(ProgramName[program::TEXTURE], semantic::frag::COLOR, "Color"); glLinkProgram(ProgramName[program::TEXTURE]); Validated = Validated && Compiler.checkProgram(ProgramName[program::TEXTURE]); } if(Validated) { UniformTransform = glGetUniformBlockIndex(ProgramName[program::TEXTURE], "transform"); UniformDiffuse[program::TEXTURE] = glGetUniformLocation(ProgramName[program::TEXTURE], "Diffuse"); UniformUseGrad = glGetUniformLocation(ProgramName[program::TEXTURE], "UseGrad"); } if(Validated) { ShaderName[shader::VERT_SPLASH] = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE_SPLASH, "--version 400 --profile core"); ShaderName[shader::FRAG_SPLASH] = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE_SPLASH, "--version 400 --profile core"); Validated = Validated && Compiler.check(); ProgramName[program::SPLASH] = glCreateProgram(); glAttachShader(ProgramName[program::SPLASH], ShaderName[shader::VERT_SPLASH]); glAttachShader(ProgramName[program::SPLASH], ShaderName[shader::FRAG_SPLASH]); glBindFragDataLocation(ProgramName[program::SPLASH], semantic::frag::COLOR, "Color"); glLinkProgram(ProgramName[program::SPLASH]); Validated = Validated && Compiler.checkProgram(ProgramName[program::SPLASH]); } if(Validated) { UniformDiffuse[program::SPLASH] = glGetUniformLocation(ProgramName[program::SPLASH], "Diffuse"); UniformFramebufferSize = glGetUniformLocation(ProgramName[program::SPLASH], "FramebufferSize"); } return Validated && this->checkError("initProgram"); }
void SHADER::SetProgramVariables() { // glsl shader must be bind to set samplers Bind(); // Bind UBO if (g_ActiveConfig.backend_info.bSupportsGLSLUBO) { GLint PSBlock_id = glGetUniformBlockIndex(glprogid, "PSBlock"); GLint VSBlock_id = glGetUniformBlockIndex(glprogid, "VSBlock"); if(PSBlock_id != -1) glUniformBlockBinding(glprogid, PSBlock_id, 1); if(VSBlock_id != -1) glUniformBlockBinding(glprogid, VSBlock_id, 2); } // We cache our uniform locations for now // Once we move up to a newer version of GLSL, ~1.30 // We can remove this // (Sonicadvance): For some reason this fails on my hardware //glGetUniformIndices(glprogid, NUM_UNIFORMS, UniformNames, UniformLocations); // Got to do it this crappy way. UniformLocations[0] = glGetUniformLocation(glprogid, UniformNames[0]); if (!g_ActiveConfig.backend_info.bSupportsGLSLUBO) for (int a = 1; a < NUM_UNIFORMS; ++a) UniformLocations[a] = glGetUniformLocation(glprogid, UniformNames[a]); // Bind Texture Sampler for (int a = 0; a <= 9; ++a) { char name[8]; snprintf(name, 8, "samp%d", a); // Still need to get sampler locations since we aren't binding them statically in the shaders int loc = glGetUniformLocation(glprogid, name); if (loc != -1) glUniform1i(loc, a); } }
bool effect::create() { _program = createProgram(&_shaders[0], _shaders.size()); if (!_program) return false; std::vector<std::string> uniformNames; GLint numUniforms, maxLength; glGetProgramiv(_program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxLength); glGetProgramiv(_program, GL_ACTIVE_UNIFORMS, &numUniforms); char* buf = new char[maxLength]; for (int i = 0; i < numUniforms; ++i) { GLsizei size; glGetActiveUniformName(_program, i, maxLength, &size, buf); std::string name(buf); if (uniformNames.size() > 0 && uniformNames[i - 1] == name) break; else uniformNames.push_back(name); } delete[] buf; for (int i = 0; i < uniformNames.size(); ++i) { GLint uniformLocation = glGetUniformLocation(_program, uniformNames[i].c_str()); if (uniformLocation != -1) _uniforms[uniformNames[i]] = uniformLocation; } std::vector<std::string> uniformBlockNames; glGetProgramiv(_program, GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, &maxLength); glGetProgramiv(_program, GL_ACTIVE_UNIFORM_BLOCKS, &numUniforms); buf = new char[maxLength]; for (int i = 0; i < numUniforms; ++i) { GLsizei size; glGetActiveUniformBlockName(_program, i, maxLength, &size, buf); std::string name(buf); if (uniformBlockNames.size() > 0 && uniformBlockNames[i - 1] == name) break; else uniformBlockNames.push_back(name); } delete[] buf; for (int i = 0; i < uniformBlockNames.size(); ++i) { GLuint blockIndex = glGetUniformBlockIndex(_program, uniformBlockNames[i].c_str()); glUniformBlockBinding(_program, blockIndex, i); _blockUniforms[uniformBlockNames[i]] = i; } return true; }
/// Set the frame data in the shader void ShaderProgram::setFrameData(int frameDataBO) { // Find the frame data position, if it does not exist if (frameDataPosition == (GLuint) -1) { frameDataPosition = glGetUniformBlockIndex(ShaderProgramID,"frameData"); glUniformBlockBinding(ShaderProgramID, frameDataPosition, 1); } // Bind the buffer to it glBindBufferBase(GL_UNIFORM_BUFFER,1,frameDataBO); }
void Initialize() { printf("Version Pilote OpenGL : %s\n", glGetString(GL_VERSION)); printf("Type de GPU : %s\n", glGetString(GL_RENDERER)); printf("Fabricant : %s\n", glGetString(GL_VENDOR)); printf("Version GLSL : %s\n", glGetString(GL_SHADING_LANGUAGE_VERSION)); int numExtensions; glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions); GLenum error = glewInit(); if (error != GL_NO_ERROR) { // TODO } for (int index = 0; index < numExtensions; ++index) { printf("Extension[%d] : %s\n", index, glGetStringi(GL_EXTENSIONS, index)); } #ifdef _WIN32 // on coupe la synchro vertical pour voir l'effet du delta time wglSwapIntervalEXT(0); #endif basicShader.LoadVertexShader("basic.vs"); basicShader.LoadFragmentShader("basic.fs"); basicShader.Create(); auto program = basicShader.GetProgram(); // UN UBO SERAIT UTILE ICI auto basicProgram = basicShader.GetProgram(); auto blockIndex = glGetUniformBlockIndex(basicProgram, "ViewProj"); GLuint blockBinding = 1; glGenBuffers(1, &g_Camera.UBO); glBindBuffer(GL_UNIFORM_BUFFER, g_Camera.UBO); //glBufferData(GL_UNIFORM_BUFFER, sizeof(glm::mat4) * 2, NULL, GL_STREAM_DRAW); glBufferSubData(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4), glm::value_ptr(g_Camera.projectionMatrix)); glBufferSubData(GL_UNIFORM_BUFFER, sizeof(glm::mat4), sizeof(glm::mat4), glm::value_ptr(g_Camera.viewMatrix)); glBindBufferBase(GL_UNIFORM_BUFFER, blockBinding, g_Camera.UBO); glBindBuffer(GL_UNIFORM_BUFFER, 0); glUniformBlockBinding(basicProgram, blockIndex, blockBinding); previousTime = glutGet(GLUT_ELAPSED_TIME); InitCube(); // render states par defaut glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); glEnable(GL_CULL_FACE); }
void Test6::Init(){ cout<<endl<<"INIT TEST 6 CELL SHADING "<<endl; /*************** 0 -- Retrec l'apuntador al objecte VIDEO MANAGER per no fer una indireccio més cada cop */ VideoManager *m_video_manager_pointer = VideoManager::GetInstance(); /************ 1 -- CARREGO OBJECTES ********************/ m_mesh = new Mesh_OBJ2(); //m_mesh->CarregaFitxer("esfera32.obj"); m_mesh->CarregaFitxer("donut.obj"); /************ 2 -- CREO UN PROGRAMA AMB ELS SHADERS ***************/ m_GL_program = new CGLProgram(); m_GL_program->AttachShader("recursos/shaders/Test6.vert",GL_VERTEX_SHADER); m_GL_program->AttachShader("recursos/shaders/Test6.frag",GL_FRAGMENT_SHADER); // FAIG QUE EL ATRIBUT 0 (QUE SON LES CORDENADES DELS VERTEX) ENTRIN a "in_Position" al vertex shader m_GL_program->Bind_Attribute_Location(0,"in_Position"); m_GL_program->Bind_Attribute_Location(1,"in_Normals"); m_GL_program->Link(); //CARREGO UNIFORMS GLuint l_block_index = glGetUniformBlockIndex(m_GL_program->m_ID,"MatriusGlobals"); glUniformBlockBinding(m_GL_program->m_ID,l_block_index,0); glBindBufferRange(GL_UNIFORM_BUFFER,0,m_video_manager_pointer->Get_UBO_Matrius_globals_location(),0 * sizeof(glm::mat4),2*sizeof(glm::mat4)); //APLICO LA TEXTURA UNIDIMENSIONAL GLuint textura; glGenTextures(1,&textura); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_1D, textura); GLubyte textureData[4][3] = { {32,0,0}, {64,0,0}, {128,0,0}, {255,0,0} }; //TEXTURA UNIDIMENSIONAL glTexImage1D(GL_TEXTURE_1D,0,GL_RGB,4,0,GL_RGB,GL_UNSIGNED_BYTE,textureData); glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MIN_FILTER,GL_NEAREST); glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MAG_FILTER,GL_NEAREST); glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE); m_GL_program->SetUniform("CoordenadaTex",0); //Li dic que m'agafi la textura del sampler 0 //CARREGO UNA LLUM m_llum = new CGLLlum(vec3(0.0,32.0,0.0),vec3(0.8,0.7,0.5),0.2); }
bool initProgram() { bool Validated(true); compiler Compiler; std::array<GLuint, shader::MAX> ShaderName; if(Validated) { ShaderName[shader::VERT_TEXTURE] = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE_TEXTURE, "--version 300 --profile es"); ShaderName[shader::FRAG_TEXTURE] = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE_TEXTURE, "--version 300 --profile es"); ProgramName[program::TEXTURE] = glCreateProgram(); glAttachShader(ProgramName[program::TEXTURE], ShaderName[shader::VERT_TEXTURE]); glAttachShader(ProgramName[program::TEXTURE], ShaderName[shader::FRAG_TEXTURE]); glLinkProgram(ProgramName[program::TEXTURE]); } if(Validated) { ShaderName[shader::VERT_SPLASH] = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE_SPLASH, "--version 300 --profile es"); ShaderName[shader::FRAG_SPLASH] = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE_SPLASH, "--version 300 --profile es"); ProgramName[program::SPLASH] = glCreateProgram(); glAttachShader(ProgramName[program::SPLASH], ShaderName[shader::VERT_SPLASH]); glAttachShader(ProgramName[program::SPLASH], ShaderName[shader::FRAG_SPLASH]); glLinkProgram(ProgramName[program::SPLASH]); } if(Validated) { Validated = Validated && Compiler.check(); Validated = Validated && Compiler.checkProgram(ProgramName[program::TEXTURE]); Validated = Validated && Compiler.checkProgram(ProgramName[program::SPLASH]); } if(Validated) { UniformTransform = glGetUniformBlockIndex(ProgramName[program::TEXTURE], "transform"); UniformDiffuse[program::TEXTURE] = glGetUniformLocation(ProgramName[program::TEXTURE], "Diffuse"); UniformDiffuse[program::SPLASH] = glGetUniformLocation(ProgramName[program::SPLASH], "Diffuse"); glUseProgram(ProgramName[program::TEXTURE]); glUniform1i(UniformDiffuse[program::TEXTURE], 0); glUniformBlockBinding(ProgramName[program::TEXTURE], UniformTransform, semantic::uniform::TRANSFORM0); glUseProgram(ProgramName[program::SPLASH]); glUniform1i(UniformDiffuse[program::SPLASH], 0); } return Validated && this->checkError("initProgram"); }
void Piece::createBufferObject() { progID = shaderProg->getProgram(); unifID = glGetUniformLocation(progID,"ModelMatrix"); normalID = glGetUniformLocation(progID,"NormalMatrix"); uboID = glGetUniformBlockIndex(progID, "SharedMatrices"); glUniform3f(glGetUniformLocation(progID, "LightPosition"), 0.0, 0.0, -5.0);//2.0,0.0,0.0 glUniform2f(glGetUniformLocation(progID, "LightAttenuation"), 0.0f, 0.0005f);//0.0, 0.0 glUniform3f(glGetUniformLocation(progID, "AmbientLightColor"), 0.3f, 0.3f, 0.3f);//0.1,0.1,0.1 glUniform3f(glGetUniformLocation(progID, "LightDiffuseColor"), 0.9f, 0.9f, 0.9f);//0.9,0.9,0.9 glUniform3f(glGetUniformLocation(progID, "LightSpecularColor"), 0.9f, 0.9f, 0.9f);//0.9,0.9,0.9 glUniform3f(glGetUniformLocation(progID, "MaterialAmbientColor"), 0.8f, 0.8f, 0.8f);//0.9,0.1,0.1 glUniform3f(glGetUniformLocation(progID, "MaterialDiffuseColor"), 0.9f, 0.9f, 0.9f);//0.9,0.1,0.1 glUniform3f(glGetUniformLocation(progID, "MaterialSpecularColor"), 0.9f, 0.9f, 0.9f);//0.9,0.9,0.9 glUniform1f(glGetUniformLocation(progID, "MaterialShininess"), 64.0f);//64.0f//22 glUniformBlockBinding(progID, uboID, 0); glGenBuffers(1, &indexBuffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer); glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW); glGenVertexArrays(1, &VaoId); glBindVertexArray(VaoId); glGenBuffers(2, VboId); glBindBuffer(GL_ARRAY_BUFFER, VboId[0]); glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex)*vertexes.size(), &vertexes[0], GL_STATIC_DRAW); glEnableVertexAttribArray(VERTICES); glVertexAttribPointer(VERTICES, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex), 0); glEnableVertexAttribArray(COLORS); glVertexAttribPointer(COLORS, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid *)sizeof(vertexes[0].XYZW)); glEnableVertexAttribArray(NORMALS); glVertexAttribPointer(NORMALS, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid *)(sizeof(vertexes[0].XYZW) + sizeof(vertexes[0].RGBA))); glEnableVertexAttribArray(TEXTURE); glVertexAttribPointer(TEXTURE, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (GLvoid *)(sizeof(vertexes[0].XYZW) + sizeof(vertexes[0].RGBA) + sizeof(vertexes[0].NORMAL))); glBindBuffer(GL_UNIFORM_BUFFER, VboId[1]); glBufferData(GL_UNIFORM_BUFFER, sizeof(glm::mat4)*2, 0, GL_STREAM_DRAW); glBindBufferBase(GL_UNIFORM_BUFFER, 0, VboId[1]); glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_UNIFORM_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); }
UnlitProgData loadUnlitProgram(const std::string &vertShaderFile, const std::string &fragShaderFile) { UnlitProgData data; data.program = loadProgram(vertShaderFile, fragShaderFile); data.modelViewUnif = glGetUniformLocation(data.program, "modelViewMatrix"); data.objectColorUnif = glGetUniformLocation(data.program, "objectColor"); GLuint projectionBlock = glGetUniformBlockIndex(data.program, "Projection"); glUniformBlockBinding(data.program, projectionBlock, g_projectionBlockIndex); return data; }
static void setup_ubos(void) { static const char *names[NUM_UBOS] = { "ub_pos_size", "ub_color", "ub_rot" }; int i; glGenBuffers(NUM_UBOS, buffers); for (i = 0; i < NUM_UBOS; i++) { GLint index, size; /* query UBO index */ index = glGetUniformBlockIndex(prog, names[i]); /* query UBO size */ glGetActiveUniformBlockiv(prog, index, GL_UNIFORM_BLOCK_DATA_SIZE, &size); printf("UBO %s: index = %d, size = %d\n", names[i], index, size); /* Allocate UBO */ glBindBuffer(GL_UNIFORM_BUFFER, buffers[i]); glBufferStorage(GL_UNIFORM_BUFFER, size, NULL, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT | GL_DYNAMIC_STORAGE_BIT); piglit_check_gl_error(GL_NO_ERROR); ubos[i] = glMapBufferRange(GL_UNIFORM_BUFFER, 0, size, GL_MAP_WRITE_BIT | GL_MAP_PERSISTENT_BIT | GL_MAP_COHERENT_BIT); piglit_check_gl_error(GL_NO_ERROR); if (!ubos[i]) piglit_report_result(PIGLIT_FAIL); /* Attach UBO */ glBindBufferBase(GL_UNIFORM_BUFFER, i, buffers[i]); glUniformBlockBinding(prog, index, i); if (!piglit_check_gl_error(GL_NO_ERROR)) piglit_report_result(PIGLIT_FAIL); } }
void ShaderProgram::setFrameData() { glBindBuffer(GL_UNIFORM_BUFFER, frameDataBO); glBufferData(GL_UNIFORM_BUFFER, sizeof(frameData), &frameData, GL_DYNAMIC_DRAW); if (frameDataPosition == (GLuint) -1) { frameDataPosition = glGetUniformBlockIndex(ShaderProgramID,"frameData"); glUniformBlockBinding(ShaderProgramID, frameDataPosition, 1); } glBindBufferBase(GL_UNIFORM_BUFFER,1,frameDataBO); }
bool initProgram() { bool Validated = true; compiler Compiler; if(Validated) { compiler Compiler; GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE, "--version 150 --profile core"); GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE, "--version 150 --profile core"); ProgramName = glCreateProgram(); glAttachShader(ProgramName, VertShaderName); glAttachShader(ProgramName, FragShaderName); glBindAttribLocation(ProgramName, semantic::attr::POSITION, "Position"); glBindAttribLocation(ProgramName, semantic::attr::NORMAL, "Normal"); glBindAttribLocation(ProgramName, semantic::attr::COLOR, "Color"); glBindFragDataLocation(ProgramName, semantic::frag::COLOR, "Color"); glLinkProgram(ProgramName); Validated = Validated && Compiler.check(); Validated = Validated && Compiler.checkProgram(ProgramName); } if(Validated) { this->UniformPerDraw = glGetUniformBlockIndex(ProgramName, "per_draw"); this->UniformPerPass = glGetUniformBlockIndex(ProgramName, "per_pass"); this->UniformPerScene = glGetUniformBlockIndex(ProgramName, "per_scene"); glUniformBlockBinding(ProgramName, this->UniformPerDraw, uniform::PER_DRAW); glUniformBlockBinding(ProgramName, this->UniformPerPass, uniform::PER_PASS); glUniformBlockBinding(ProgramName, this->UniformPerPass, uniform::PER_SCENE); } return Validated; }
END_COMPONENT_DESTROY #if 0 void tv_material_add_ubo(tv_material *material, const tvchar* name) { /* retrieve the binding point for the new UBO */ GLuint binding_point = material->num_ubos + 1; /* get the block index of the UBO by its name */ GLuint block_index = glGetUniformBlockIndex(material->program, name); glUniformBlockBinding(material->program, block_index, binding_point); glGenBuffers(1, &material->ubos[material->num_ubos]); ++material->num_ubos; }
bool initProgram() { bool Validated(true); if(Validated) { glf::compiler Compiler; GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, glf::DATA_DIRECTORY + VERT_SHADER_SOURCE_TEXTURE, "--version 150 --profile core"); GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, glf::DATA_DIRECTORY + FRAG_SHADER_SOURCE_TEXTURE, "--version 150 --profile core"); Validated = Validated && Compiler.check(); ProgramName[program::TEXTURE] = glCreateProgram(); glAttachShader(ProgramName[program::TEXTURE], VertShaderName); glAttachShader(ProgramName[program::TEXTURE], FragShaderName); glBindAttribLocation(ProgramName[program::TEXTURE], glf::semantic::attr::POSITION, "Position"); glBindAttribLocation(ProgramName[program::TEXTURE], glf::semantic::attr::TEXCOORD, "Texcoord"); glBindFragDataLocation(ProgramName[program::TEXTURE], glf::semantic::frag::COLOR, "Color"); glLinkProgram(ProgramName[program::TEXTURE]); glDeleteShader(VertShaderName); glDeleteShader(FragShaderName); Validated = Validated && glf::checkProgram(ProgramName[program::TEXTURE]); } if(Validated) UniformTransform = glGetUniformBlockIndex(ProgramName[program::TEXTURE], "transform"); if(Validated) { glf::compiler Compiler; GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, glf::DATA_DIRECTORY + VERT_SHADER_SOURCE_SPLASH, "--version 150 --profile core"); GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, glf::DATA_DIRECTORY + FRAG_SHADER_SOURCE_SPLASH, "--version 150 --profile core"); Validated = Validated && Compiler.check(); ProgramName[program::SPLASH] = glCreateProgram(); glAttachShader(ProgramName[program::SPLASH], VertShaderName); glAttachShader(ProgramName[program::SPLASH], FragShaderName); glBindFragDataLocation(ProgramName[program::TEXTURE], glf::semantic::frag::COLOR, "Color"); glLinkProgram(ProgramName[program::SPLASH]); glDeleteShader(VertShaderName); glDeleteShader(FragShaderName); Validated = Validated && glf::checkProgram(ProgramName[program::SPLASH]); } return Validated; }
void piglit_init(int argc, char **argv) { bool pass = true; GLuint prog; const char *uniform_block_names[3] = { "ub_a", "ub_b", "ub_c" }; const char *uniform_names[4] = { "a", "b", "c", "d" }; GLuint block_indices[3]; GLuint uniform_indices[4]; GLint uniform_block_indices[4]; int i; piglit_require_extension("GL_ARB_uniform_buffer_object"); prog = piglit_build_simple_program(vs_source, fs_source); for (i = 0; i < 3; i++) { block_indices[i] = glGetUniformBlockIndex(prog, uniform_block_names[i]); printf("Uniform block \"%s\" index: 0x%08x\n", uniform_block_names[i], block_indices[i]); } if (block_indices[0] == block_indices[1] || block_indices[0] == block_indices[2] || block_indices[1] == block_indices[2]) { piglit_report_result(PIGLIT_FAIL); } glGetUniformIndices(prog, 4, uniform_names, uniform_indices); glGetActiveUniformsiv(prog, 4, uniform_indices, GL_UNIFORM_BLOCK_INDEX, uniform_block_indices); for (i = 0; i < 4; i++) { int expected_index = (i == 3) ? -1 : block_indices[i]; printf("Uniform \"%s\": index %d, block index %d", uniform_names[i], uniform_indices[i], uniform_block_indices[i]); if (uniform_block_indices[i] != expected_index) { printf(" FAIL"); pass = false; } printf("\n"); } piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL); }
// render the 3D object void Object::render(Camera * camera, Light * light, GLdouble elapsedTime) { Program::useProgram(program); GLuint p = program->getProgram(); Mesh::aPositionLoc = glGetAttribLocation(p, "position"); Mesh::aTexCoordLoc = glGetAttribLocation(p, "texCoord"); Mesh::aNormalLoc = glGetAttribLocation(p, "normal"); Node::uModelMatrixLoc = glGetUniformLocation(p, "modelMatrix"); Camera::uViewMatrixLoc = glGetUniformLocation(p, "viewMatrix"); Camera::uProjMatrixLoc = glGetUniformLocation(p, "projMatrix"); Material::uboMaterialLoc = glGetUniformBlockIndex(p, "Material"); Light::uboLightLoc = glGetUniformBlockIndex(p, "Light"); Texture::uTextureCountLoc = glGetUniformLocation(p, "texCount"); Camera::uViewPosLoc = glGetUniformLocation(p, "viewPos"); glUniformMatrix4fv(Camera::uViewMatrixLoc, 1, GL_FALSE, glm::value_ptr(camera->getViewMatrix())); glUniformMatrix4fv(Camera::uProjMatrixLoc, 1, GL_FALSE, glm::value_ptr(camera->getProjectionMatrix())); glm::vec3 viewPos = camera->getViewPoint(); glUniform3f(Camera::uViewPosLoc, viewPos.x, viewPos.y, viewPos.z); #ifdef PRINT_CAMERA_POSITION cout << "Camera Pos:\t" << viewPos << endl; #endif if (light != NULL){ glBindBufferRange(GL_UNIFORM_BUFFER, Light::uboLightLoc, light->getUBOLight(), 0, sizeof(LightMaterial)); #ifdef PRINT_LIGHT_SOURCE cout << *(light->uLight) << endl; #endif } model->render(); }
static void setup_ubos(void) { static const char *names[NUM_UBOS] = { "ub_pos_size", "ub_color", "ub_rot" }; int i; glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, &alignment); printf("GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT = %d\n", alignment); if (test_buffer_offset) { printf("Testing buffer offset %d\n", alignment); } else { /* we use alignment as the offset */ alignment = 0; } glCreateBuffers(NUM_UBOS, buffers); for (i = 0; i < NUM_UBOS; i++) { GLint index, size; /* query UBO index */ index = glGetUniformBlockIndex(prog, names[i]); /* query UBO size */ glGetActiveUniformBlockiv(prog, index, GL_UNIFORM_BLOCK_DATA_SIZE, &size); printf("UBO %s: index = %d, size = %d\n", names[i], index, size); /* Allocate UBO */ glNamedBufferData(buffers[i], size + alignment, NULL, GL_DYNAMIC_DRAW); /* Attach UBO */ glBindBufferRange(GL_UNIFORM_BUFFER, i, buffers[i], alignment, /* offset */ size); glUniformBlockBinding(prog, index, i); if (!piglit_check_gl_error(GL_NO_ERROR)) piglit_report_result(PIGLIT_FAIL); } }
ShaderProgram::ShaderProgram(const std::string& vertexShaderName, const std::string& fragmentShaderName) { vertexShader = new Shader(GL_VERTEX_SHADER, vertexShaderName); fragmentShader = new Shader(GL_FRAGMENT_SHADER, fragmentShaderName); shaderList.push_back(vertexShader->getShader()); shaderList.push_back(fragmentShader->getShader()); theProgram = Framework::CreateProgram(shaderList); modelToWorldMatrixUnif = glGetUniformLocation(theProgram, "modelToWorldMatrix"); globalUniformBlockIndex = glGetUniformBlockIndex(theProgram, "GlobalMatrices"); baseColorUnif = glGetUniformLocation(theProgram, "baseColor"); glUniformBlockBinding(theProgram, globalUniformBlockIndex, globalMatricesBindingIndex); }
bool initProgram() { bool Validated = true; compiler Compiler; // Create program if(Validated) { compiler Compiler; GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE, "--version 150 --profile core"); GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE, "--version 150 --profile core"); ProgramName = glCreateProgram(); glAttachShader(ProgramName, VertShaderName); glAttachShader(ProgramName, FragShaderName); glBindAttribLocation(ProgramName, semantic::attr::POSITION, "Position"); glBindFragDataLocation(ProgramName, semantic::frag::COLOR, "Color"); glLinkProgram(ProgramName); Validated = Validated && Compiler.check(); Validated = Validated && Compiler.check_program(ProgramName); } // Get variables locations if(Validated) { UniformTransform = glGetUniformBlockIndex(ProgramName, "transform"); UniformMaterial = glGetUniformBlockIndex(ProgramName, "material"); glUniformBlockBinding(ProgramName, UniformTransform, semantic::uniform::TRANSFORM0); glUniformBlockBinding(ProgramName, UniformMaterial, semantic::uniform::MATERIAL); } return Validated && this->checkError("initProgram"); }
void GLHelper::attachUBOs(const GLuint program) const {//Attach the light block to our UBO GLuint lightAttachPoint = 0, playerAttachPoint = 1; int uniformIndex = glGetUniformBlockIndex(program, "LightSourceBlock"); if (uniformIndex >= 0) { glBindBuffer(GL_UNIFORM_BUFFER, lightUBOLocation); glUniformBlockBinding(program, uniformIndex, lightAttachPoint); glBindBufferRange(GL_UNIFORM_BUFFER, lightAttachPoint, lightUBOLocation, 0, (sizeof(glm::mat4) + 2 * sizeof(glm::vec4)) * NR_POINT_LIGHTS); //FIXME calculating the size should not be like that glBindBuffer(GL_UNIFORM_BUFFER, 0); } int uniformIndex2 = glGetUniformBlockIndex(program, "PlayerTransformBlock"); if (uniformIndex2 >= 0) { glBindBuffer(GL_UNIFORM_BUFFER, playerUBOLocation); glUniformBlockBinding(program, uniformIndex2, playerAttachPoint); glBindBufferRange(GL_UNIFORM_BUFFER, playerAttachPoint, playerUBOLocation, 0, 3 * sizeof(glm::mat4)); glBindBuffer(GL_UNIFORM_BUFFER, 0); } }
void Light::init() { for (auto shader : shader_programs) { GLuint light_index = glGetUniformBlockIndex(shader, "light_block"); glUniformBlockBinding(shader, light_index, 0); GLuint info_index = glGetUniformBlockIndex(shader, "light_info_block"); glUniformBlockBinding(shader, info_index, 1); } glGenBuffers(2, ubos); glBindBuffer(GL_UNIFORM_BUFFER, ubos[0]); glBufferData(GL_UNIFORM_BUFFER, light_size * _MAX_LIGHTS_, NULL, GL_DYNAMIC_DRAW); glBindBuffer(GL_UNIFORM_BUFFER, ubos[1]); glBufferData(GL_UNIFORM_BUFFER, info_size, NULL, GL_DYNAMIC_DRAW); glBindBuffer(GL_UNIFORM_BUFFER, 0); glBindBufferBase(GL_UNIFORM_BUFFER, 0, ubos[0]); glBindBufferBase(GL_UNIFORM_BUFFER, 1, ubos[1]); turn_on_all_lights(); }
ProgramData LoadLitProgram(const std::string &strVertexShader, const std::string &strFragmentShader) { std::vector<GLuint> shaderList; shaderList.push_back(Framework::LoadShader(GL_VERTEX_SHADER, strVertexShader)); shaderList.push_back(Framework::LoadShader(GL_FRAGMENT_SHADER, strFragmentShader)); ProgramData data; data.theProgram = Framework::CreateProgram(shaderList); data.modelToCameraMatrixUnif = glGetUniformLocation(data.theProgram, "modelToCameraMatrix"); data.normalModelToCameraMatrixUnif = glGetUniformLocation(data.theProgram, "normalModelToCameraMatrix"); GLuint materialBlock = glGetUniformBlockIndex(data.theProgram, "Material"); GLuint lightBlock = glGetUniformBlockIndex(data.theProgram, "Light"); GLuint projectionBlock = glGetUniformBlockIndex(data.theProgram, "Projection"); if(materialBlock != GL_INVALID_INDEX) //Can be optimized out. glUniformBlockBinding(data.theProgram, materialBlock, g_materialBlockIndex); glUniformBlockBinding(data.theProgram, lightBlock, g_lightBlockIndex); glUniformBlockBinding(data.theProgram, projectionBlock, g_projectionBlockIndex); return data; }
void UniformBuffer::init(Shader *referent, std::string const &blockName, std::string const vars[]) { GLint blockIdx, varNbr; GLint *varsInfos; glGenBuffers(1, &_bufferId); glBindBufferBase(GL_UNIFORM_BUFFER, _bindingPoint, _bufferId); blockIdx = glGetUniformBlockIndex(referent->getId(), blockName.c_str()); // find the total size to allocate the buffer glGetActiveUniformBlockiv(referent->getId(), blockIdx, GL_UNIFORM_BLOCK_DATA_SIZE, (GLint*)&_dataSize); _buffer = new char[_dataSize]; // get the number of uniforms glGetActiveUniformBlockiv(referent->getId(), blockIdx, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, &varNbr); assert(varNbr > 0 && "glGetActiveUniformBlockid Error"); // we store the uniforms informations in this table with this layout: // Indices - Types - Offset varsInfos = new GLint[varNbr * 3]; glGetActiveUniformBlockiv(referent->getId(), blockIdx, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, varsInfos); glGetActiveUniformsiv(referent->getId(), varNbr, (GLuint*)varsInfos, GL_UNIFORM_TYPE, varsInfos + varNbr); glGetActiveUniformsiv(referent->getId(), varNbr, (GLuint*)varsInfos, GL_UNIFORM_OFFSET, varsInfos + 2 * varNbr); // sort the vars by offset to make them correspond with the order of the names std::list<std::pair<GLint, GLint> > sorted; std::list<std::pair<GLint, GLint> >::iterator it; GLint curOffset; GLint i; // insertion sort for (i = 0; i < varNbr; ++i) { curOffset = varsInfos[varNbr * 2 + i]; it = sorted.begin(); while (it != sorted.end() && it->second < curOffset) ++it; sorted.insert(it, std::pair<GLint, GLint>(i, curOffset)); } // bind the name with the offset and type it = sorted.begin(); for (i = 0; it != sorted.end() && i < varNbr; ++i) { SUniformVars added; added.offset = varsInfos[varNbr * 2 + it->first]; added.type = varsInfos[varNbr + it->first]; _vars[vars[i]] = added; ++it; } delete[] varsInfos; }
void image_impl::render(const void* pWnd, int pX, int pY, int pViewPortWidth, int pViewPortHeight) { static const float matrix[16] = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}; glUseProgram(mProgram); // get uniform locations int mat_loc = glGetUniformLocation(mProgram, "matrix"); int tex_loc = glGetUniformLocation(mProgram, "tex"); int chn_loc = glGetUniformLocation(mProgram, "isGrayScale"); int cml_loc = glGetUniformLocation(mProgram, "cmaplen"); int ubo_idx = glGetUniformBlockIndex(mProgram, "ColorMap"); glUniform1i(chn_loc, mFormat==1); // load texture from PBO glActiveTexture(GL_TEXTURE0); glUniform1i(tex_loc, 0); glBindTexture(GL_TEXTURE_2D, mTex); // bind PBO to load data into texture glBindBuffer(GL_PIXEL_UNPACK_BUFFER, mPBO); glPixelStorei(GL_UNPACK_ALIGNMENT, 1); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, mWidth, mHeight, mGLformat, mDataType, 0); glPixelStorei(GL_UNPACK_ALIGNMENT, 4); glUniformMatrix4fv(mat_loc, 1, GL_FALSE, matrix); glUniform1f(cml_loc, (GLfloat)mUBOSize); glBindBufferBase(GL_UNIFORM_BUFFER, 0, mColorMapUBO); glUniformBlockBinding(mProgram, ubo_idx, 0); CheckGL("Before render"); // Draw to screen bindResources(pWnd); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); unbindResources(); glBindTexture(GL_TEXTURE_2D, 0); glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); // ubind the shader program glUseProgram(0); CheckGL("After render"); }
// Wczytuje shader bez oœwietlenia UnlitProgData loadFlatShader(const std::string &strVertexShader, const std::string &strFragmentShader) { std::vector<GLuint> shaderList; shaderList.push_back(Framework::LoadShader(GL_VERTEX_SHADER, strVertexShader)); shaderList.push_back(Framework::LoadShader(GL_FRAGMENT_SHADER, strFragmentShader)); UnlitProgData data; data.theProgram = Framework::CreateProgram(shaderList); data.modelToCameraMatrixUnif = glGetUniformLocation(data.theProgram, "modelToCameraMatrix"); data.objectColorUnif = glGetUniformLocation(data.theProgram, "objectColor"); GLuint projectionBlock = glGetUniformBlockIndex(data.theProgram, "Projection"); glUniformBlockBinding(data.theProgram, projectionBlock, projectionBlockIndex); return data; }
void TransformBlock::initialize() { transformBlockIndex = glGetUniformBlockIndex(shaderProgram, "TransformBlock"); glGetActiveUniformBlockiv(shaderProgram, transformBlockIndex, GL_UNIFORM_BLOCK_DATA_SIZE, &transformBlockSize); glUniformBlockBinding(shaderProgram, transformBlockIndex, transformBlockBindingPoint); GLuint uniformIndeces[3] = { 0 }; GLint uniformOffsets[3] = { 0 }; const GLchar * charStringNames[] = { "TransformBlock.modelMatrix", "TransformBlock.viewingMatrix", "TransformBlock.projectionMatrix", }; // Get the indeces of the uniforms. glGetUniformIndices(shaderProgram, 3, (const GLchar **)charStringNames, uniformIndeces); // Get the offsets of the uniforms glGetActiveUniformsiv(shaderProgram, 3, uniformIndeces, GL_UNIFORM_OFFSET, uniformOffsets); cout << "uniform transformblock" << endl; for (int i = 0; i < 3; i++) { cout << uniformOffsets[i] << endl; } modelMatrixLoc = uniformOffsets[0]; viewingMatrixLoc = uniformOffsets[1]; projectionMatrixLoc = uniformOffsets[2]; if (!bufferMade) { bufferMade = true; glGenBuffers(1, &transformBlockBuffer); cout << "TransformBlock Buffer ID " << transformBlockBuffer << endl; glBindBuffer(GL_UNIFORM_BUFFER, transformBlockBuffer); glBufferData(GL_UNIFORM_BUFFER, transformBlockSize, NULL, GL_DYNAMIC_DRAW); glBindBufferBase(GL_UNIFORM_BUFFER, transformBlockBindingPoint, transformBlockBuffer); } }