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 <memory>
#include <mutex>
#include <tuple>
#include <unordered_map>
#include <vector>
 
#include "util/sdl_deleter.h"
#include "app/gfx/background_buffer.h"
#include "app/gfx/bitmap.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
  };
 
  void QueueTextureCommand(TextureCommandType type, Bitmap* bitmap);
  void ProcessTextureQueue(IRenderer* renderer);
 
  // --- 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(); }
 
  // Graphics sheet access (223 total sheets in YAZE)
  std::array<gfx::Bitmap, 223>& gfx_sheets() { return gfx_sheets_; }
  
  auto gfx_sheet(int i) { return gfx_sheets_[i]; }
  
  auto mutable_gfx_sheet(int i) { return &gfx_sheets_[i]; }
  
  auto mutable_gfx_sheets() { return &gfx_sheets_; }
  
  void NotifySheetModified(int sheet_index);
 
  // Background buffer access for SNES layer rendering
  auto& bg1() { return bg1_; }
  
  auto& bg2() { return bg2_; }
 
 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_;
 
  std::array<gfx::Bitmap, 223> gfx_sheets_;
 
  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_;
  IRenderer* renderer_ = nullptr;
};
 
}  // namespace gfx
}  // namespace yaze
 
#endif  // YAZE_APP_GFX_ARENA_H