void Sprite::setShaderProgram(ShaderProgram* shader_program) { Drawable::setShaderProgram(shader_program); glBindVertexArray(s_VAO); glBindBuffer(GL_ARRAY_BUFFER, s_VBO); p_position_loc = shaderProgram()->bindVertexAttribute("position", 2, 3*sizeof(float), 0); p_texture_coord_loc = shaderProgram()->bindVertexAttribute("point_id", 1, 3*sizeof(float), (void *)(2 * sizeof(float))); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); }
void initShader_texture ( ) { static bool uninitialized = true; if (uninitialized) { shaders[shader_texture] = shaderProgram( "src/shaders/texture_vertex.glsl", "src/shaders/texture_fragment.glsl" ); if (shaders[shader_texture] == 0) { fprintf(stderr,"Texture Shader Error\n"); exit(EXIT_FAILURE); } currentShader(shaders[shader_texture]); shaderPositions[shader_texture] = glGetAttribLocation( shaders[shader_texture],"position"); shaderColors[shader_texture] = glGetAttribLocation( shaders[shader_texture],"color"); CTvTexture = glGetAttribLocation( shaders[shader_texture],"texture_coordinate"); CTtexture = glGetUniformLocation(shaders[shader_texture],"texture_map"); shaderModels[shader_texture] = glGetUniformLocation(shaders[shader_texture],"model"); shaderViews[shader_texture] = glGetUniformLocation(shaders[shader_texture],"view"); shaderProjections[shader_texture] = glGetUniformLocation(shaders[shader_texture],"projection"); glUniformMatrix4fv(shaderModels[shader_texture] ,1,GL_FALSE,glm::value_ptr(glm::mat4())); glUniformMatrix4fv(shaderViews[shader_texture] ,1,GL_FALSE,glm::value_ptr(glm::mat4())); glUniformMatrix4fv(shaderProjections[shader_texture],1,GL_FALSE,glm::value_ptr(glm::mat4())); glUniform1i(CTtexture,0); } else { currentShader(0); glDeleteProgram(shaders[shader_texture]); } uninitialized = not uninitialized; }
void Rectangle::setShaderProgram(ShaderProgram* shader_program) { Drawable::setShaderProgram(shader_program); glBindVertexArray(p_VAO); glBindBuffer(GL_ARRAY_BUFFER, p_VBO); p_position_loc = shaderProgram()->bindVertexAttribute("position", 2, 0, 0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); }
void initialize() { glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); GLuint vao; glGenVertexArrays(1, &vao); glBindVertexArray(vao); GLuint vbo; glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); std::string vertexShaderSource; if (!contentsOfFile("vertex.glsl", vertexShaderSource)) { exit(1); } std::string fragmentShaderSource; if (!contentsOfFile("fragment.glsl", fragmentShaderSource)) { exit(1); } Shader vertexShader(GL_VERTEX_SHADER); if (!vertexShader.compile(vertexShaderSource)) { debugPrint("Failed to compile vertex shader: %s", vertexShader.getCompileStatus().c_str()); exit(1); } Shader fragmentShader(GL_FRAGMENT_SHADER); if (!fragmentShader.compile(fragmentShaderSource)) { debugPrint("Failed to compile fragment shader: %s", fragmentShader.getCompileStatus().c_str()); exit(1); } Program shaderProgram(vertexShader, fragmentShader); if (!shaderProgram.link()) { debugPrint("Failed to link shader program: %s", shaderProgram.getLinkStatus().c_str()); exit(1); } GLuint programID = shaderProgram.getGLID(); glUseProgram(programID); GLint posAttrib = glGetAttribLocation(programID, "position"); glVertexAttribPointer(posAttrib, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), 0); GLint colorAttrib = glGetAttribLocation(programID, "color"); glEnableVertexAttribArray(colorAttrib); glVertexAttribPointer(colorAttrib, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(2 * sizeof(float))); glEnableVertexAttribArray(posAttrib); ball.setLeftPlayer(&leftPlayer); ball.setRightPlayer(&rightPlayer); }
void Sprite::draw() { sf::Texture::bind(p_texture, sf::Texture::Normalized); glBindVertexArray(s_VAO); shaderProgram()->setUniform4f("texture_coords", static_cast<float>(p_rect.left)/static_cast<float>(p_texture->getSize().x), static_cast<float>(p_rect.top)/static_cast<float>(p_texture->getSize().y), static_cast<float>(p_rect.width)/static_cast<float>(p_texture->getSize().x), static_cast<float>(p_rect.height)/static_cast<float>(p_texture->getSize().y)); shaderProgram()->setUniform4f("color", static_cast<float>(p_color.r)/255.0f, static_cast<float>(p_color.g)/255.0f, static_cast<float>(p_color.b)/255.0f, static_cast<float>(p_color.a)/255.0f); glEnableVertexAttribArray(p_position_loc); glEnableVertexAttribArray(p_texture_coord_loc); glDrawArrays(GL_TRIANGLES, 0, 6); sf::Texture::bind(NULL); }
void Rectangle::draw() { glBindVertexArray(p_VAO); shaderProgram()->setUniform4f("color", static_cast<float>(p_color.r)/255.0f, static_cast<float>(p_color.g)/255.0f, static_cast<float>(p_color.b)/255.0f, static_cast<float>(p_color.a)/255.0f); glEnableVertexAttribArray(p_position_loc); glDrawArrays(GL_TRIANGLES, 0, 6); }
void Model::draw(Camera * camera) { shaderProgram()->setUniformMatrix4fv("projection", camera->projectionMatrix()); shaderProgram()->setUniformMatrix4fv("view", camera->transformationMatrix()); shaderProgram()->setUniformMatrix4fv("model", transformationMatrix()); bindTextures(); shaderProgram()->use(); if (isWireframeMode()) { // wireframe mode glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); } glBindVertexArray ( m_vaoId ); if (geometry()->isExist("index")) { GeometryBuffer *indices = geometry()->get("index"); indices->bind(); glDrawElements(GL_TRIANGLES, indices->size(), GL_UNSIGNED_INT, 0); } else { glDrawArrays ( GL_TRIANGLES, 0, geometry()->get("vertex")->size() ); } glBindVertexArray ( 0 ); if (isWireframeMode()) { // wireframe mode glPolygonMode( GL_FRONT_AND_BACK, GL_FILL ); } shaderProgram()->disable(); unbindTextures(); }
void Model::bindTextures() { std::string textureName = "texture"; for (GLuint i = 0; i < textures()->size(); i++) { glActiveTexture( GL_TEXTURE0 + i ); Texture * texture = textures()->texture(i); if ( texture != nullptr ) { glBindTexture(GL_TEXTURE_2D, texture->getId() ); shaderProgram()->setUniform1i( textureName + patch::to_string(i), i ); } } }
void HUDRenderer::render(const PlayerLogicComponent &playerLogic, int width, int height) { ASSERT(width > 0 && height > 0, "Width and height must be positive"); for (HUDElement &element : elements) { element.update(playerLogic); textureMaterial->setTexture(element.texture); SPtr<ShaderProgram> shaderProgram(xyPlane->getShaderProgram()); shaderProgram->setUniformValue("uOpacity", element.opacity); shaderProgram->setUniformValue("uFill", element.fill); shaderProgram->setUniformValue("uTint", element.tint); glm::mat4 scale(glm::scale(glm::vec3(element.scale.x, element.scale.y, 1.0f) / 100.0f)); glm::mat4 ratio(glm::scale(glm::vec3((float)height / width, 1.0f, 1.0f))); glm::mat4 translate(glm::translate(glm::vec3((element.position.x / 50.0f) - 1.0f, (element.position.y / 50.0f) - 1.0f, 0.0f))); glm::mat4 transform = translate * ratio * scale; shaderProgram->setUniformValue("uTransform", transform); RenderData renderData; xyPlane->draw(renderData); } }
// The address returned here will only be valid until next time this function is called. // The program is return bound. QGLEngineShaderProg *QGLEngineSharedShaders::findProgramInCache(const QGLEngineShaderProg &prog) { for (int i = 0; i < cachedPrograms.size(); ++i) { QGLEngineShaderProg *cachedProg = cachedPrograms[i]; if (*cachedProg == prog) { // Move the program to the top of the list as a poor-man's cache algo cachedPrograms.move(i, 0); cachedProg->program->bind(); return cachedProg; } } QScopedPointer<QGLEngineShaderProg> newProg; do { QByteArray fragSource; // Insert the custom stage before the srcPixel shader to work around an ATI driver bug // where you cannot forward declare a function that takes a sampler as argument. if (prog.srcPixelFragShader == CustomImageSrcFragmentShader) fragSource.append(prog.customStageSource); fragSource.append(qShaderSnippets[prog.mainFragShader]); fragSource.append(qShaderSnippets[prog.srcPixelFragShader]); if (prog.compositionFragShader) fragSource.append(qShaderSnippets[prog.compositionFragShader]); if (prog.maskFragShader) fragSource.append(qShaderSnippets[prog.maskFragShader]); QByteArray vertexSource; vertexSource.append(qShaderSnippets[prog.mainVertexShader]); vertexSource.append(qShaderSnippets[prog.positionVertexShader]); QScopedPointer<QGLShaderProgram> shaderProgram(new QGLShaderProgram); CachedShader shaderCache(fragSource, vertexSource); bool inCache = shaderCache.load(shaderProgram.data(), QGLContext::currentContext()); if (!inCache) { QScopedPointer<QGLShader> fragShader(new QGLShader(QGLShader::Fragment)); QByteArray description; #if defined(QT_DEBUG) // Name the shader for easier debugging description.append("Fragment shader: main="); description.append(snippetNameStr(prog.mainFragShader)); description.append(", srcPixel="); description.append(snippetNameStr(prog.srcPixelFragShader)); if (prog.compositionFragShader) { description.append(", composition="); description.append(snippetNameStr(prog.compositionFragShader)); } if (prog.maskFragShader) { description.append(", mask="); description.append(snippetNameStr(prog.maskFragShader)); } fragShader->setObjectName(QString::fromLatin1(description)); #endif if (!fragShader->compileSourceCode(fragSource)) { qWarning() << "Warning:" << description << "failed to compile!"; break; } QScopedPointer<QGLShader> vertexShader(new QGLShader(QGLShader::Vertex)); #if defined(QT_DEBUG) // Name the shader for easier debugging description.clear(); description.append("Vertex shader: main="); description.append(snippetNameStr(prog.mainVertexShader)); description.append(", position="); description.append(snippetNameStr(prog.positionVertexShader)); vertexShader->setObjectName(QString::fromLatin1(description)); #endif if (!vertexShader->compileSourceCode(vertexSource)) { qWarning() << "Warning:" << description << "failed to compile!"; break; } shaders.append(vertexShader.data()); shaders.append(fragShader.data()); shaderProgram->addShader(vertexShader.take()); shaderProgram->addShader(fragShader.take()); // We have to bind the vertex attribute names before the program is linked: shaderProgram->bindAttributeLocation("vertexCoordsArray", QT_VERTEX_COORDS_ATTR); if (prog.useTextureCoords) shaderProgram->bindAttributeLocation("textureCoordArray", QT_TEXTURE_COORDS_ATTR); if (prog.useOpacityAttribute) shaderProgram->bindAttributeLocation("opacityArray", QT_OPACITY_ATTR); if (prog.usePmvMatrixAttribute) { shaderProgram->bindAttributeLocation("pmvMatrix1", QT_PMV_MATRIX_1_ATTR); shaderProgram->bindAttributeLocation("pmvMatrix2", QT_PMV_MATRIX_2_ATTR); shaderProgram->bindAttributeLocation("pmvMatrix3", QT_PMV_MATRIX_3_ATTR); } } newProg.reset(new QGLEngineShaderProg(prog)); newProg->program = shaderProgram.take(); newProg->program->link(); if (newProg->program->isLinked()) { if (!inCache) shaderCache.store(newProg->program, QGLContext::currentContext()); } else { QLatin1String none("none"); QLatin1String br("\n"); QString error; error = QLatin1String("Shader program failed to link,"); #if defined(QT_DEBUG) error += QLatin1String("\n Shaders Used:\n"); for (int i = 0; i < newProg->program->shaders().count(); ++i) { QGLShader *shader = newProg->program->shaders().at(i); error += QLatin1String(" ") + shader->objectName() + QLatin1String(": \n") + QLatin1String(shader->sourceCode()) + br; } #endif error += QLatin1String(" Error Log:\n") + QLatin1String(" ") + newProg->program->log(); qWarning() << error; break; } newProg->program->bind(); if (newProg->maskFragShader != QGLEngineSharedShaders::NoMaskFragmentShader) { GLuint location = newProg->program->uniformLocation("maskTexture"); newProg->program->setUniformValue(location, QT_MASK_TEXTURE_UNIT); } if (cachedPrograms.count() > 30) { // The cache is full, so delete the last 5 programs in the list. // These programs will be least used, as a program us bumped to // the top of the list when it's used. for (int i = 0; i < 5; ++i) { delete cachedPrograms.last(); cachedPrograms.removeLast(); } } cachedPrograms.insert(0, newProg.data()); } while (false); return newProg.take(); }
int main() { glfwInit(); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); GLFWwindow* window = glfwCreateWindow(800, 600, "Learn OpenGL", nullptr, nullptr); if (window == nullptr) { std::cerr << "Failed to create GLFW window" << std::endl; glfwTerminate(); return -1; } glfwMakeContextCurrent(window); glewExperimental = GL_TRUE; if (glewInit() != GLEW_OK) { std::cerr << "Failed to initialize GLEW" << std::endl; return -1; } // Set up OpenGL to draw a triangle glViewport(0, 0, 800, 600); Shader shaderProgram("shaders/transform.vs", "shaders/textured.frag"); GLfloat vertices[] = { 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, // top right 0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, // bottom right -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, // bottom left -0.5f, 0.5f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f // top left }; GLuint indices[] = { 0, 1, 3, // First triangle 1, 2, 3 // Second triangle }; GLuint VBO; glGenBuffers(1, &VBO); GLuint EBO; glGenBuffers(1, &EBO); GLuint VAO; glGenVertexArrays(1, &VAO); glBindVertexArray(VAO); glBindBuffer(GL_ARRAY_BUFFER, VBO); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)0); glEnableVertexAttribArray(0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat))); glEnableVertexAttribArray(1); glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (GLvoid*)(6 * sizeof(GLfloat))); glEnableVertexAttribArray(2); glBindVertexArray(0); Texture texture1("textures/container.jpg"); Texture texture2("textures/awesomeface.png"); glfwSetKeyCallback(window, key_callback); while(!glfwWindowShouldClose(window)) { glfwPollEvents(); glClearColor(0.2f, 0.3f, 0.3f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); GLuint transformLoc = shaderProgram.UniformLocation("transform"); shaderProgram.Use(); glUniform1f(shaderProgram.UniformLocation("faceVisibility"), g_visibility); // Bind textures using texture units glActiveTexture(GL_TEXTURE0); texture1.Bind(); glUniform1i(shaderProgram.UniformLocation("ourTexture1"), 0); glActiveTexture(GL_TEXTURE1); texture2.Bind(); glUniform1i(shaderProgram.UniformLocation("ourTexture2"), 1); glBindVertexArray(VAO); glm::mat4 trans; trans = glm::translate(trans, glm::vec3(0.5f, -0.5f, 0.0f)); trans = glm::rotate(trans, glm::radians((GLfloat)glfwGetTime() * 50.0f), glm::vec3(0.0, 0.0, 1.0)); glUniformMatrix4fv(transformLoc, 1, GL_FALSE, glm::value_ptr(trans)); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); glm::mat4 trans2; GLfloat scaleValue = sin((GLfloat)glfwGetTime()); trans2 = glm::translate(trans2, glm::vec3(-0.5f, 0.5f, 0.0f)); trans2 = glm::scale(trans2, glm::vec3(scaleValue, scaleValue, scaleValue)); glUniformMatrix4fv(transformLoc, 1, GL_FALSE, glm::value_ptr(trans2)); glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); glBindVertexArray(0); glfwSwapBuffers(window); } glfwTerminate(); return 0; }
int main() { DEBUGLOG->setAutoPrint(true); ////////////////////////////////////////////////////////////////////////////// /////////////////////// INIT ////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// // create window and opengl context auto window = generateWindow(800,800); ////////////////////////////////////////////////////////////////////////////// /////////////////////////////// RENDERING /////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// ///////////////////// Scene / View Settings ////////////////////////// glm::mat4 model = glm::mat4(1.0f); glm::vec4 eye(0.0f, 0.0f, 3.0f, 1.0f); glm::vec4 center(0.0f,0.0f,0.0f,1.0f); glm::mat4 view = glm::lookAt(glm::vec3(eye), glm::vec3(center), glm::vec3(0,1,0)); // glm::mat4 perspective = glm::ortho(-2.0f, 2.0f, -2.0f, 2.0f, -1.0f, 6.0f); /// perspective projection is experimental; yields weird warping effects due to vertex interpolation of uv-coordinates glm::mat4 perspective = glm::perspective(glm::radians(65.f), getRatio(window), 0.1f, 10.f); // create object // Sphere grid; Grid grid(10,10,0.1f,0.1f,true); // Volume grid; // load grass texture s_texHandle = TextureTools::loadTexture(RESOURCES_PATH + std::string( "/grass.png")); glBindTexture(GL_TEXTURE_2D, s_texHandle); /////////////////////// Renderpass /////////////////////////// DEBUGLOG->log("Shader Compilation: volume uvw coords"); DEBUGLOG->indent(); ShaderProgram shaderProgram("/modelSpace/GBuffer.vert", "/modelSpace/GBuffer.frag"); DEBUGLOG->outdent(); shaderProgram.update("model", model); shaderProgram.update("view", view); shaderProgram.update("projection", perspective); shaderProgram.update("color", glm::vec4(1.0f,0.0f,0.0f,1.0f)); DEBUGLOG->log("FrameBufferObject Creation: volume uvw coords"); DEBUGLOG->indent(); FrameBufferObject fbo(getResolution(window).x, getResolution(window).y); FrameBufferObject::s_internalFormat = GL_RGBA32F; // to allow arbitrary values in G-Buffer fbo.addColorAttachments(4); DEBUGLOG->outdent(); // G-Buffer FrameBufferObject::s_internalFormat = GL_RGBA; // restore default RenderPass renderPass(&shaderProgram, &fbo); renderPass.addEnable(GL_DEPTH_TEST); renderPass.addClearBit(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); renderPass.addRenderable(&grid); ShaderProgram compShader("/screenSpace/fullscreen.vert", "/screenSpace/finalCompositing.frag"); // ShaderProgram compShader("/screenSpace/fullscreen.vert", "/screenSpace/simpleAlphaTexture.frag"); Quad quad; RenderPass compositing(&compShader, 0); compositing.addClearBit(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); compositing.addRenderable(&quad); // Geometry test shader ShaderProgram geomShader("/modelSpace/geometry.vert", "/modelSpace/simpleLighting.frag", "/geometry/simpleGeom.geom"); RenderPass geom(&geomShader, 0); geom.addClearBit(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT); geom.addRenderable(&grid); geom.addEnable(GL_DEPTH_TEST); geom.addEnable(GL_ALPHA_TEST); geom.addEnable(GL_BLEND); glAlphaFunc(GL_GREATER, 0); geomShader.update("projection", perspective); ////////////////////////////////////////////////////////////////////////////// /////////////////////// GUI / USER INPUT //////////////////////////////// ////////////////////////////////////////////////////////////////////////////// // Setup ImGui binding ImGui_ImplGlfwGL3_Init(window, true); Turntable turntable; double old_x; double old_y; glfwGetCursorPos(window, &old_x, &old_y); auto cursorPosCB = [&](double x, double y) { ImGuiIO& io = ImGui::GetIO(); if ( io.WantCaptureMouse ) { return; } // ImGUI is handling this double d_x = x - old_x; double d_y = y - old_y; if ( turntable.getDragActive() ) { turntable.dragBy(d_x, d_y, view); } old_x = x; old_y = y; }; auto mouseButtonCB = [&](int b, int a, int m) { if (b == GLFW_MOUSE_BUTTON_LEFT && a == GLFW_PRESS) { turntable.setDragActive(true); } if (b == GLFW_MOUSE_BUTTON_LEFT && a == GLFW_RELEASE) { turntable.setDragActive(false); } ImGui_ImplGlfwGL3_MouseButtonCallback(window, b, a, m); }; auto keyboardCB = [&](int k, int s, int a, int m) { if (a == GLFW_RELEASE) {return;} switch (k) { case GLFW_KEY_W: eye += glm::inverse(view) * glm::vec4(0.0f,0.0f,-0.1f,0.0f); center += glm::inverse(view) * glm::vec4(0.0f,0.0f,-0.1f,0.0f); break; case GLFW_KEY_A: eye += glm::inverse(view) * glm::vec4(-0.1f,0.0f,0.0f,0.0f); center += glm::inverse(view) * glm::vec4(-0.1f,0.0f,0.0f,0.0f); break; case GLFW_KEY_S: eye += glm::inverse(view) * glm::vec4(0.0f,0.0f,0.1f,0.0f); center += glm::inverse(view) * glm::vec4(0.0f,0.0f,0.1f,0.0f); break; case GLFW_KEY_D: eye += glm::inverse(view) * glm::vec4(0.1f,0.0f,0.0f,0.0f); center += glm::inverse(view) * glm::vec4(0.1f,0.0f,0.0f,0.0f); break; default: break; } ImGui_ImplGlfwGL3_KeyCallback(window,k,s,a,m); }; setCursorPosCallback(window, cursorPosCB); setMouseButtonCallback(window, mouseButtonCB); setKeyCallback(window, keyboardCB); ////////////////////////////////////////////////////////////////////////////// //////////////////////////////// RENDER LOOP ///////////////////////////////// ////////////////////////////////////////////////////////////////////////////// double elapsedTime = 0.0; render(window, [&](double dt) { elapsedTime += dt; std::string window_header = "Volume Renderer - " + std::to_string( 1.0 / dt ) + " FPS"; glfwSetWindowTitle(window, window_header.c_str() ); //////////////////////////////// GUI //////////////////////////////// ImGuiIO& io = ImGui::GetIO(); ImGui_ImplGlfwGL3_NewFrame(); // tell ImGui a new frame is being rendered ImGui::PushItemWidth(-100); if (ImGui::CollapsingHeader("Geometry Shader Settings")) { ImGui::ColorEdit4( "color", glm::value_ptr( s_color)); // color mixed at max distance ImGui::SliderFloat("strength", &s_strength, 0.0f, 2.0f); // influence of color shift } ImGui::Checkbox("auto-rotate", &s_isRotating); // enable/disable rotating volume ImGui::PopItemWidth(); ////////////////////////////////////////////////////////////////////////////// ///////////////////////////// MATRIX UPDATING /////////////////////////////// if (s_isRotating) // update view matrix { model = glm::rotate(glm::mat4(1.0f), (float) dt, glm::vec3(0.0f, 1.0f, 0.0f) ) * model; } view = glm::lookAt(glm::vec3(eye), glm::vec3(center), glm::vec3(0.0f, 1.0f, 0.0f)); ////////////////////////////////////////////////////////////////////////////// //////////////////////// SHADER / UNIFORM UPDATING ////////////////////////// // update view related uniforms shaderProgram.update( "view", view); shaderProgram.update( "model", turntable.getRotationMatrix() * model); geomShader.update( "view", view); geomShader.update( "model", turntable.getRotationMatrix() * model); compShader.update( "vLightPos", view * turntable.getRotationMatrix() * s_lightPos); updateVectorTexture(elapsedTime); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, s_vectorTexture); // glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); // this is altered by ImGui::Render(), so reset it every frame glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, s_texHandle); geomShader.update("tex", 1); geomShader.update("blendColor", 2.0); geomShader.update("color", s_color); geomShader.update("strength", s_strength); ////////////////////////////////////////////////////////////////////////////// //////////////////////////////// RENDERING //// ///////////////////////////// // glActiveTexture(GL_TEXTURE0); // glBindTexture(GL_TEXTURE_2D, fbo.getColorAttachmentTextureHandle(GL_COLOR_ATTACHMENT0)); // color // glActiveTexture(GL_TEXTURE1); // glBindTexture(GL_TEXTURE_2D, fbo.getColorAttachmeHntTextureHandle(GL_COLOR_ATTACHMENT1)); // normal // glActiveTexture(GL_TEXTURE2); // glBindTexture(GL_TEXTURE_2D, fbo.getColorAttachmentTextureHandle(GL_COLOR_ATTACHMENT2)); // position // glActiveTexture(GL_TEXTURE0); // compShader.update("colorMap", 0); // compShader.update("normalMap", 1); // compShader.update("positionMap", 2); // renderPass.render(); // compositing.render(); geom.render(); ImGui::Render(); glDisable(GL_BLEND); glBlendFunc(GL_ONE, GL_ZERO); // this is altered by ImGui::Render(), so reset it every frame ////////////////////////////////////////////////////////////////////////////// }); destroyWindow(window); return 0; }