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