Public Image class

[picosaur]

Could you please make public (I mean not internal) class for image?
For example, in my code I use the following

// Image.h
class Image {
  class Impl;
  std::unique_ptr<Impl> impl_;

public:
  Image();
  Image(int width, int height); // for creating empty image
  Image(const std::byte *data, std::size_t size); // for loading with stb
  ~Image();
  
  void render();
  ImTextureID textureId() const;

  // Geometry
  int width() const;
  int height() const;
  ImVec2 imageSize() const;

  // data pointer ...
};

// Image.cpp 
// As Impl is backend dependent so we can have here different Impl's using ifdefs
// ----------------------------------------------------------------------------
class Image::Impl {
public:
  unsigned char *rgba{};
  GLint width{};
  GLint height{};
  GLuint textureId{};
  bool stbi{};

  ImU32 *data() const;
  int size() const;

  auto begin();
  auto end();

  void loadTexture();
  void updateTexture();
  void freeTexture();
};

auto Image::Impl::begin() { return data(); }

auto Image::Impl::end() { return data() + size(); }

ImU32 *Image::Impl::data() const { return reinterpret_cast<ImU32 *>(rgba); }

int Image::Impl::size() const { return width * height; }

void Image::Impl::loadTexture() {
  glGenTextures(1, &textureId);
  glBindTexture(GL_TEXTURE_2D, textureId);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
#if defined(HELLOIMGUI_USE_GLES2) || defined(HELLOIMGUI_USE_GLES3)
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
#endif
  glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA,
               GL_UNSIGNED_BYTE, rgba);
  glBindTexture(GL_TEXTURE_2D, 0);
}

void Image::Impl::updateTexture() {
  glBindTexture(GL_TEXTURE_2D, textureId);
  glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA,
                  GL_UNSIGNED_BYTE, rgba);
  glBindTexture(GL_TEXTURE_2D, 0);
}

void Image::Impl::freeTexture() {
  if (rgba != nullptr) {
    glDeleteTextures(1, &textureId);
    if (stbi) {
      stbi_image_free(rgba);
    } else {
      delete[] rgba;
    }
    rgba = {};
  }
}

// Image
// ----------------------------------------------------------------------------
Image::Image() : impl_{std::make_unique<Impl>()} {}

Image::Image(int width, int height) : impl_{std::make_unique<Impl>()} {
  impl_->width = width;
  impl_->height = height;
  impl_->rgba = new unsigned char[width * height * 4];
  impl_->loadTexture();
}

Image::Image(const std::byte *data, std::size_t size)
    : impl_{std::make_unique<Impl>()} {
  impl_->rgba = stbi_load_from_memory((unsigned char *)data, size,
                                      &impl_->width, &impl_->height, NULL, 4);
  impl_->stbi = true;
  impl_->loadTexture();
}

Image::~Image() { impl_->freeTexture(); }

void Image::render() { impl_->updateTexture(); }

ImTextureID Image::textureId() const {
  return (ImTextureID)(intptr_t)impl_->textureId;
}

int Image::width() const { return impl_->width; }

int Image::height() const { return impl_->height; }

ImVec2 Image::imageSize() const {
  return {(float)impl_->width, (float)impl_->height};
}

[pthom]

Hi,

Does this API, which is public, fill your needs?

// `HelloImGui::ImageAndSize HelloImGui::ImageAndSizeFromAsset(assetPath)`:
// will return the texture ID and the size of an image loaded from the assets.
struct ImageAndSize
{
    ImTextureID textureId = ImTextureID(0);
    ImVec2 size = ImVec2(0.f, 0.f);
};
ImageAndSize ImageAndSizeFromAsset(const char *assetPath);

[pthom]

... Or are you looking to access the pixel data?

[picosaur]

Following current API-style I would prefer to have some helper functions, for example
ImageAndSize ImageAndSizeFromMemory(const unsigned char *data, int size); - this loads image using stb
and
ImageAndSize ImageAndSizeSolid(int w, int h, ImU32 color); - this creates an image filled with color
also
ImageAndSizeFromFile in case if assetPath can't accept global paths

As image data is storing in GPU memory, so access to its copy in RAM is user responsibility I think

[pthom]

I'll leave this issue opened and come back to it at a later time