image.h

#pragma once
 
#include "sdl_painter/export.h"
#include "sdl_painter/renderer.h"
#include "sdl_painter/texture.h"
 
#include <cstdint>
#include <memory>
#include <string>
 
namespace sdl_painter {
 
class IRenderer;
 
enum class ImageFlip : uint8_t {
  kNone,        
  kHorizontal,  
  kVertical,    
  kBoth,        
};
 
class SDLPAINTER_API Image {
 public:
  Image() = default;
 
  explicit Image(const std::string& file_path);
 
  ~Image();
 
  // Non-copyable, movable
  Image(const Image&) = delete;
  Image& operator=(const Image&) = delete;
  Image(Image&&) noexcept;
  Image& operator=(Image&&) noexcept;
 
  [[nodiscard]] bool IsValid() const noexcept { return mRawData != nullptr; }
 
  [[nodiscard]] int32_t Width() const noexcept { return mWidth; }
 
  [[nodiscard]] int32_t Height() const noexcept { return mHeight; }
 
  [[nodiscard]] int32_t Channels() const noexcept { return mChannels; }
 
  [[nodiscard]] const uint8_t* RawData() const noexcept {
    return mRawData.get();
  }
 
  [[nodiscard]] static Image CreateFromData(const uint8_t* data, int32_t width,
                                            int32_t height, int32_t channels);
 
  void SetFilter(TextureFilter filter) noexcept { mFilter = filter; }
 
  [[nodiscard]] TextureFilter GetFilter() const noexcept { return mFilter; }
 
  TextureHandle Upload(IRenderer& renderer) const;
 
  [[nodiscard]] TextureHandle GetHandle() const noexcept {
    return mHandle.Handle();
  }
 
 private:
  struct StbDeleter {
    void operator()(uint8_t* ptr) const;
  };
 
  std::unique_ptr<uint8_t, StbDeleter> mRawData;
  int32_t mWidth{0};
  int32_t mHeight{0};
  int32_t mChannels{0};
  TextureFilter mFilter{TextureFilter::kLinear};
  mutable Texture
      mHandle;  
};
 
}  // namespace sdl_painter