arena.h

Go to the documentation of this file.

#ifndef YAZE_APP_GFX_ARENA_H
#define YAZE_APP_GFX_ARENA_H
 
#include <array>
#include <cstdint>
#include <functional>
#include <list>
#include <memory>
#include <mutex>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
 
#include "app/gfx/core/bitmap.h"
#include "app/gfx/render/background_buffer.h"
#include "util/sdl_deleter.h"
 
namespace yaze {
namespace gfx {
 
class Arena {
 public:
  static Arena& Get();
 
  void Initialize(IRenderer* renderer);
  ~Arena();
 
  // --- New Deferred Command System ---
  enum class TextureCommandType { CREATE, UPDATE, DESTROY };
  struct TextureCommand {
    TextureCommandType type;
    Bitmap* bitmap;       // The bitmap that needs a texture operation
    uint32_t generation;  // Generation at queue time for staleness detection
  };
 
  void QueueTextureCommand(TextureCommandType type, Bitmap* bitmap);
  bool HasPendingTextureCommand(TextureCommandType type,
                                const Bitmap* bitmap) const;
  void ProcessTextureQueue(IRenderer* renderer);
  void ClearTextureQueue();
 
  void RetireBitmap(Bitmap& bitmap);
 
  size_t DrainRetiredBitmaps(IRenderer* renderer);
 
  bool HasPendingTextures() const { return !texture_command_queue_.empty(); }
 
  bool ProcessSingleTexture(IRenderer* renderer);
 
  bool ProcessTextureQueueWithBudget(IRenderer* renderer, float budget_ms);
 
  struct TextureQueueStats {
    size_t textures_processed = 0;     // Total textures processed this session
    size_t frames_with_work = 0;       // Frames that did texture work
    float total_time_ms = 0.0f;        // Total time spent processing
    float max_frame_time_ms = 0.0f;    // Maximum time spent in a single call
    float avg_texture_time_ms = 0.0f;  // Average time per texture
 
    void Reset() {
      textures_processed = 0;
      frames_with_work = 0;
      total_time_ms = 0.0f;
      max_frame_time_ms = 0.0f;
      avg_texture_time_ms = 0.0f;
    }
  };
 
  const TextureQueueStats& GetTextureQueueStats() const {
    return texture_queue_stats_;
  }
 
  void ResetTextureQueueStats() { texture_queue_stats_.Reset(); }
 
  // --- Surface Management (unchanged) ---
  SDL_Surface* AllocateSurface(int width, int height, int depth, int format);
  void FreeSurface(SDL_Surface* surface);
 
  void Shutdown();
 
  // Resource tracking for debugging
  size_t GetTextureCount() const { return textures_.size(); }
  size_t GetSurfaceCount() const { return surfaces_.size(); }
  size_t GetPooledTextureCount() const {
    return texture_pool_.available_textures_.size();
  }
  size_t GetPooledSurfaceCount() const {
    return surface_pool_.available_surfaces_.size();
  }
  size_t texture_command_queue_size() const {
    return texture_command_queue_.size();
  }
  size_t retired_texture_handle_count() const {
    return retired_texture_handles_.size();
  }
 
  // Graphics sheet access (223 total sheets in YAZE)
  using GraphicsSheets = std::array<gfx::Bitmap, 223>;
  GraphicsSheets& gfx_sheets() { return *active_gfx_sheets_; }
 
  auto gfx_sheet(int i) {
    if (i < 0 || i >= 223)
      return gfx::Bitmap{};
    return gfx_sheets()[i];
  }
 
  auto mutable_gfx_sheet(int i) {
    if (i < 0 || i >= 223)
      return static_cast<gfx::Bitmap*>(nullptr);
    return &gfx_sheets()[i];
  }
 
  auto mutable_gfx_sheets() { return active_gfx_sheets_; }
 
  // Select stable session-owned display storage. The caller retains it through
  // rendering and retires its bitmaps before destruction. Null selects the
  // standalone storage; switching never copies pixels or replaces textures.
  void BindGraphicsSheets(GraphicsSheets* sheets, const void* owner);
 
  // Legacy standalone/test ownership marker. Session code must bind storage
  // and ownership together through BindGraphicsSheets().
  void set_gfx_sheets_owner(const void* owner) { gfx_sheets_owner_ = owner; }
  const void* gfx_sheets_owner() const { return gfx_sheets_owner_; }
 
  void NotifySheetModified(int sheet_index);
 
  // ========== Palette Change Notification System ==========
 
  using PaletteChangeCallback =
      std::function<void(const std::string& group_name, int palette_index)>;
 
  void NotifyPaletteModified(const std::string& group_name,
                             int palette_index = -1);
 
  int RegisterPaletteListener(PaletteChangeCallback callback);
 
  void UnregisterPaletteListener(int listener_id);
 
  // Background buffer access for SNES layer rendering
  auto& bg1() { return bg1_; }
 
  auto& bg2() { return bg2_; }
 
  // ========== LRU Sheet Texture Cache ==========
 
  void TouchSheet(int sheet_index);
 
  Bitmap* GetSheetWithCache(int sheet_index);
 
  void SetSheetCacheSize(size_t max_size);
 
  size_t GetSheetCacheSize() const { return sheet_cache_max_size_; }
 
  size_t GetCachedSheetCount() const { return sheet_lru_map_.size(); }
 
  size_t EvictLRUSheets(size_t count = 0);
 
  void ClearSheetCache();
 
  struct SheetCacheStats {
    size_t hits = 0;          // Sheet accessed and already had texture
    size_t misses = 0;        // Sheet accessed but needed texture creation
    size_t evictions = 0;     // Textures evicted due to cache pressure
    size_t current_size = 0;  // Current number of cached textures
 
    void Reset() {
      hits = 0;
      misses = 0;
      evictions = 0;
      current_size = 0;
    }
 
    float HitRate() const {
      size_t total = hits + misses;
      return total > 0 ? static_cast<float>(hits) / total : 0.0f;
    }
  };
 
  const SheetCacheStats& GetSheetCacheStats() const {
    return sheet_cache_stats_;
  }
 
  void ResetSheetCacheStats() { sheet_cache_stats_.Reset(); }
 
 private:
  Arena();
 
  BackgroundBuffer bg1_;
  BackgroundBuffer bg2_;
 
  static constexpr int kTilesPerRow = 64;
  static constexpr int kTilesPerColumn = 64;
  static constexpr int kTotalTiles = kTilesPerRow * kTilesPerColumn;
 
  std::array<uint16_t, kTotalTiles> layer1_buffer_;
  std::array<uint16_t, kTotalTiles> layer2_buffer_;
 
  GraphicsSheets gfx_sheets_;
  GraphicsSheets* active_gfx_sheets_ = &gfx_sheets_;
  const void* gfx_sheets_owner_ = nullptr;
 
  std::unordered_map<TextureHandle,
                     std::unique_ptr<SDL_Texture, util::SDL_Texture_Deleter>>
      textures_;
 
  std::unordered_map<SDL_Surface*,
                     std::unique_ptr<SDL_Surface, util::SDL_Surface_Deleter>>
      surfaces_;
 
  // Resource pooling for efficient memory management
  struct TexturePool {
    std::vector<TextureHandle> available_textures_;
    std::unordered_map<TextureHandle, std::pair<int, int>> texture_sizes_;
    static constexpr size_t MAX_POOL_SIZE = 100;
  } texture_pool_;
 
  struct SurfacePool {
    std::vector<SDL_Surface*> available_surfaces_;
    std::unordered_map<SDL_Surface*, std::tuple<int, int, int, int>>
        surface_info_;
    static constexpr size_t MAX_POOL_SIZE = 100;
  } surface_pool_;
 
  std::vector<TextureCommand> texture_command_queue_;
  std::vector<TextureHandle> retired_texture_handles_;
  IRenderer* renderer_ = nullptr;
  bool is_shutdown_ = false;
  TextureQueueStats texture_queue_stats_;
 
  // Palette change notification system
  std::unordered_map<int, PaletteChangeCallback> palette_listeners_;
  int next_palette_listener_id_ = 1;
 
  // LRU sheet texture cache
  // List stores sheet indices in access order (front = most recent)
  std::list<int> sheet_lru_list_;
  // Map from sheet index to iterator in lru_list for O(1) access
  std::unordered_map<int, std::list<int>::iterator> sheet_lru_map_;
  size_t sheet_cache_max_size_ = 64;  // Default: cache 64 sheet textures
  SheetCacheStats sheet_cache_stats_;
};
 
}  // namespace gfx
}  // namespace yaze
 
#endif  // YAZE_APP_GFX_ARENA_H