Nill pointer from glTextImage2D

[shrit]

Hello,

I am trying to run the example that is provided to load images but the image_texture pointer is always NULL or FFFFFF
NULL if you change to GL_RGB and FFFFFF if you keep the GL_RGBA, the standard one (if course with changing the channel number in stb).

Any idea why this is happening I have checked the image and it is loaded correctly by STB.

No error returned by opengl

I know this is not directly related to ImGUI but I am pretty sure that the maintainers have came accross this issue or have an idea what I am doing wrong especially that opengl is not my domain of expertise

Many thanks

static int my_image_width = 0;
static int my_image_height = 0;                                                                                                                                                                                                      
static GLuint my_image_texture = 0;


// Simple helper function to load an image into a OpenGL texture with common settings
bool LoadTextureFromFile(const char* filename, GLuint* out_texture, int* out_width, int* out_height)
{
  // Load from file
  int image_width = 0;
  int image_height = 0;
  unsigned char* image_data = stbi_load(filename, &image_width, &image_height, NULL, 3);
  if (image_data == NULL)
      return false;

  for (size_t i = 0; i < image_width * image_height; ++i)
  {
    std::cout << +image_data[i] << " ";
  }
  std::cout << std::endl;

  // Create a OpenGL texture identifier
  GLuint image_texture;
  glGenTextures(1, &image_texture);
  glBindTexture(GL_TEXTURE_2D, image_texture);

  std::cout << "pointer 1 address" << std::hex << image_texture << std::endl;
  // Setup filtering parameters for display
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); // This is required on WebGL for non power-of-two textures
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); // Same

  // Upload pixels into texture
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, image_width, image_height, 0, GL_RGB, GL_UNSIGNED_BYTE, image_data);
  stbi_image_free(image_data);
  int error_code = glGetError();
  std::cout << "Error: " << error_code << std::endl;

  std::cout << "pointer 2 address" << std::hex << image_texture << std::endl;
  *out_texture = image_texture;
  *out_width = image_width;
  *out_height = image_height;

  return true;
}

[shrit]

@ocornut did I open this in the wrong place? I am happy to re-open it as an issue

[PathogenDavid]

This isn't the right place, but reopening as an issue wouldn't be appropriate either as this is more of an OpenGL question rather than a Dear ImGui one.

glGenTextures isn't something I'd ever expect to fail under normal circumstances.

My hunch would be that you're calling it without an active/valid OpenGL context.

Any chance you're trying to load your image on a background thread? OpenGL doesn't support multithreading.

[shrit]

Hi David @PathogenDavid ,

I totally agree with you and am sorry for that, since there is no direct way to access the OpenGL community, and I am using it in the context of Dear I'mgui I thought I would give it a chance here since I will have a way more chance if someone has seen something like that before.

Here is the entire code, I do not think I am calling it inside any kind of thread and indeed I am very surprised by this issue:

#include "imgui.h"
#include "imgui_impl_glut.h"
#include "imgui_impl_opengl2.h"
#define GL_SILENCE_DEPRECATION
#include <GL/freeglut.h>

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

#include <iostream>
void MainLoopStep();

static bool show_demo_window = true;
static bool show_another_window = false;
static ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
static int my_image_width = 0;
static int my_image_height = 0;
static GLuint my_image_texture = 0;

// Simple helper function to load an image into a OpenGL texture with common settings
bool LoadTextureFromFile(const char* filename, GLuint* out_texture, int* out_width, int* out_height)
{
  // Load from file
  int image_width = 0;
  int image_height = 0;
  unsigned char* image_data = stbi_load(filename, &image_width, &image_height, NULL, 3);
  if (image_data == NULL)
      return false;

  for (size_t i = 0; i < image_width * image_height; ++i)
  {
    std::cout << +image_data[i] << " ";
  }
  std::cout << std::endl;

  // Create a OpenGL texture identifier
  GLuint image_texture;
  glGenTextures(1, &image_texture);
  glBindTexture(GL_TEXTURE_2D, image_texture);

  std::cout << "pointer 1 address" << std::hex << image_texture << std::endl;
  // Setup filtering parameters for display
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); // This is required on WebGL for non power-of-two textures
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); // Same

  // Upload pixels into texture
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, image_width, image_height, 0, GL_RGB, GL_UNSIGNED_BYTE, image_data);
  stbi_image_free(image_data);
  int error_code = glGetError();
  std::cout << "Error: " << error_code << std::endl;

  std::cout << "pointer 2 address" << std::hex << image_texture << std::endl;
  *out_texture = image_texture;
  *out_width = image_width;
  *out_height = image_height;

  return true;
}


void init_glut(int argc, char** argv)
{
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_MULTISAMPLE);
  glutInitWindowSize(1280, 720);
  glutCreateWindow("Dear ImGui GLUT+OpenGL2 Example");
}

int main(int argc, char** argv)
{
  bool ret = LoadTextureFromFile("test.jpg", &my_image_texture, &my_image_width, &my_image_height);
  IM_ASSERT(ret);

  std::cout << "True is it : " << ret << std::endl;

  std::cout << "pointer address" << std::hex << my_image_texture << std::endl;
  init_glut(argc, argv);
  // Setup GLUT display function
  // We will also call ImGui_ImplGLUT_InstallFuncs() to get all the other functions installed for us,
  // otherwise it is possible to install our own functions and call the imgui_impl_glut.h functions ourselves.
  glutDisplayFunc(MainLoopStep);

  // Setup Dear ImGui context
  IMGUI_CHECKVERSION();
  ImGui::CreateContext();
  ImGuiIO& io = ImGui::GetIO(); (void)io;
  io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls

  // Setup Dear ImGui style
  ImGui::StyleColorsDark();
  //ImGui::StyleColorsLight();

  // Setup Platform/Renderer backends
  ImGui_ImplGLUT_Init();
  ImGui_ImplOpenGL2_Init();
  ImGui_ImplGLUT_InstallFuncs();

  // Main loop
  glutMainLoop();

  // Cleanup
  ImGui_ImplOpenGL2_Shutdown();
  ImGui_ImplGLUT_Shutdown();
  ImGui::DestroyContext();
  return 0;
}

void DemoHeader(const char* label, void(*demo)())
{
  if (ImGui::TreeNodeEx(label))
  {
    demo();
    ImGui::TreePop();
  }
}


void MainLoopStep()
{
  // Start the Dear ImGui frame
  ImGui_ImplOpenGL2_NewFrame();
  ImGui_ImplGLUT_NewFrame();
  ImGui::NewFrame();
  ImGuiIO& io = ImGui::GetIO();

  ImGui::SetNextWindowPos(ImVec2(70, 5), ImGuiCond_Once);
  ImGui::SetNextWindowSize(ImVec2(1200.0, 1200.0), ImGuiCond_Once);

  ImGui::Begin("PigSoft Capture and label images");

  ImGui::Text("pointer = %p", my_image_texture);
  ImGui::Text("size = %d x %d", my_image_width, my_image_height);
  ImGui::Image((void*)(intptr_t)my_image_texture, ImVec2(my_image_width, my_image_height));

  ImGui::End();

  ImGui::Render();
  glViewport(0, 0, (GLsizei)io.DisplaySize.x, (GLsizei)io.DisplaySize.y);
  glClearColor(clear_color.x * clear_color.w, clear_color.y * clear_color.w, clear_color.z * clear_color.w, clear_color.w);
  glClear(GL_COLOR_BUFFER_BIT);
  //glUseProgram(0); // You may want this if using this code in an OpenGL 3+ context where shaders may be bound, but prefer using the GL3+ code.
  ImGui_ImplOpenGL2_RenderDrawData(ImGui::GetDrawData());

  glutSwapBuffers();
  glutPostRedisplay();
}

[PathogenDavid]

No worries! I was more trying to explain why you didn't get a response.

You need to load your texture after initializing GLUT since it's what initialized your GL context.

---

As an aside, GLUT and OpenGL 2 are seriously ancient. You'd be better off using at least OpenGL 3 and something more modern. GLFW and SDL are both popular choices, GLFW is the simpler of the two.

If you're following some old OpenGL tutorial that is recommending GLUT it's out of date to the point of being harmful.

[shrit]

@PathogenDavid Thank you very much for your answer, I agree with all your points.

Actually, if you know a backend library for graphics in Linux that you prefer and that is lightweight, not cumbersome and does not add a ton of libraries into the linking process, I would be more than happy to use it, I am not familiar with either GLFW or SDL so if you have a preference I would be more than happy to follow it.

[PathogenDavid]

That definitely depends on your exact needs.

Short answer though: GLFW + OpenGL [3.0..4.1] is a safe bet, that's what I've used for simple standalone DearImGui apps on Linux in the past.

If your goal is only to use Dear ImGui and maybe the bare-bones 2D rendering it provides, I'd definitely just use GLFW and OpenGL.

Long answer:

Platform Library (IE: Windowing, input)

Both SDL and GLFW are pretty lightweight, but GLFW is definitely the more lightweight of the two. SDL has abstractions for more things (like audio and filesystem stuff), although most people are really only using it for the windowing and keyboard/mouse/gamepad stuff. There are official Dear ImGui backends and examples for both. (Note that SDL3 is still in flux, so if you go with SDL use SDL2 for now.)

Both are in most Linux distros' package managers.

Rendering Library (IE: The API you use to send draw commands to the GPU)

For the actual rendering side of things, OpenGL 4.1 is a common target for cross-platform apps since it was the last version supported by macOS. If you foresee the need for browser or mobile GPU support (including Raspberry Pi) you might lean towards OpenGL 3.x for easier compatibility with WebGL/OpenGL ES.

If you want to get away from OpenGL entirely, SDL has an accelerated 2D rendering abstraction that some people like (I'm personally not a fan, but I have experience with the various graphics APIs so I'm not the target audience.) Do note though that with Dear ImGui, it doesn't support multi-viewports due to upstream limitations. (See #5835)

I've never used it myself, but I've heard good things about raylib. There is a third-party Dear ImGui backend available, although do note that it also doesn't support multi-viewports either.

Some others I'm aware of but know even less about are sokol and SFML, which also have third-party backends.

It is worth noting that these higher-level libraries also tend to come with their own windowing abstractions, so they actually sometimes/always straddle the line between both categories. (IE: raylib has its own windowing, and with sokol it looks like you can use glfw or their own windowing.)

In general I think it comes down to which vibes with you the best. If you're indecisive I think OpenGL is probably the safest bet and the decision you're least likely to regret, but you might also have to learn more about it than you wanted. (On the flip side, there's bound to be way more OpenGL resources out there than there are for any abstraction.)

[shrit]

@PathogenDavid Thank you very much for your answer it is very clarifying for me.

I switched to GLFW, and it looks great and working nicely with opengl3.

Regarding the rendering library, I have one question, you mention in your above comment that OpenGL does not support threading which mean mult threading my rendering. However, I should see no issue mult threading other tasks and keep OpenGL in the main thread and putting data on a shared memory, is that correct ?

Having a quick look at the different rendering libraries that you have mentioned, sokol look really cool especially that it is header only which mean easy portability and compilation process. However, it will require some testing to see if it is good for all what I need.

[PathogenDavid]

No problem!

However, I should see no issue mult threading other tasks and keep OpenGL in the main thread and putting data on a shared memory, is that correct ?

Yes, that's correct.