painter.h

#pragma once
 
#include "sdl_painter/brush.h"
#include "sdl_painter/color.h"
#include "sdl_painter/export.h"
#include "sdl_painter/font.h"
#include "sdl_painter/frame_stats.h"
#include "sdl_painter/geometry.h"
// ImageFlip için — Image'ın kendisi ileri bildirimle yetiyordu, ancak
// DrawImage'ın varsayılan argümanı enum'un tam tanımını gerektiriyor.
#include "sdl_painter/image.h"
#include "sdl_painter/path.h"
#include "sdl_painter/pen.h"
#include "sdl_painter/render_target.h"
#include "sdl_painter/renderer.h"
#include "sdl_painter/vertex.h"
 
#include <cstddef>
#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 IRenderer;
class RenderBatcher;
 
struct RenderState {
  glm::mat3 transform{1.0F};  
  Pen pen;
  Brush brush;
  float opacity{1.0F};
  BlendMode blend_mode{BlendMode::kAlpha};
  Rect clip_rect;
  bool has_clip{false};
};
 
class SDLPAINTER_API Painter {
 public:
  Painter(SDL_Window* window, RendererBackend backend);
 
  Painter(std::unique_ptr<IRenderer> renderer, int32_t viewport_width,
          int32_t viewport_height);
 
  ~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();
 
  void SetDrawableSize(int32_t width, int32_t height);
 
  // --- Görüntü alanı (viewport) ---
 
  void SetViewport(int32_t x, int32_t y, int32_t width, int32_t height);
 
  void ResetViewport();
 
  // --- Çizim hedefi (dokuya çizim) ---
 
  [[nodiscard]] RenderTarget CreateRenderTarget(
      int32_t width, int32_t height,
      TextureFilter filter = TextureFilter::kLinear);
 
  bool SetRenderTarget(const RenderTarget& target);
 
  void ResetRenderTarget();
 
  void DrawRenderTarget(const RenderTarget& target, float x, float y,
                        const Color& tint = Color::White(),
                        ImageFlip flip = ImageFlip::kNone);
 
  void DrawRenderTarget(const RenderTarget& target, const Rect& dest_rect,
                        const Color& tint = Color::White(),
                        ImageFlip flip = ImageFlip::kNone);
 
  bool ReadRenderTarget(const RenderTarget& target,
                        std::vector<uint8_t>& out_rgba);
 
  // --- Temizlik ---
 
  void Clear(const Color& color);
 
  // --- Profilleme ---
 
  [[nodiscard]] const FrameStats& GetFrameStats() const noexcept {
    return mLastStats;
  }
 
  // --- Stil ---
 
  void SetPen(const Pen& pen);
 
  void SetBrush(const Brush& brush);
 
  void SetFont(std::shared_ptr<Font> font);
 
  [[nodiscard]] const std::shared_ptr<Font>& GetFont() const noexcept {
    return mCurrentFont;
  }
 
  void SetOpacity(float alpha);
 
  void SetBlendMode(BlendMode mode);
 
  [[nodiscard]] BlendMode GetBlendMode() const noexcept {
    return mCurrentState.blend_mode;
  }
 
  // --- 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 DrawRoundedRect(float x, float y, float w, float h, float radius);
 
  void FillRoundedRect(float x, float y, float w, float h, float radius);
 
  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 DrawArc(float cx, float cy, float rx, float ry, float start_degrees,
               float sweep_degrees);
 
  void DrawPie(float cx, float cy, float rx, float ry, float start_degrees,
               float sweep_degrees);
 
  void FillPie(float cx, float cy, float rx, float ry, float start_degrees,
               float sweep_degrees);
 
  void DrawChord(float cx, float cy, float rx, float ry, float start_degrees,
                 float sweep_degrees);
 
  void FillChord(float cx, float cy, float rx, float ry, float start_degrees,
                 float sweep_degrees);
 
  void DrawPolygon(const std::vector<Point>& points);
 
  void FillPolygon(const std::vector<Point>& points);
 
  void DrawPolyline(const std::vector<Point>& points);
 
  // --- Yol (path) ---
 
  void DrawPath(const Path& path);
 
  void FillPath(const Path& path);
 
  // --- Görüntü ---
 
  void DrawImage(const Image& image, float x, float y,
                 const Color& tint = Color::White(),
                 ImageFlip flip = ImageFlip::kNone);
 
  void DrawImage(const Image& image, const Rect& dest_rect,
                 const Color& tint = Color::White(),
                 ImageFlip flip = ImageFlip::kNone);
 
  void DrawImageMesh(const Image& image, int32_t cols, int32_t rows,
                     const std::vector<Point>& points,
                     const Color& tint = Color::White());
 
  void UpdateImage(const Image& image, const uint8_t* rgba);
 
  void DrawImage(const Image& image, const Rect& src_rect,
                 const Rect& dest_rect, const Color& tint = Color::White(),
                 ImageFlip flip = ImageFlip::kNone);
 
  // --- Metin
 
  void DrawText(float x, float y, const std::string& text);
 
  void DrawText(const Rect& rect, const std::string& text,
                Alignment alignment = Alignment::kLeft,
                TextWrap wrap = TextWrap::kNone);
 
  [[nodiscard]] std::size_t CountTextLines(const std::string& text,
                                           float max_width,
                                           TextWrap wrap) const;
 
  // --- 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 QueryDrawableSize(int32_t& out_width, int32_t& out_height) const;
 
  void ApplyDrawableSize(int32_t width, int32_t height);
 
  void UpdateProjection();
 
  [[nodiscard]] bool YAxisMatchesGpu() const;
 
  [[nodiscard]] int32_t SurfaceHeight() const;
 
  void ApplyViewport();
 
  void PushTexturedQuad(TextureHandle texture, float u0, float v0, float u1,
                        float v1, const Rect& dest_rect, const Color& tint,
                        ImageFlip flip);
 
  void PushStroke(const std::vector<Vertex>& verts, const Color& color);
 
  void PushFilled(std::vector<Vertex>& verts);
 
  void DrawTextLine(float x, float y, const std::string& text);
 
  [[nodiscard]] float AlignedX(const Rect& rect, const std::string& line,
                               Alignment alignment) const;
 
  void ApplyScissor(const Rect& rect);
 
  void ClearScissorCounted();
 
  [[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;
 
  FrameStats mStats;
  FrameStats mLastStats;
  uint64_t mFrameStartNs{0};
 
  int32_t mDrawableWidth{0};
  int32_t mDrawableHeight{0};
 
  int32_t mViewportX{0};
  int32_t mViewportY{0};
  int32_t mViewportWidth{0};
  int32_t mViewportHeight{0};
 
  bool mCustomViewport{false};
 
  RenderTargetHandle mActiveTarget{kInvalidRenderTarget};
  int32_t mTargetWidth{0};
  int32_t mTargetHeight{0};
 
  int32_t mSavedViewportX{0};
  int32_t mSavedViewportY{0};
  int32_t mSavedViewportWidth{0};
  int32_t mSavedViewportHeight{0};
  bool mSavedCustomViewport{false};
 
  bool mAutoDrawableSize{true};
};
 
}  // namespace sdl_painter