tilemap.h

Go to the documentation of this file.

#ifndef YAZE_GFX_TILEMAP_H
#define YAZE_GFX_TILEMAP_H
 
#include <list>
#include <memory>
#include <unordered_map>
 
#include "absl/container/flat_hash_map.h"
#include "app/gfx/backend/irenderer.h"
#include "app/gfx/core/bitmap.h"
#include "app/gfx/types/snes_tile.h"
 
namespace yaze {
namespace gfx {
 
struct Pair {
  int x;  
  int y;  
};
 
struct TileCache {
  static constexpr size_t MAX_CACHE_SIZE = 1024;
  // Use unique_ptr to ensure stable Bitmap* pointers across rehashing
  std::unordered_map<int, std::unique_ptr<Bitmap>> cache_;
  std::list<int> access_order_;
 
  Bitmap* GetTile(int tile_id) {
    auto it = cache_.find(tile_id);
    if (it != cache_.end()) {
      // Move to front of access order (most recently used)
      access_order_.remove(tile_id);
      access_order_.push_front(tile_id);
      return it->second.get();
    }
    return nullptr;
  }
 
  void CacheTile(int tile_id, const Bitmap& bitmap) {
    if (cache_.size() >= MAX_CACHE_SIZE) {
      // Remove least recently used tile
      int lru_tile = access_order_.back();
      access_order_.pop_back();
      cache_.erase(lru_tile);
    }
 
    cache_[tile_id] = std::make_unique<Bitmap>(bitmap);  // Copy, not move
    access_order_.push_front(tile_id);
  }
 
  void Clear() {
    cache_.clear();
    access_order_.clear();
  }
 
  size_t Size() const { return cache_.size(); }
};
 
struct Tilemap {
  Bitmap atlas;          
  TileCache tile_cache;  
  std::vector<std::array<gfx::TileInfo, 4>>
      tile_info;   
  Pair tile_size;  
  Pair map_size;   
};
 
std::vector<uint8_t> FetchTileDataFromGraphicsBuffer(
    const std::vector<uint8_t>& data, int tile_id, int sheet_offset);
 
Tilemap CreateTilemap(IRenderer* renderer, std::vector<uint8_t>& data,
                      int width, int height, int tile_size, int num_tiles,
                      SnesPalette& palette);
 
void UpdateTilemap(IRenderer* renderer, Tilemap& tilemap,
                   const std::vector<uint8_t>& data);
 
void RenderTile(IRenderer* renderer, Tilemap& tilemap, int tile_id);
 
void RenderTile16(IRenderer* renderer, Tilemap& tilemap, int tile_id);
void UpdateTile16(IRenderer* renderer, Tilemap& tilemap, int tile_id);
 
void ModifyTile16(Tilemap& tilemap, const std::vector<uint8_t>& data,
                  const TileInfo& top_left, const TileInfo& top_right,
                  const TileInfo& bottom_left, const TileInfo& bottom_right,
                  int sheet_offset, int tile_id);
 
void ComposeTile16(Tilemap& tilemap, const std::vector<uint8_t>& data,
                   const TileInfo& top_left, const TileInfo& top_right,
                   const TileInfo& bottom_left, const TileInfo& bottom_right,
                   int sheet_offset);
 
std::vector<uint8_t> GetTilemapData(Tilemap& tilemap, int tile_id);
 
void RenderTilesBatch(IRenderer* renderer, Tilemap& tilemap,
                      const std::vector<int>& tile_ids,
                      const std::vector<std::pair<float, float>>& positions,
                      const std::vector<std::pair<float, float>>& scales = {});
 
}  // namespace gfx
}  // namespace yaze
 
#endif  // YAZE_GFX_TILEMAP_H