bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
static int FrameIndex = 0;
// Bind shared objects
glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y);
glBindSampler(0, SamplerName);
glBindVertexArray(VertexArrayName);
// Update a colorbuffer bound as a framebuffer attachement and as a texture
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
glBindProgramPipeline(PipelineName[pipeline::UPDATE]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, FrameIndex ? TextureName[texture::COLORBUFFER] : TextureName[texture::DIFFUSE]);
glMemoryBarrier(GL_TEXTURE_UPDATE_BARRIER_BIT | GL_TEXTURE_FETCH_BARRIER_BIT);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, VertexCount, 1, 0);
// Blit to framebuffer
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindProgramPipeline(PipelineName[pipeline::BLIT]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]);
glMemoryBarrier(GL_TEXTURE_UPDATE_BARRIER_BIT);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, VertexCount, 1, 0);
FrameIndex = (FrameIndex + 1) % 256;
return true;
}
void display()
{
glViewportIndexedf(0, 0, 0, float(Window.Size.x), float(Window.Size.y));
glDrawBuffer(GL_BACK);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.5f, 1.0f, 1.0f)[0]);
// Renderer to image
{
glDrawBuffer(GL_NONE);
glBindProgramPipeline(PipelineName[pipeline::SAVE]);
glBindImageTexture(glf::semantic::image::DIFFUSE, TextureName, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8);
glBindVertexArray(VertexArrayName);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 3, 1, 0);
}
// Read from image
{
GLint Border(8);
glEnable(GL_SCISSOR_TEST);
glScissorIndexed(0, Border, Border, Window.Size.x - 2 * Border, Window.Size.y - 2 * Border);
glDrawBuffer(GL_BACK);
glBindProgramPipeline(PipelineName[pipeline::READ]);
glBindImageTexture(glf::semantic::image::DIFFUSE, TextureName, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
glBindVertexArray(VertexArrayName);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 3, 1, 0);
glDisable(GL_SCISSOR_TEST);
}
glf::swapBuffers();
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y);
glDrawBuffer(GL_BACK);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.5f, 1.0f, 1.0f)[0]);
// Renderer to image
{
glDrawBuffer(GL_NONE);
glBindProgramPipeline(PipelineName[pipeline::SAVE]);
glBindImageTexture(semantic::image::DIFFUSE, TextureName, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8);
glBindVertexArray(VertexArrayName);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 3, 1, 0);
}
// Read from image
{
glDrawBuffer(GL_BACK);
glBindProgramPipeline(PipelineName[pipeline::READ]);
glBindImageTexture(semantic::image::DIFFUSE, TextureName, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8);
glBindVertexArray(VertexArrayName);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 3, 1, 0);
}
return true;
}
void resolveMultisampling()
{
glm::ivec2 WindowSize(this->getWindowSize());
glViewport(0, 0, WindowSize.x, WindowSize.y);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindTextures(0, 1, &TextureName[texture::MULTISAMPLE_COLORBUFFER]);
glBindVertexArray(VertexArrayName);
glBindBufferRange(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM], this->UniformBlockSize, this->UniformBlockSize);
glEnable(GL_SCISSOR_TEST);
// Box
{
glScissor(1, 1, WindowSize.x / 2 - 2, WindowSize.y - 2);
glBindProgramPipeline(PipelineName[program::RESOLVE_BOX]);
glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 5);
}
// Near
{
glScissor(WindowSize.x / 2 + 1, 1, WindowSize.x / 2 - 2, WindowSize.y - 2);
glBindProgramPipeline(PipelineName[program::RESOLVE_NEAR]);
glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 5);
}
glDisable(GL_SCISSOR_TEST);
}
GLint ComputeWaterSimulation::createShaderPipelineProgram(GLuint target, const char* src, GLuint &pipeline, GLuint &program)
{
GLint status;
glGenProgramPipelines(1, &pipeline);
program = glCreateShaderProgramv(target, 1, (const GLchar **)&src);
glBindProgramPipeline(pipeline);
glUseProgramStages(pipeline, GL_COMPUTE_SHADER_BIT, program);
glValidateProgramPipeline(pipeline);
glGetProgramPipelineiv(pipeline, GL_VALIDATE_STATUS, &status);
if (status != GL_TRUE)
{
GLint logLength;
glGetProgramPipelineiv(pipeline, GL_INFO_LOG_LENGTH, &logLength);
char *log = new char [logLength];
glGetProgramPipelineInfoLog(pipeline, logLength, 0, log);
LOGI("Shader pipeline not valid:\n%s\n", log);
delete [] log;
}
glBindProgramPipeline(0);
return status;
}
void ShaderState::initialize()
{
glGenProgramPipelines(1, &pipeline);
glBindProgramPipeline(pipeline);
glBindProgramPipeline(0);
//create a very basic shader program
std::vector<GLuint> shaderList;
std::string vertexShaderPath = "data/shaders/NoLighting.vert";
std::string fragShaderPath = "data/shaders/ColorPassthrough.frag";
shaderList.push_back(loadShader(GL_VERTEX_SHADER, vertexShaderPath));
shaderList.push_back(loadShader(GL_FRAGMENT_SHADER, fragShaderPath));
basicProgram = createProgram(shaderList);
std::string vertexShaderTessellationPath = "data/shaders/Tessellation.vert";
std::string tessControlPath = "data/shaders/TessControl.cont";
std::string tessEvalPath = "data/shaders/TessEval.eval";
shaderList.clear();
shaderList.push_back(loadShader(GL_VERTEX_SHADER, vertexShaderTessellationPath));
shaderList.push_back(loadShader(GL_TESS_CONTROL_SHADER, tessControlPath));
shaderList.push_back(loadShader(GL_TESS_EVALUATION_SHADER, tessEvalPath));
shaderList.push_back(loadShader(GL_FRAGMENT_SHADER, fragShaderPath));
tessellationProgram = createProgram(shaderList);
//glUseProgramStages(pipeline, GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, basicProgram);
}
bool initProgram()
{
bool Validated(true);
glGenProgramPipelines(1, &PipelineName);
glBindProgramPipeline(PipelineName);
if(Validated)
{
GLuint VertShaderName = glf::createShader(GL_VERTEX_SHADER, VERT_SHADER_SOURCE);
GLuint FragShaderName = glf::createShader(GL_FRAGMENT_SHADER, FRAG_SHADER_SOURCE);
ProgramName = glCreateProgram();
glProgramParameteri(ProgramName, GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName, VertShaderName);
glAttachShader(ProgramName, FragShaderName);
glDeleteShader(VertShaderName);
glDeleteShader(FragShaderName);
glLinkProgram(ProgramName);
Validated = glf::checkProgram(ProgramName);
}
if(Validated)
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName);
glBindProgramPipeline(0);
return Validated;
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y);
glBindVertexArray(this->VertexArrayName);
glBindSampler(0, this->SamplerName);
// Render
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]);
glBindProgramPipeline(PipelineName[pipeline::RENDER]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]);
glBindImageTexture(semantic::image::DIFFUSE, TextureName[texture::COLORBUFFER], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 3, 1, 0);
// Splash
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindProgramPipeline(PipelineName[pipeline::SPLASH]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 3, 1, 0);
return true;
}
bool initProgram()
{
bool Validated(true);
glGenProgramPipelines(1, &PipelineName);
glBindProgramPipeline(PipelineName);
if(Validated)
{
compiler Compiler;
GLuint VertShaderName = Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + VERT_SHADER_SOURCE, "--version 420 --profile core");
GLuint FragShaderName = Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + FRAG_SHADER_SOURCE, "--version 420 --profile core");
Validated = Validated && Compiler.check();
ProgramName = glCreateProgram();
glProgramParameteri(ProgramName, GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName, VertShaderName);
glAttachShader(ProgramName, FragShaderName);
glLinkProgram(ProgramName);
Validated = Validated && Compiler.checkProgram(ProgramName);
}
if(Validated)
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT, ProgramName);
glBindProgramPipeline(0);
return Validated;
}
bool initProgram()
{
bool Validated(true);
glGenProgramPipelines(pipeline::MAX, PipelineName);
glBindProgramPipeline(PipelineName[pipeline::READ]);
if(Validated)
{
std::string VertexSourceContent = glf::loadFile(glf::DATA_DIRECTORY + VERT_SHADER_SOURCE_READ);
char const * VertexSourcePointer = VertexSourceContent.c_str();
ProgramName[program::VERT] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &VertexSourcePointer);
Validated = Validated && glf::checkProgram(ProgramName[program::VERT]);
}
if(Validated)
{
std::string FragmentSourceContent = glf::loadFile(glf::DATA_DIRECTORY + FRAG_SHADER_SOURCE_READ);
char const * FragmentSourcePointer = FragmentSourceContent.c_str();
ProgramName[program::FRAG] = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &FragmentSourcePointer);
Validated = Validated && glf::checkProgram(ProgramName[program::FRAG]);
}
if(Validated)
{
glUseProgramStages(PipelineName[pipeline::READ], GL_VERTEX_SHADER_BIT, ProgramName[program::VERT]);
glUseProgramStages(PipelineName[pipeline::READ], GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG]);
Validated = Validated && glf::checkError("initProgram - stage");
}
glBindProgramPipeline(PipelineName[pipeline::SAVE]);
if(Validated)
{
std::string VertexSourceContent = glf::loadFile(glf::DATA_DIRECTORY + VERT_SHADER_SOURCE_SAVE);
char const * VertexSourcePointer = VertexSourceContent.c_str();
ProgramName[program::VERT] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &VertexSourcePointer);
Validated = Validated && glf::checkProgram(ProgramName[program::VERT]);
}
if(Validated)
{
std::string FragmentSourceContent = glf::loadFile(glf::DATA_DIRECTORY + FRAG_SHADER_SOURCE_SAVE);
char const * FragmentSourcePointer = FragmentSourceContent.c_str();
ProgramName[program::FRAG] = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &FragmentSourcePointer);
Validated = Validated && glf::checkProgram(ProgramName[program::FRAG]);
}
if(Validated)
{
glUseProgramStages(PipelineName[pipeline::SAVE], GL_VERTEX_SHADER_BIT, ProgramName[program::VERT]);
glUseProgramStages(PipelineName[pipeline::SAVE], GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG]);
Validated = Validated && glf::checkError("initProgram - stage");
}
return Validated;
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
this->Monitor->begin();
{
glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]);
glm::mat4* Pointer = (glm::mat4*)glMapBufferRange(
GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4),
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
*Pointer = Projection * this->view() * Model;
// Make sure the uniform buffer is uploaded
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y);
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
float Depth(1.0f);
glClearBufferfv(GL_DEPTH , 0, &Depth);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]);
// Bind rendering objects
glBindProgramPipeline(PipelineName[pipeline::TEXTURE]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]);
glBindVertexArray(VertexArrayName[pipeline::TEXTURE]);
glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 2, 0, 0);
glDisable(GL_DEPTH_TEST);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindProgramPipeline(PipelineName[pipeline::SPLASH]);
glActiveTexture(GL_TEXTURE0);
glBindVertexArray(VertexArrayName[pipeline::SPLASH]);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]);
glDrawArraysInstanced(GL_TRIANGLES, 0, 3, 1);
this->Monitor->end();
this->Monitor->log();
return true;
}
void display()
{
// Update of the uniform buffer
{
glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]);
glm::mat4* Pointer = (glm::mat4*)glMapBufferRange(
GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4),
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
glm::mat4 Projection = glm::perspectiveFov(45.f, 640.f, 480.f, 0.1f, 100.0f);
//glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y));
glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f));
glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f));
glm::mat4 Model = glm::mat4(1.0f);
*Pointer = Projection * View * Model;
// Make sure the uniform buffer is uploaded
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
glBindProgramPipeline(PipelineName[program::COMPUTE]);
glBindImageTexture(image::POSITION_INPUT, TextureName[texture::POSITION_INPUT], 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA32F);
glBindImageTexture(image::TEXCOORD_INPUT, TextureName[texture::TEXCOORD_INPUT], 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA32F);
glBindImageTexture(image::COLOR_INPUT, TextureName[texture::COLOR_INPUT], 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA32F);
glBindImageTexture(image::POSITION_OUTPUT, TextureName[texture::POSITION_OUTPUT], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
glBindImageTexture(image::TEXCOORD_OUTPUT, TextureName[texture::TEXCOORD_OUTPUT], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
glBindImageTexture(image::COLOR_OUTPUT, TextureName[texture::COLOR_OUTPUT], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32F);
glBindBufferBase(GL_UNIFORM_BUFFER, glf::semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
glDispatchCompute(GLuint(VertexCount), 1, 1);
glViewportIndexedf(0, 0, 0, GLfloat(Window.Size.x), GLfloat(Window.Size.y));
glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f)[0]);
glBindProgramPipeline(PipelineName[program::GRAPHICS]);
glActiveTexture(GL_TEXTURE0 + glf::semantic::sampling::SAMPLER_DIFFUSE);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]);
glActiveTexture(GL_TEXTURE0 + sampling::SAMPLER_POSITION);
glBindTexture(GL_TEXTURE_BUFFER, TextureName[texture::POSITION_OUTPUT]);
glActiveTexture(GL_TEXTURE0 + sampling::SAMPLER_TEXCOORD);
glBindTexture(GL_TEXTURE_BUFFER, TextureName[texture::TEXCOORD_OUTPUT]);
glActiveTexture(GL_TEXTURE0 + sampling::SAMPLER_COLOR);
glBindTexture(GL_TEXTURE_BUFFER, TextureName[texture::COLOR_OUTPUT]);
glBindVertexArray(VertexArrayName);
glBindBufferBase(GL_UNIFORM_BUFFER, glf::semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
glDrawElementsInstancedBaseVertexBaseInstance(
GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, GLF_BUFFER_OFFSET(0), 1, 0, 0);
glf::swapBuffers();
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]);
{
glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]);
glm::mat4* Pointer = (glm::mat4*)glMapBufferRange(
GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4),
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
glm::mat4 Projection = glm::ortho(0.f, 256.f, 0.f, 256.f, 0.f, 16.f);
glm::mat4 Model = glm::mat4(1.0f);
*Pointer = Projection * this->view() * Model;
// Make sure the uniform buffer is uploaded
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
glBindVertexArray(VertexArrayName);
glActiveTexture(GL_TEXTURE0);
glBindProgramPipeline(PipelineName[program::UINT]);
{
glViewportIndexedfv(0, &glm::vec4(Viewport[texture::RGBA8UI])[0]);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::RGBA8UI]);
glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 1, 0, 0);
}
glBindProgramPipeline(PipelineName[program::NORM]);
{
glViewportIndexedfv(0, &glm::vec4(Viewport[texture::RGBA32F])[0]);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::RGBA32F]);
glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 1, 0, 0);
glViewportIndexedfv(0, &glm::vec4(Viewport[texture::RGBA8])[0]);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::RGBA8]);
glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 1, 0, 0);
glViewportIndexedfv(0, &glm::vec4(Viewport[texture::RGBA8_SNORM])[0]);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::RGBA8_SNORM]);
glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 1, 0, 0);
}
return true;
}
bool initProgram()
{
bool Validated = true;
glGenProgramPipelines(1, &PipelineName);
glBindProgramPipeline(PipelineName);
glBindProgramPipeline(0);
if(Validated)
{
GLuint VertShaderName = glf::createShader(GL_VERTEX_SHADER, SAMPLE_VERT_SHADER);
GLuint ContShaderName = glf::createShader(GL_TESS_CONTROL_SHADER, SAMPLE_CONT_SHADER);
GLuint EvalShaderName = glf::createShader(GL_TESS_EVALUATION_SHADER, SAMPLE_EVAL_SHADER);
GLuint GeomShaderName = glf::createShader(GL_GEOMETRY_SHADER, SAMPLE_GEOM_SHADER);
GLuint FragShaderName = glf::createShader(GL_FRAGMENT_SHADER, SAMPLE_FRAG_SHADER);
ProgramName[program::VERT] = glCreateProgram();
ProgramName[program::FRAG] = glCreateProgram();
glProgramParameteri(ProgramName[program::VERT], GL_PROGRAM_SEPARABLE, GL_TRUE);
glProgramParameteri(ProgramName[program::FRAG], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::VERT], VertShaderName);
glAttachShader(ProgramName[program::VERT], ContShaderName);
glAttachShader(ProgramName[program::VERT], EvalShaderName);
glAttachShader(ProgramName[program::VERT], GeomShaderName);
glLinkProgram(ProgramName[program::VERT]);
glAttachShader(ProgramName[program::FRAG], FragShaderName);
glLinkProgram(ProgramName[program::FRAG]);
glDeleteShader(VertShaderName);
glDeleteShader(ContShaderName);
glDeleteShader(EvalShaderName);
glDeleteShader(GeomShaderName);
glDeleteShader(FragShaderName);
Validated = Validated && glf::checkProgram(ProgramName[program::VERT]);
Validated = Validated && glf::checkProgram(ProgramName[program::FRAG]);
}
if(Validated)
{
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT | GL_TESS_CONTROL_SHADER_BIT | GL_TESS_EVALUATION_SHADER_BIT | GL_GEOMETRY_SHADER_BIT, ProgramName[program::VERT]);
glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG]);
}
if(Validated)
{
UniformMVP = glGetUniformLocation(ProgramName[program::VERT], "MVP");
}
return Validated && glf::checkError("initProgram");
}
bool initProgram()
{
bool Validated = true;
glGenProgramPipelines(1, &PipelineName);
glBindProgramPipeline(PipelineName);
glBindProgramPipeline(0);
if(Validated)
{
GLuint VertShader = glf::createShader(GL_VERTEX_SHADER, SHADER_VERT_SOURCE);
ProgramName[program::VERTEX] = glCreateProgram();
glProgramParameteri(ProgramName[program::VERTEX], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::VERTEX], VertShader);
glDeleteShader(VertShader);
glLinkProgram(ProgramName[program::VERTEX]);
Validated = Validated && glf::checkProgram(ProgramName[program::VERTEX]);
}
if(Validated)
{
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT, ProgramName[program::VERTEX]);
Validated = Validated && glf::checkError("initProgram - stage");
}
if(Validated)
{
GLuint FragShader = glf::createShader(GL_FRAGMENT_SHADER, SHADER_FRAG_SOURCE);
ProgramName[program::FRAGMENT] = glCreateProgram();
glProgramParameteri(ProgramName[program::FRAGMENT], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[program::FRAGMENT], FragShader);
glDeleteShader(FragShader);
glLinkProgram(ProgramName[program::FRAGMENT]);
Validated = Validated && glf::checkProgram(ProgramName[program::FRAGMENT]);
}
if(Validated)
{
glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAGMENT]);
Validated = Validated && glf::checkError("initProgram - stage");
}
if(Validated)
{
UniformMVP = glGetUniformLocation(ProgramName[program::VERTEX], "MVP");
UniformDiffuse = glGetUniformLocation(ProgramName[program::FRAGMENT], "Diffuse");
}
return glf::checkError("initProgram");
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
{
glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]);
glm::mat4* Pointer = (glm::mat4*)glMapBufferRange(
GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4),
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
glm::mat4 Projection = glm::perspectiveFov(glm::pi<float>() * 0.25f, WindowSize.x, WindowSize.y, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
*Pointer = Projection * this->view() * Model;
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
// Clear
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName[framebuffer::CLEAR]);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]);
// Render
glViewportIndexedf(0, 0, 0, WindowSize.x * this->Supersampling, WindowSize.y * this->Supersampling);
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName[framebuffer::BLEND]);
glBindVertexArray(this->VertexArrayName[pipeline::RENDER]);
glBindProgramPipeline(PipelineName[pipeline::RENDER]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]);
glBindImageTexture(semantic::image::DIFFUSE, TextureName[texture::COLORBUFFER], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8);
glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, semantic::storage::VERTEX, BufferName[buffer::VERTEX]);
for (std::size_t i = 0; i < this->Viewports.size(); ++i)
{
glViewportIndexedfv(0, &this->Viewports[i][0]);
glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 1, 0, 0);
}
// Splash
glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindVertexArray(this->VertexArrayName[pipeline::SPLASH]);
glBindProgramPipeline(PipelineName[pipeline::SPLASH]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 3, 1, 0);
return true;
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
{
glm::mat4* Pointer = static_cast<glm::mat4*>(glMapNamedBufferRange(BufferName[buffer::TRANSFORM],
0, sizeof(glm::mat4), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT));
//glm::mat4 Projection = glm::perspectiveFov(glm::pi<float>() * 0.25f, 640.f, 480.f, 0.1f, 100.0f);
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
*Pointer = Projection * this->view() * Model;
// Make sure the uniform buffer is uploaded
glUnmapNamedBuffer(BufferName[buffer::TRANSFORM]);
}
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
glViewportIndexedf(0, 0, 0, WindowSize.x / 16.0f, WindowSize.y / 16.0f);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f)[0]);
// Bind rendering objects
glViewportIndexedf(0, 0, 0, WindowSize.x / 16.0f, WindowSize.y / 16.0f);
glBindProgramPipeline(PipelineName[pipeline::TEXTURE]);
glBindVertexArray(VertexArrayName[pipeline::TEXTURE]);
glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::MATERIAL, BufferName[buffer::MATERIAL0]);
//glSubpixelPrecisionBiasNV(-8, -8);
glEnable(GL_CONSERVATIVE_RASTERIZATION_NV);
glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 1, 0, 0);
glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::MATERIAL, BufferName[buffer::MATERIAL1]);
glDisable(GL_CONSERVATIVE_RASTERIZATION_NV);
glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 1, 0, 0);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y);
glBindProgramPipeline(PipelineName[pipeline::SPLASH]);
glBindVertexArray(VertexArrayName[pipeline::SPLASH]);
glBindTextureUnit(0, TextureName[texture::COLORBUFFER]);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 3, 1, 0);
return true;
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
{
glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]);
glm::mat4* Pointer = (glm::mat4*)glMapBufferRange(
GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4),
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
*Pointer = Projection * this->view() * Model;
// Make sure the uniform buffer is uploaded
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
glClearTexImage(TextureName[texture::COLORBUFFER], 0, GL_RGBA, GL_FLOAT, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]);
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
// Bind rendering objects
glBindProgramPipeline(PipelineName[pipeline::TEXTURE]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]);
glBindVertexArray(VertexArrayName[pipeline::TEXTURE]);
glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
for (std::size_t i = 0; i < this->Viewports.size(); ++i)
{
glViewportIndexedfv(0, &this->Viewports[i][0]);
glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 1, 0, 0);
glTextureBarrier();
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y);
glBindProgramPipeline(PipelineName[pipeline::SPLASH]);
glActiveTexture(GL_TEXTURE0);
glBindVertexArray(VertexArrayName[pipeline::SPLASH]);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 3, 1, 0);
return true;
}
bool initProgram()
{
bool Validated = true;
glGenProgramPipelines(1, &PipelineName);
glBindProgramPipeline(PipelineName);
glBindProgramPipeline(0);
// Create program
if(Validated)
{
GLuint VertShaderName = glf::createShader(GL_VERTEX_SHADER, glf::DATA_DIRECTORY + VERT_SHADER_SOURCE);
GLuint GeomShaderName = glf::createShader(GL_GEOMETRY_SHADER, glf::DATA_DIRECTORY + GEOM_SHADER_SOURCE);
GLuint FragShaderName = glf::createShader(GL_FRAGMENT_SHADER, glf::DATA_DIRECTORY + FRAG_SHADER_SOURCE);
ProgramName[program::VERT] = glCreateProgram();
ProgramName[program::FRAG] = glCreateProgram();
glAttachShader(ProgramName[program::VERT], VertShaderName);
glAttachShader(ProgramName[program::VERT], GeomShaderName);
glAttachShader(ProgramName[program::FRAG], FragShaderName);
glDeleteShader(VertShaderName);
glDeleteShader(GeomShaderName);
glDeleteShader(FragShaderName);
glProgramParameteri(ProgramName[program::VERT], GL_PROGRAM_SEPARABLE, GL_TRUE);
glProgramParameteri(ProgramName[program::FRAG], GL_PROGRAM_SEPARABLE, GL_TRUE);
glLinkProgram(ProgramName[program::VERT]);
glLinkProgram(ProgramName[program::FRAG]);
Validated = Validated && glf::checkProgram(ProgramName[program::VERT]);
Validated = Validated && glf::checkProgram(ProgramName[program::FRAG]);
}
if(Validated)
{
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT | GL_GEOMETRY_SHADER_BIT, ProgramName[program::VERT]);
glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG]);
}
// Get variables locations
if(Validated)
{
UniformMVP = glGetUniformLocation(ProgramName[program::VERT], "MVP");
UniformDiffuse = glGetUniformLocation(ProgramName[program::FRAG], "Diffuse");
}
return Validated && glf::checkError("initProgram");
}
bool initProgram()
{
bool Validated = true;
glGenProgramPipelines(1, &PipelineName);
glBindProgramPipeline(PipelineName);
glBindProgramPipeline(0);
// Create program
if(Validated)
{
compiler Compiler;
GLuint ShaderName[] = {
Compiler.create(GL_VERTEX_SHADER, getDataDirectory() + SAMPLE_VERT_SHADER, "--version 410 --profile core"),
Compiler.create(GL_TESS_CONTROL_SHADER, getDataDirectory() + SAMPLE_CONT_SHADER, "--version 410 --profile core"),
Compiler.create(GL_TESS_EVALUATION_SHADER, getDataDirectory() + SAMPLE_EVAL_SHADER, "--version 410 --profile core"),
Compiler.create(GL_GEOMETRY_SHADER, getDataDirectory() + SAMPLE_GEOM_SHADER, "--version 410 --profile core"),
Compiler.create(GL_FRAGMENT_SHADER, getDataDirectory() + SAMPLE_FRAG_SHADER, "--version 410 --profile core")} ;
Validated = Validated && Compiler.check();
for(std::size_t i = 0; i < program::MAX; ++i)
{
ProgramName[i] = glCreateProgram();
glProgramParameteri(ProgramName[i], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[i], ShaderName[i]);
glLinkProgram(ProgramName[i]);
}
for(std::size_t i = 0; i < program::MAX; ++i)
Validated = Validated && Compiler.checkProgram(ProgramName[i]);
}
if(Validated)
{
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT, ProgramName[program::VERT]);
glUseProgramStages(PipelineName, GL_TESS_CONTROL_SHADER_BIT, ProgramName[program::CONT]);
glUseProgramStages(PipelineName, GL_TESS_EVALUATION_SHADER_BIT, ProgramName[program::EVAL]);
glUseProgramStages(PipelineName, GL_GEOMETRY_SHADER_BIT, ProgramName[program::GEOM]);
glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG]);
}
// Get variables locations
if(Validated)
{
UniformMVP = glGetUniformLocation(ProgramName[program::VERT], "MVP");
}
return Validated && this->checkError("initProgram");
}
bool initProgram()
{
bool Validated = true;
glGenProgramPipelines(1, &PipelineName);
glBindProgramPipeline(PipelineName);
glBindProgramPipeline(0);
// Create program
if(Validated)
{
GLuint ShaderName[] = {
glf::createShader(GL_VERTEX_SHADER, SAMPLE_VERT_SHADER),
glf::createShader(GL_TESS_CONTROL_SHADER, SAMPLE_CONT_SHADER),
glf::createShader(GL_TESS_EVALUATION_SHADER, SAMPLE_EVAL_SHADER),
glf::createShader(GL_GEOMETRY_SHADER, SAMPLE_GEOM_SHADER),
glf::createShader(GL_FRAGMENT_SHADER, SAMPLE_FRAG_SHADER)};
for(std::size_t i = 0; i < program::MAX; ++i)
{
ProgramName[i] = glCreateProgram();
glProgramParameteri(ProgramName[i], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(ProgramName[i], ShaderName[i]);
glDeleteShader(ShaderName[i]);
glLinkProgram(ProgramName[i]);
}
for(std::size_t i = 0; i < program::MAX; ++i)
Validated = Validated && glf::checkProgram(ProgramName[i]);
}
if(Validated)
{
glUseProgramStages(PipelineName, GL_VERTEX_SHADER_BIT, ProgramName[program::VERT]);
glUseProgramStages(PipelineName, GL_TESS_CONTROL_SHADER_BIT, ProgramName[program::CONT]);
glUseProgramStages(PipelineName, GL_TESS_EVALUATION_SHADER_BIT, ProgramName[program::EVAL]);
glUseProgramStages(PipelineName, GL_GEOMETRY_SHADER_BIT, ProgramName[program::GEOM]);
glUseProgramStages(PipelineName, GL_FRAGMENT_SHADER_BIT, ProgramName[program::FRAG]);
}
// Get variables locations
if(Validated)
{
UniformMVP = glGetUniformLocation(ProgramName[program::VERT], "MVP");
}
return Validated && glf::checkError("initProgram");
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
{
glm::mat4* Pointer = reinterpret_cast<glm::mat4*>(glMapNamedBufferRange(BufferName[buffer::TRANSFORM],
0, sizeof(glm::mat4), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT));
//glm::mat4 Projection = glm::perspectiveFov(glm::pi<float>() * 0.25f, 640.f, 480.f, 0.1f, 100.0f);
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
*Pointer = Projection * this->view() * Model;
// Make sure the uniform buffer is uploaded
glUnmapNamedBuffer(BufferName[buffer::TRANSFORM]);
}
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glClearTexImage(TextureName[texture::COLORBUFFER], 0, GL_RGBA, GL_UNSIGNED_BYTE, &glm::u8vec4(255, 255, 255, 255)[0]);
glClearTexImage(TextureName[texture::RENDERBUFFER], 0, GL_DEPTH_COMPONENT, GL_FLOAT, &glm::vec1(1.0)[0]);
glClearTexImage(TextureName[texture::INVOCATION_COUNT], 0, GL_RED_INTEGER, GL_UNSIGNED_INT, &glm::u32vec1(0)[0]);
glViewportIndexedf(0, 0, 0, WindowSize.x * FRAMEBUFFER_SCALE, WindowSize.y * FRAMEBUFFER_SCALE);
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
glBindProgramPipeline(PipelineName[pipeline::TEXTURE]);
glBindVertexArray(VertexArrayName[pipeline::TEXTURE]);
glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
glBindImageTexture(0, TextureName[texture::INVOCATION_COUNT], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_R32UI);
glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 5, 0, 0);
glDisable(GL_DEPTH_TEST);
glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindProgramPipeline(PipelineName[pipeline::SPLASH]);
glBindVertexArray(VertexArrayName[pipeline::SPLASH]);
glBindImageTexture(0, TextureName[texture::INVOCATION_COUNT], 0, GL_FALSE, 0, GL_READ_ONLY, GL_R32UI);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 3, 1, 0);
return true;
}
device_t device_create(struct gs_init_data *info)
{
struct gs_device *device = bmalloc(sizeof(struct gs_device));
memset(device, 0, sizeof(struct gs_device));
device->plat = gl_platform_create(device, info);
if (!device->plat)
goto fail;
if (!gl_init_extensions(device))
goto fail;
gl_enable(GL_CULL_FACE);
glGenProgramPipelines(1, &device->pipeline);
if (!gl_success("glGenProgramPipelines"))
goto fail;
glBindProgramPipeline(device->pipeline);
if (!gl_success("glBindProgramPipeline"))
goto fail;
device_leavecontext(device);
device->cur_swap = gl_platform_getswap(device->plat);
return device;
fail:
blog(LOG_ERROR, "device_create (GL) failed");
bfree(device);
return NULL;
}
void
piglit_init(int argc, char **argv)
{
GLuint pipe = 0;
unsigned glsl_version;
piglit_require_vertex_shader();
piglit_require_fragment_shader();
piglit_require_extension("GL_ARB_separate_shader_objects");
piglit_require_extension("GL_ARB_explicit_attrib_location");
glsl_version = pick_a_glsl_version();
vs = generate_program(vs_template, glsl_version, GL_VERTEX_SHADER,
&loc_vs);
fs = generate_program(fs_template, glsl_version, GL_FRAGMENT_SHADER,
&loc_fs);
if (vs == 0 || fs == 0)
piglit_report_result(PIGLIT_FAIL);
glGenProgramPipelines(1, &pipe);
glBindProgramPipeline(pipe);
glUseProgramStages(pipe, GL_VERTEX_SHADER_BIT, vs);
glUseProgramStages(pipe, GL_FRAGMENT_SHADER_BIT, fs);
if (!piglit_check_gl_error(0))
piglit_report_result(PIGLIT_FAIL);
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
{
glm::mat4 ProjectionA = glm::scale(glm::perspective(glm::pi<float>() * 0.25f, float(FRAMEBUFFER_SIZE.x) / FRAMEBUFFER_SIZE.y, 0.1f, 100.0f), glm::vec3(1, -1, 1));
*reinterpret_cast<glm::mat4*>(this->UniformPointer + 0) = ProjectionA * this->view() * glm::mat4(1);
glm::mat4 ProjectionB = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f);
*reinterpret_cast<glm::mat4*>(this->UniformPointer + this->UniformBlockSize) = ProjectionB * this->view() * glm::scale(glm::mat4(1), glm::vec3(2));
}
// Step 1, render the scene in a multisampled framebuffer
glBindProgramPipeline(PipelineName);
renderFBO();
// Step 2: blit
glBlitNamedFramebuffer(FramebufferName[framebuffer::RENDER], FramebufferName[framebuffer::RESOLVE],
0, 0, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y,
0, 0, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y,
GL_COLOR_BUFFER_BIT, GL_NEAREST);
GLenum MaxColorAttachment = GL_COLOR_ATTACHMENT0;
glInvalidateNamedFramebufferData(FramebufferName[framebuffer::RENDER], 1, &MaxColorAttachment);
// Step 3, render the colorbuffer from the multisampled framebuffer
renderFB();
return true;
}
void display()
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y));
glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f));
glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f));
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * View * Model;
glProgramUniformMatrix4fv(ProgramName[program::VERT], UniformMVP, 1, GL_FALSE, &MVP[0][0]);
glViewportIndexedfv(0, &glm::vec4(0, 0, Window.Size)[0]);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f)[0]);
glBindProgramPipeline(PipelineName);
glBindVertexArray(VertexArrayName);
glPatchParameteri(GL_PATCH_VERTICES, VertexCount);
glDrawArraysInstanced(GL_PATCHES, 0, VertexCount, 1);
glf::checkError("display");
glf::swapBuffers();
}
static void
realize(GtkWidget *widget, gpointer user_data)
{
gtk_gl_area_make_current(GTK_GL_AREA(widget));
glDebugMessageCallback(debug, NULL);
char *str = pk_io_read_file("data/vs.glsl");
programs[0] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1, &str);
free(str);
str = pk_io_read_file("data/fs.glsl");
programs[1] = glCreateShaderProgramv(GL_FRAGMENT_SHADER, 1, &str);
free(str);
/* set up pipeline for rendering fullscreen quad */
glCreateProgramPipelines(1, &pipeline);
glUseProgramStages(pipeline, GL_VERTEX_SHADER_BIT, programs[0]);
glUseProgramStages(pipeline, GL_FRAGMENT_SHADER_BIT, programs[1]);
glBindProgramPipeline(pipeline);
glCreateVertexArrays(1, &vao);
glBindVertexArray(vao);
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
{
glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]);
glm::mat4* Pointer = (glm::mat4*)glMapBufferRange(
GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4),
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
*Pointer = Projection * this->view() * Model;
}
glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]);
// Bind rendering objects
glBindProgramPipeline(PipelineName);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName);
glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
glBindVertexArray(VertexArrayName);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, BufferName[buffer::ELEMENT]);
// Make sure the uniform buffer is uploaded
glUnmapBuffer(GL_UNIFORM_BUFFER);
glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 1, 0, 0);
return true;
}
void GraphicsPipeline::bind() const
{
// bind shader programs
assert(glIsProgram(mProgId));
assert(glIsProgramPipeline(mPipeId));
glBindProgramPipeline(mPipeId);
}
void display()
{
// Update of the uniform buffer
{
glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]);
glm::mat4* Pointer = (glm::mat4*)glMapBufferRange(
GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4),
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
glm::mat4 Projection = glm::perspectiveFov(45.f, 640.f, 480.f, 0.1f, 100.0f);
//glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y));
glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f));
glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f));
glm::mat4 Model = glm::mat4(1.0f);
*Pointer = Projection * View * Model;
// Make sure the uniform buffer is uploaded
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
glViewportIndexedf(0, 0, 0, float(Window.Size.x), float(Window.Size.y));
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]);
glBindProgramPipeline(PipelineName);
glBindBufferBase(GL_UNIFORM_BUFFER, glf::semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
glBindVertexArray(VertexArrayName);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, BufferName[buffer::VERTEX]);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 6, 1, 0);
glf::swapBuffers();
}
