bitmap.h

Go to the documentation of this file.

#ifndef YAZE_APP_GFX_BITMAP_H
#define YAZE_APP_GFX_BITMAP_H
 
#include "app/platform/sdl_compat.h"
 
#include <cstdint>
#include <memory>
#include <span>
#include <unordered_map>
#include <vector>
 
#include "app/gfx/backend/irenderer.h"
#include "app/gfx/types/snes_palette.h"
 
namespace yaze {
 
namespace gfx {
 
class Arena;
 
// Pixel format constants
constexpr Uint32 SNES_PIXELFORMAT_INDEXED =
    SDL_DEFINE_PIXELFORMAT(SDL_PIXELTYPE_INDEX8, 0, 0, 8, 1);
 
constexpr Uint32 SNES_PIXELFORMAT_4BPP = SDL_DEFINE_PIXELFORMAT(
    /*type=*/SDL_PIXELTYPE_INDEX8, /*order=*/0,
    /*layouts=*/0, /*bits=*/4, /*bytes=*/1);
 
constexpr Uint32 SNES_PIXELFORMAT_8BPP = SDL_DEFINE_PIXELFORMAT(
    /*type=*/SDL_PIXELTYPE_INDEX8, /*order=*/0,
    /*layouts=*/0, /*bits=*/8, /*bytes=*/1);
 
enum BitmapFormat {
  kIndexed = 0,
  k4bpp = 1,
  k8bpp = 2,
  kRgba = 3,  // Display output: packed R, G, B, A bytes, not ROM indices.
};
 
class Bitmap {
 public:
  Bitmap() = default;
 
  Bitmap(int width, int height, int depth, const std::vector<uint8_t>& data);
 
  Bitmap(int width, int height, int depth, const std::vector<uint8_t>& data,
         const SnesPalette& palette);
 
  Bitmap(const Bitmap& other);
 
  Bitmap& operator=(const Bitmap& other);
 
  Bitmap(Bitmap&& other) noexcept;
 
  Bitmap& operator=(Bitmap&& other) noexcept;
 
  ~Bitmap() = default;
 
  void Create(int width, int height, int depth, std::span<uint8_t> data);
 
  void Create(int width, int height, int depth,
              const std::vector<uint8_t>& data);
 
  void Create(int width, int height, int depth, int format,
              const std::vector<uint8_t>& data);
 
  void Reformat(int format);
 
  void Fill(uint8_t value) {
    std::fill(data_.begin(), data_.end(), value);
    modified_ = true;
  }
 
  void CreateTexture();
 
  void UpdateTexture();
 
  void QueueTextureUpdate(IRenderer* renderer);
 
  void UpdateTextureData();
 
  void SetPalette(const SnesPalette& palette);
 
  void SetPaletteWithTransparent(const SnesPalette& palette, size_t index,
                                 int length = 7);
 
  void ApplyPaletteByMetadata(const SnesPalette& palette,
                              int sub_palette_index = 0);
 
  void ApplyStoredPalette();
 
  void UpdateSurfacePixels();
 
  void SetPalette(const std::vector<SDL_Color>& palette);
 
  void WriteToPixel(int position, uint8_t value);
 
  void WriteToPixel(int x, int y, uint8_t value) {
    if (x >= 0 && x < width_ && y >= 0 && y < height_) {
      WriteToPixel(y * width_ + x, value);
    }
  }
 
  uint8_t GetPixel(int x, int y) const {
    if (x >= 0 && x < width_ && y >= 0 && y < height_) {
      return data_[y * width_ + x];
    }
    return 0;
  }
 
  [[deprecated("Choose an explicit palette slot and use WriteToPixel")]]
  void WriteColor(int position, const ImVec4& color);
 
  void SetPixel(int x, int y, const SnesColor& color);
 
  void Resize(int new_width, int new_height);
 
  void InvalidatePaletteCache();
 
  uint8_t FindColorIndex(const SnesColor& color);
 
  bool ValidateDataSurfaceSync();
 
  void Get8x8Tile(int tile_index, int x, int y, std::vector<uint8_t>& tile_data,
                  int& tile_data_offset);
 
  void Get16x16Tile(int tile_x, int tile_y, std::vector<uint8_t>& tile_data,
                    int& tile_data_offset);
 
  enum class BitmapPurpose : uint8_t {
    kPreview,          // Read-only preview (e.g. gfx-group sheet thumbnails).
    kEditable,         // User-editable scratchpad (default).
    kSelectionSource,  // Read-only tile/region picker source.
    kCompositeOutput,  // Post-render composite (room renderer output, etc).
  };
 
  struct BitmapMetadata {
    int source_bpp = 8;      // Original bits per pixel (3, 4, 8)
    int palette_format = 0;  // 0=full palette, 1=sub-palette with transparent
    std::string
        source_type;  // "graphics_sheet", "tilemap", "screen_buffer", "mode7"
    int palette_colors = 256;  // Expected palette size
    // Role this bitmap plays. Optional metadata for editors that want to
    // distinguish preview / editable / selection / composite bitmaps.
    BitmapPurpose purpose = BitmapPurpose::kEditable;
 
    BitmapMetadata() = default;
    BitmapMetadata(int bpp, int format, const std::string& type,
                   int colors = 256)
        : source_bpp(bpp),
          palette_format(format),
          source_type(type),
          palette_colors(colors) {}
  };
 
  const SnesPalette& palette() const { return palette_; }
  SnesPalette* mutable_palette() { return &palette_; }
  BitmapMetadata& metadata() { return metadata_; }
  const BitmapMetadata& metadata() const { return metadata_; }
 
  int width() const { return width_; }
  int height() const { return height_; }
  int depth() const { return depth_; }
  bool IsIndexed() const { return depth_ <= 8; }
  // Read display colors without treating RGBA bytes as palette indices.
  // Source palette rows remain on indexed sheets; composite output has none.
  SDL_Color ReadColor(int x, int y) const;
  std::vector<uint8_t> ToRgba() const;
  auto size() const { return data_.size(); }
  const uint8_t* data() const { return data_.data(); }
  std::vector<uint8_t>& mutable_data() { return data_; }
  SDL_Surface* surface() const { return surface_; }
  TextureHandle texture() const { return texture_; }
  const std::vector<uint8_t>& vector() const { return data_; }
  uint8_t at(int i) const { return data_[i]; }
  bool modified() const { return modified_; }
  bool is_active() const { return active_; }
  uint32_t generation() const { return generation_; }
  void set_active(bool active) { active_ = active; }
  void set_data(const std::vector<uint8_t>& data);
  void set_modified(bool modified) { modified_ = modified; }
  void set_texture(TextureHandle texture) { texture_ = texture; }
 
 private:
  friend class Arena;
  void CopySurfaceState(const Bitmap& other);
 
  // Arena alone may split a Bitmap's CPU and GPU resources during explicit
  // owner retirement. Keeping these helpers private prevents ordinary callers
  // from accidentally detaching a live bitmap.
  SDL_Surface* DetachSurfaceForArena() noexcept {
    SDL_Surface* surface = surface_;
    surface_ = nullptr;
    return surface;
  }
  TextureHandle DetachTextureForArena() noexcept {
    TextureHandle texture = texture_;
    texture_ = nullptr;
    return texture;
  }
  void MarkRetiredByArena() noexcept {
    active_ = false;
    modified_ = false;
    texture_pixels = nullptr;
    generation_ = next_generation_++;
  }
  int width_ = 0;
  int height_ = 0;
  int depth_ = 0;
 
  bool active_ = false;
  bool modified_ = false;
 
  // Generation counter for staleness detection in deferred operations
  // Incremented on each Create() call to detect reused/reallocated bitmaps
  uint32_t generation_ = 0;
  static inline uint32_t next_generation_ = 1;
 
  // Pointer to the texture pixels
  void* texture_pixels = nullptr;
 
  // Pointer to the pixel data
  uint8_t* pixel_data_ = nullptr;
 
  gfx::SnesPalette palette_;
 
  // Metadata for tracking source format and palette requirements
  BitmapMetadata metadata_;
 
  // Packed rows: one byte per indexed pixel, or four RGBA bytes per pixel.
  std::vector<uint8_t> data_;
 
  SDL_Surface* surface_ = nullptr;
 
  // Texture for the bitmap (managed by Arena)
  TextureHandle texture_ = nullptr;
 
  // Optimized palette lookup cache for O(1) color index lookups
  std::unordered_map<uint32_t, uint8_t> color_to_index_cache_;
 
  // Dirty region tracking for efficient texture updates
  struct DirtyRegion {
    int min_x = 0, min_y = 0, max_x = 0, max_y = 0;
    bool is_dirty = false;
 
    void Reset() {
      min_x = min_y = max_x = max_y = 0;
      is_dirty = false;
    }
 
    void AddPoint(int x, int y) {
      if (!is_dirty) {
        min_x = max_x = x;
        min_y = max_y = y;
        is_dirty = true;
      } else {
        min_x = std::min(min_x, x);
        min_y = std::min(min_y, y);
        max_x = std::max(max_x, x);
        max_y = std::max(max_y, y);
      }
    }
  } dirty_region_;
 
  static uint32_t HashColor(const ImVec4& color);
};
 
// Type alias for a table of bitmaps - uses unique_ptr for stable pointers
// across rehashes (prevents dangling pointers in deferred texture commands)
using BitmapTable = std::unordered_map<int, std::unique_ptr<gfx::Bitmap>>;
 
Uint32 GetSnesPixelFormat(int format);
 
}  // namespace gfx
}  // namespace yaze
 
#endif  // YAZE_APP_GFX_BITMAP_H