painter.h

#pragma once
 
#include "sdl_painter/brush.h"
#include "sdl_painter/color.h"
#include "sdl_painter/font.h"
#include "sdl_painter/geometry.h"
#include "sdl_painter/pen.h"
#include "sdl_painter/renderer.h"
 
#include <cstdint>
#include <glm/glm.hpp>
#include <memory>
#include <string>
#include <vector>
 
// SDL forward declaration
struct SDL_Window;
 
// Windows.h DrawText makrosu (DrawTextA/DrawTextW) ile ad çakışmasını önle.
#ifdef DrawText
#undef DrawText
#endif
 
namespace sdl_painter {
 
class Image;
class IRenderer;
class RenderBatcher;

struct RenderState {
  glm::mat3 transform{1.0F};  
  Pen pen;
  Brush brush;
  float opacity{1.0F};
  Rect clip_rect;
  bool has_clip{false};
};

class Painter {
 public:
  Painter(SDL_Window* window, RendererBackend backend);
  ~Painter();
 
  // Non-copyable, movable
  Painter(const Painter&) = delete;
  Painter& operator=(const Painter&) = delete;
  Painter(Painter&& other) noexcept;
  Painter& operator=(Painter&& other) noexcept;

  [[nodiscard]] bool IsValid() const noexcept { return mRenderer != nullptr; }
 
  // --- Yaşam döngüsü ---

  void Begin();

  void End();
 
  // --- Temizlik ---

  void Clear(const Color& color);
 
  // --- Stil ---

  void SetPen(const Pen& pen);

  void SetBrush(const Brush& brush);

  void SetFont(std::shared_ptr<Font> font);

  void SetOpacity(float alpha);
 
  // --- Primitifler ---

  void DrawLine(float x1, float y1, float x2, float y2);

  void DrawRect(float x, float y, float w, float h);

  void FillRect(float x, float y, float w, float h);

  void DrawCircle(float cx, float cy, float radius);

  void FillCircle(float cx, float cy, float radius);

  void DrawEllipse(float cx, float cy, float rx, float ry);

  void FillEllipse(float cx, float cy, float rx, float ry);

  void DrawPolygon(const std::vector<Point>& points);

  void FillPolygon(const std::vector<Point>& points);

  void DrawPolyline(const std::vector<Point>& points);
 
  // --- Görüntü ---

  void DrawImage(const Image& image, float x, float y);

  void DrawImage(const Image& image, const Rect& dest_rect);

  void DrawImage(const Image& image, const Rect& src_rect,
                 const Rect& dest_rect);
 
  // --- Metin (Phase 4) ---

  void DrawText(float x, float y, const std::string& text);

  void DrawText(const Rect& rect, const std::string& text,
                Alignment alignment = Alignment::kLeft);
 
  // --- Transform stack ---

  void Save();

  void Restore();

  void Translate(float dx, float dy);

  void Rotate(float angle_degrees);

  void Scale(float sx, float sy);

  void ResetTransform();
 
  // --- Kırpma ---

  void SetClipRect(const Rect& rect);

  void ClearClip();
 
 private:
  void UpdateProjection();

  void FlushTransform();

  void ApplyScissor(const Rect& rect);
 
  [[nodiscard]] bool CanDrawPen() const noexcept {
    return mRenderer && mBatcher && mCurrentState.pen.IsVisible();
  }
  [[nodiscard]] bool CanDrawBrush() const noexcept {
    return mRenderer && mBatcher && mCurrentState.brush.IsVisible();
  }
 
  SDL_Window* mWindow{nullptr};
 
  std::unique_ptr<IRenderer> mRenderer;
  std::unique_ptr<RenderBatcher> mBatcher;
  std::vector<RenderState> mStateStack;
  RenderState mCurrentState;
  std::shared_ptr<Font> mCurrentFont;
 
  int32_t mViewportWidth{0};
  int32_t mViewportHeight{0};
};
 
}  // namespace sdl_painter