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