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

  void Begin();

  void End();

  void SetDrawableSize(int32_t width, int32_t height);

  void SetViewport(int32_t x, int32_t y, int32_t width, int32_t height);

  void ResetViewport();

  [[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);

  void Clear(const Color& color);

  [[nodiscard]] const FrameStats& GetFrameStats() const noexcept {
    return mLastStats;
  }

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

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

  void DrawPath(const Path& path);

  void FillPath(const Path& path);

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

  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;

  void Save();

  void Restore();

  void Translate(float dx, float dy);

  void Rotate(float angle_degrees);

  void Scale(float sx, float sy);

  void ResetTransform();

  void SetClipRect(const Rect& rect);

  void ClearClip();
 
 private:
  friend class RenderTarget;

  void OnRenderTargetDestroyed(RenderTargetHandle handle);

  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 SurfaceWidth() const;

  [[nodiscard]] int32_t SurfaceHeight() const;

  [[nodiscard]] bool OwnsTarget(const RenderTarget& target) 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};

  std::shared_ptr<Painter*> mSelf;
};
 
}  // namespace sdl_painter