renderer.h

#pragma once
 
#include "sdl_painter/export.h"
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <vector>
 
// SDL forward declaration
struct SDL_Window;
 
namespace sdl_painter {
 
struct Color;
struct Vertex;
struct TexturedVertex;
 
using TextureHandle = uint32_t;
 
constexpr TextureHandle kInvalidTexture = 0;
 
using RenderTargetHandle = uint32_t;
 
constexpr RenderTargetHandle kInvalidRenderTarget = 0;
 
// Çizim hedeflerinin piksel formatı her backend'de **doğrusal RGBA8**'dir ve
// ekran yüzeyinin formatından (Vulkan'da tipik olarak B8G8R8A8_UNORM)
// kasıtlı olarak ayrıştırılmıştır — gerekçe ReadRenderTarget'ta.
 
enum class TextureFilter : uint8_t {
  kLinear,
  kNearest,
};
 
enum class BlendMode : uint8_t {
  kAlpha,
  kAdditive,
  kMultiply,
  kNone,
};
 
inline constexpr std::size_t kBlendModeCount = 4;
 
enum class RendererBackend : uint8_t {
  kOpenGL,
  kVulkan,
};
 
class IRenderer {
 public:
  IRenderer() = default;
  virtual ~IRenderer() = default;
 
  // Soyut arayüz: kopyalama/taşıma kapalı (object slicing önlenir).
  // Sahiplik daima std::unique_ptr<IRenderer> üzerinden taşınır.
  IRenderer(const IRenderer&) = delete;
  IRenderer& operator=(const IRenderer&) = delete;
  IRenderer(IRenderer&&) = delete;
  IRenderer& operator=(IRenderer&&) = delete;
 
  // --- Yaşam döngüsü ---
 
  virtual bool Initialize(SDL_Window* window) = 0;
 
  virtual void Shutdown() = 0;
 
  virtual void BeginFrame() = 0;
 
  virtual void EndFrame() = 0;
 
  // --- Durum ---
 
  virtual void SetViewport(int32_t x, int32_t y, int32_t width,
                           int32_t height) = 0;
 
  virtual void SetScissor(int32_t x, int32_t y, int32_t width,
                          int32_t height) = 0;
 
  virtual void ClearScissor() = 0;
 
  virtual void Clear(const Color& color) = 0;
 
  virtual void SetOpacity(float alpha) = 0;
 
  virtual void SetBlendMode(BlendMode mode) { (void)mode; }
 
  // --- Çizim primitifleri (tessellated vertex'ler) ---
 
  virtual void DrawTriangles(const std::vector<Vertex>& vertices) = 0;
 
  // --- Texture işlemleri ---
 
  virtual TextureHandle CreateTexture(const uint8_t* data, int32_t width,
                                      int32_t height, int32_t channels) = 0;
 
  virtual TextureHandle CreateTexture(const uint8_t* data, int32_t width,
                                      int32_t height, int32_t channels,
                                      TextureFilter filter) {
    (void)filter;
    return CreateTexture(data, width, height, channels);
  }
 
  virtual void UpdateTexture(TextureHandle handle, int32_t x, int32_t y,
                             int32_t width, int32_t height,
                             const uint8_t* data) = 0;
 
  virtual void DestroyTexture(TextureHandle handle) = 0;
 
  virtual void DrawTextured(const std::vector<TexturedVertex>& vertices,
                            TextureHandle texture) = 0;
 
  // --- Çizim hedefleri (offscreen render target) ---
  //
  // Aşağıdakilerin hiçbiri saf sanal DEĞİLDİR; varsayılan gövdeler "hedef
  // desteklenmiyor" anlamına gelir. Böylece bu arayüzü dışarıda implemente
  // etmiş kod derlenmeye devam eder (aynı yaklaşım SetBlendMode, filtreli
  // CreateTexture ve GetLastGpuFrameMs için de kullanılıyor).
 
  virtual RenderTargetHandle CreateRenderTarget(int32_t width, int32_t height,
                                                TextureFilter filter) {
    (void)width;
    (void)height;
    (void)filter;
    return kInvalidRenderTarget;
  }
 
  virtual void DestroyRenderTarget(RenderTargetHandle handle) { (void)handle; }
 
  [[nodiscard]] virtual TextureHandle GetRenderTargetTexture(
      RenderTargetHandle handle) const {
    (void)handle;
    return kInvalidTexture;
  }
 
  virtual bool SetRenderTarget(RenderTargetHandle handle) {
    (void)handle;
    return false;
  }
 
  virtual bool ReadRenderTarget(RenderTargetHandle handle, uint8_t* out_rgba,
                                std::size_t byte_capacity) {
    (void)handle;
    (void)out_rgba;
    (void)byte_capacity;
    return false;
  }
 
  // --- Transform ---
 
  [[nodiscard]] virtual RendererBackend GetBackend() const = 0;
 
  virtual void SetProjectionMatrix(const float* mat4) = 0;
 
  virtual void SetModelMatrix(const float* mat3) = 0;
 
  // --- Profilleme (isteğe bağlı) ---
 
  [[nodiscard]] virtual double GetLastGpuFrameMs() const { return 0.0; }
};
 
SDLPAINTER_API std::unique_ptr<IRenderer> CreateRenderer(
    RendererBackend backend);
 
}  // namespace sdl_painter