renderer.h

#pragma once
 
#include "sdl_painter/export.h"
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <vector>
 
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;

  virtual bool Initialize(SDL_Window* window) = 0;

  virtual void Shutdown() = 0;

  virtual void BeginFrame() = 0;

  virtual void EndFrame() = 0;

  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; }

  virtual void DrawTriangles(const std::vector<Vertex>& vertices) = 0;

  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;
 
  //
  // 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;
  }

  [[nodiscard]] virtual RendererBackend GetBackend() const = 0;

  virtual void SetProjectionMatrix(const float* mat4) = 0;

  virtual void SetModelMatrix(const float* mat3) = 0;

  [[nodiscard]] virtual double GetLastGpuFrameMs() const { return 0.0; }
};

SDLPAINTER_API std::unique_ptr<IRenderer> CreateRenderer(
    RendererBackend backend);
 
}  // namespace sdl_painter