Can't understand how to make ImGui rendering the texture with OpenGL

[lazzybunny]

Hello there, i'm pretty stuck with the problem to generate the texture inside ImGui window, it's works with GLFW, but ImGui::Image do nothing right now, i was searching a lot on the internet, on the Discussion and Issues forums, i was trying to find the solution on the others project who was using ImGui, and i was rereading the imgui.h and .cpp files for answers, but i don't find any...

This is my MVP code

//headers
// ...
int main() {
// initialization
// ...
// generates vertex buffers, vertex array and elements buffer objects
//...
// loadind and creating the texture
// ...
// rendering loop with the problem
 while (main_window.isOpen()) {
        sf::Event event;
        while (main_window.pollEvent(event)) {
            ImGui::SFML::ProcessEvent(event);

            if (event.type == sf::Event::Closed) {
                main_window.close();
            }
        

        ImGui::SFML::Update(main_window, deltaClock.restart());

  // Rendering map window-------------------------------------
  ImGui::Begin("Map");     // Create a window called "Map"
  

  if (!glfwWindowShouldClose(map_window) && main_window.isOpen())
      {
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);


        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, map_texture);

        map_shader.use();
        glBindVertexArray(VAO);
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

	// imgui image rendering NOT WORKING!
	ImVec2 size(map_width, map_height);
	ImGui::Image((void*)(intptr_t)map_texture, size);

        glfwSwapBuffers(map_window);
        glfwPollEvents();
      }
   
  ImGui::End();
   
  ImGui::Render();
  //-----------------------------------------------------
        main_window.clear();
        ImGui::SFML::Render(main_window);
        main_window.display();
	}
    }
// cleanup
return 0;
}

and it's create the main_window and map_window and glfw rendering the texture, but i don't see the ImGui window, and i actually want to render this inside ImGui window

[lazzybunny]

I finnaly did it! It worked as it was expected! But i changed code a lot, i think it would be rude to pass it all here :)

[ocornut]

Glad you did it!
Even though it’s not technically a dear imgui problem, many people are stumbling on similar issues when doing graphics programming, and it may be helpful if you share your working code here.

[lazzybunny]

Okay then, i hope it's really will be helpful for someone, so this is the whole code that worked for me

#include <SFML/Window/Window.hpp>
#include <SFML/System.hpp>
#include <SFML/Graphics.hpp>

#include <SFML/Graphics/RenderWindow.hpp>
#include <SFML/System/Clock.hpp>
#include <SFML/Window/Event.hpp>

#define GLAD_GL_IMPLEMENTATION
#include <glad/glad.h>

#define _GLFW_BUILD_DLL

#include <GLFW/glfw3.h>
#include <GLFW/glfw3native.h>

#include <imgui.h>
#include <imgui_impl_glfw.h>
#include <imgui_impl_opengl3.h>
#include <imgui-SFML.h>

#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS
#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS

//#define STB_IMAGE_IMPLEMENTATION
#include <stb_image.h>

#include <shader_loader.h>


    // global defined indices for OpeGL
    GLuint VAO; // vertex array object
    GLuint VBO; // vertex buffer object
    GLuint EBO; // elements buffer object
    GLuint FBO; // frame buffer object
    GLuint RBO; // rendering buffer object
    GLuint texture_id;
    int main_window_width = 1280;
    int main_window_height = 720;


void create_framebuffer();
void bind_framebuffer();
void unbind_framebuffer();
void rescale_framebuffer(float width, float height);

int main() {
  // INITIALIZATION ===================================================
  //======================================================
 
    // init and create glfw window
    //--------------------------------------------------------------------
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    // creating
  
    GLFWwindow* main_window = glfwCreateWindow(main_window_width, main_window_height, "Bones animation", NULL, NULL);
    if (main_window == NULL)
      {
  std::cout << "Failed to create GLFW window" << std::endl;
  return -1;
      }
    glfwMakeContextCurrent(main_window);
    //----------------------------------

   // glad: load all OpenGL function pointers
   // -----------------------------------------------
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cout << "Failed to initialize the GLAD" << std::endl;
    }
    //------------------------

    // ImGui init
    //-----------
    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGuiIO& io = ImGui::GetIO(); (void)io;
    io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; 
    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
    io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
    //-------------------------------------------------

    // SET UP VERTEX DATA
    // -----------------------------------------------------------------
    float map_vertices[] = {
        // positions           //colors                 // texture coords
        1.0f,  1.0f, 0.0f,     1.0f, 0.0f, 0.0f,         1.0f, 1.0f, // top right
        1.0f, -1.0f, 0.0f,     0.0f, 1.0f, 0.0f,         1.0f, 0.0f, // bottom right
       -1.0f, -1.0f, 0.0f,     0.0f, 0.0f, 1.0f,         0.0f, 0.0f,  // bottom left
       -1.0f,  1.0f, 0.0f,     1.0f, 1.0f, 0.0f,         0.0f, 1.0f  // top left
    };
    unsigned int map_indices[] = {
      0, 1, 3, // first triangle
      1, 2, 3  // second triangle
    };

    
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    glGenBuffers(1, &EBO);

    glBindVertexArray(VAO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(map_vertices), map_vertices, GL_STATIC_DRAW);

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(map_indices), map_indices, GL_STATIC_DRAW);

    // position attribute
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);
    // color coordinates
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float)));
    glEnableVertexAttribArray(1);
    //texture attribute
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float)));
    glEnableVertexAttribArray(2);
    
    // LOADING AND CREATE A TEXTURE
   // --------------------------------------------------
    unsigned int map_texture;
    glGenTextures(1, &map_texture);
    glBindTexture(GL_TEXTURE_2D, map_texture);


    // setting the texture wrapping parametres
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    // setting texture filtering parametres
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);


    int map_width, map_height, nrChannels;
    stbi_set_flip_vertically_on_load(true);
    // std::string map_path = "C:\\bones_animation\\include\\textures\\map_back.jpg";  // Image of Map
     std::string map_path = "C:\\bones_animation\\include\\textures\\mesh.jpg";
    // tell OpenGL for each sampler to which texture unit it belongs too
    // -----------------------------------------------------------------
    // std::string vertexPath = "C:\\bones_animation\\dependencies\\shaders\\map_VrtsShdr.vs";
    // std::string fragmentPath = "C:\\bones_animation\\dependencies\\shaders\\map_fragmentShdr.fs";
    //Shader map_shader(vertexPath.c_str(), fragmentPath.c_str());
    Shader map_shader("C:\\bones_animation\\dependencies\\shaders\\map_VrtsShdr.vs", "C:\\bones_animation\\dependencies\\shaders\\map_fragmentShdr.fs");
    glUniform1i(glGetUniformLocation(map_shader.ID, "map_texture"), 0);


    //STBI LOADING TEXTURE
    //------------------------------------------------------------------------------------------------------
        unsigned char* map_back_data = stbi_load(map_path.c_str(), &map_width, &map_height, &nrChannels, 0);
        if (map_back_data)
        {
            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, map_width, map_height, 0, GL_RGB, GL_UNSIGNED_BYTE, map_back_data);
            glGenerateMipmap(GL_TEXTURE_2D);
        }
        else
        {
            std::cout << "Failed to load a texture!" << std::endl;
        }
        stbi_image_free(map_back_data);
    //----------------------------------
	
    // CREATING FRAMEBUFFER
    //--------------------------------
	create_framebuffer();

    // ImGui Styling
    //---------------------------------------------------
    ImGui::StyleColorsDark();
    ImGuiStyle& style = ImGui::GetStyle();
    if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable){
        style.WindowRounding = 0.0f;
        style.Colors[ImGuiCol_WindowBg].w = 1.0f;
    }

    // initialize ImGui's glfw/opengl implementation 
    ImGui_ImplGlfw_InitForOpenGL(main_window, true);
    ImGui_ImplOpenGL3_Init("#version 330");
    //--------------------------------------------
    //==============================================================================================================

	// Rendering loop--------------------------------------------------------------------
	//----------------------------------------------------------------------
	while (!glfwWindowShouldClose(main_window))
	  {
	    glfwPollEvents();

	    ImGui_ImplOpenGL3_NewFrame();
	    ImGui_ImplGlfw_NewFrame();

	
	    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
	    glClear(GL_COLOR_BUFFER_BIT);

	    ImGui::NewFrame();
	    ImGui::Begin("Map window");

	    // access the ImGui window size
	    const float window_width = ImGui::GetContentRegionAvail().x;
	    const float window_height = ImGui::GetContentRegionAvail().y;

	    //rescale the framebuffer to the actual window size
	    rescale_framebuffer(window_width, window_height);
	    glViewport(0, 0, window_width, window_height);

	    // we get the screen position of the window
	    ImVec2 pos = ImGui::GetCursorScreenPos();

	    // put the texture as image to ImGui
	    ImGui::GetWindowDrawList()->AddImage((void*)texture_id,
						 ImVec2(pos.x, pos.y),
						 ImVec2(pos.x + window_width, pos.y + window_height),
						 ImVec2(0, 1),
						 ImVec2(1, 0)
						 );

	    ImGui::End();
	    ImGui::Render();

	    bind_framebuffer();

	    glActiveTexture(GL_TEXTURE0);
	    glBindTexture(GL_TEXTURE_2D, map_texture);

	    map_shader.use();
	    glBindVertexArray(VAO);
	    glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);

	    unbind_framebuffer();

	    
	    //----------------------------------------------------
	     ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());	
        if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable)
        {
    	    GLFWwindow* backup_current_context = glfwGetCurrentContext();
    	    ImGui::UpdatePlatformWindows();
    	    ImGui::RenderPlatformWindowsDefault();
    	    glfwMakeContextCurrent(backup_current_context);
        }
	    glfwSwapBuffers(main_window);
	    glfwPollEvents();
	    
	  }
	//----------------------------------------------------------------------
	// End of rendering loop-------------------------------------------------------------


    // Cleanup =============================================
    // ============================================
    // imgui cleanup
    ImGui_ImplOpenGL3_Shutdown();
    ImGui_ImplGlfw_Shutdown();
    ImGui::DestroyContext();
    // other clenups---------------
    glDeleteFramebuffers(1, &FBO);
    glDeleteTextures(1, &texture_id);
    glDeleteRenderbuffers(1, &RBO);
    
    glfwDestroyWindow(main_window);
    glfwTerminate();

    return 0;
}


// function to creating a framebuffer
void create_framebuffer()
{
  glGenFramebuffers(1, &FBO);
  glBindFramebuffer(GL_FRAMEBUFFER, FBO);

  glGenTextures(1, &texture_id);
  glBindTexture(GL_TEXTURE_2D, texture_id);
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, main_window_width, main_window_height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_id, 0);

  glGenRenderbuffers(1, &RBO);
  glBindRenderbuffer(GL_RENDERBUFFER, RBO);
  glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, main_window_width, main_window_height);
  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, RBO);

  if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
    std::cout << "ERROR::FRAMEBUFFER:: Framebuffer is not complete!\n";

  glBindFramebuffer(GL_FRAMEBUFFER, 0);
  glBindTexture(GL_TEXTURE_2D, 0);
  glBindRenderbuffer(GL_RENDERBUFFER, 0);
}

void bind_framebuffer()
{
  glBindFramebuffer(GL_FRAMEBUFFER, FBO);
}

void unbind_framebuffer()
{
  glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

void rescale_framebuffer(float width, float height)
{
  glBindTexture(GL_TEXTURE_2D, texture_id);
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_id, 0);

  glBindRenderbuffer(GL_RENDERBUFFER, RBO);
  glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height);
  glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, RBO);
}

hope it helped :)