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 <SDL.h>
#include <vector>
#include <unordered_map>
#include <memory>
 
#include "app/gfx/bitmap.h"
#include "app/gfx/performance/performance_profiler.h"
#include "app/gfx/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