atlas_renderer.h

Go to the documentation of this file.

#ifndef YAZE_APP_GFX_ATLAS_RENDERER_H
#define YAZE_APP_GFX_ATLAS_RENDERER_H
 
#include "app/platform/sdl_compat.h"
 
#include <memory>
#include <unordered_map>
#include <vector>
 
#include "app/gfx/core/bitmap.h"
#include "app/gfx/debug/performance/performance_profiler.h"
#include "app/gfx/util/bpp_format_manager.h"
 
namespace yaze {
namespace gfx {
 
struct RenderCommand {
  int atlas_id;            
  float x, y;              
  float scale_x, scale_y;  
  float rotation;          
  SDL_Color tint;          
 
  RenderCommand(int id, float x_pos, float y_pos, float sx = 1.0f,
                float sy = 1.0f, float rot = 0.0f,
                SDL_Color color = {255, 255, 255, 255})
      : atlas_id(id),
        x(x_pos),
        y(y_pos),
        scale_x(sx),
        scale_y(sy),
        rotation(rot),
        tint(color) {}
};
 
struct AtlasStats {
  int total_atlases;
  int total_entries;
  int used_entries;
  size_t total_memory;
  size_t used_memory;
  float utilization_percent;
 
  AtlasStats()
      : total_atlases(0),
        total_entries(0),
        used_entries(0),
        total_memory(0),
        used_memory(0),
        utilization_percent(0.0f) {}
};
 
class AtlasRenderer {
 public:
  static AtlasRenderer& Get();
 
  void Initialize(IRenderer* renderer, int initial_size = 1024);
 
  int AddBitmap(const Bitmap& bitmap);
 
  int AddBitmapWithBppOptimization(const Bitmap& bitmap, BppFormat target_bpp);
 
  void RemoveBitmap(int atlas_id);
 
  void UpdateBitmap(int atlas_id, const Bitmap& bitmap);
 
  void RenderBatch(const std::vector<RenderCommand>& render_commands);
 
  void RenderBatchWithBppOptimization(
      const std::vector<RenderCommand>& render_commands,
      const std::unordered_map<BppFormat, std::vector<int>>& bpp_groups);
 
  AtlasStats GetStats() const;
 
  void Defragment();
 
  void Clear();
 
  void RenderBitmap(int atlas_id, float x, float y, float scale_x = 1.0f,
                    float scale_y = 1.0f);
 
  SDL_Rect GetUVCoordinates(int atlas_id) const;
 
 private:
  AtlasRenderer() = default;
  ~AtlasRenderer();
 
  struct AtlasEntry {
    int atlas_id;
    SDL_Rect uv_rect;  // UV coordinates in atlas
    TextureHandle texture;
    bool in_use;
    BppFormat bpp_format;  // BPP format of this entry
    int original_width;
    int original_height;
 
    AtlasEntry(int id, const SDL_Rect& rect, TextureHandle tex,
               BppFormat bpp = BppFormat::kBpp8, int width = 0, int height = 0)
        : atlas_id(id),
          uv_rect(rect),
          texture(tex),
          in_use(true),
          bpp_format(bpp),
          original_width(width),
          original_height(height) {}
  };
 
  struct Atlas {
    TextureHandle texture;
    int size;
    std::vector<AtlasEntry> entries;
    std::vector<bool> used_regions;  // Track used regions for packing
 
    Atlas(int s) : size(s), used_regions(s * s, false) {}
  };
 
  IRenderer* renderer_;
  std::vector<std::unique_ptr<Atlas>> atlases_;
  std::unordered_map<int, AtlasEntry*> atlas_lookup_;
  int next_atlas_id_;
  int current_atlas_;
 
  // Helper methods
  bool PackBitmap(Atlas& atlas, const Bitmap& bitmap, SDL_Rect& uv_rect);
  void CreateNewAtlas();
  void RebuildAtlas(Atlas& atlas);
  SDL_Rect FindFreeRegion(Atlas& atlas, int width, int height);
  void MarkRegionUsed(Atlas& atlas, const SDL_Rect& rect, bool used);
};
 
}  // namespace gfx
}  // namespace yaze
 
#endif  // YAZE_APP_GFX_ATLAS_RENDERER_H