xbintsc 0.5.21 → 0.5.23

package/runtime/ext_gui/canvas.h

@@ -19,7 +19,9 @@
 #define XT_GUI_CANVAS_H
 
 #include <cstdint>
+#include <memory>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 #include "image.h"
@@ -40,6 +42,8 @@ struct CanvasTransform {
   bool axis_aligned() const { return b == 0.0f && c == 0.0f; }
   /** Approximate uniform scale, used to size stroked lines and text. */
   float scale() const;
+  /** The inverse transform (device -> user space); identity when singular. */
+  CanvasTransform inverted() const;
 };
 
 /** A point in device (canvas) space. */
@@ -51,6 +55,51 @@ struct CanvasPoint {
 /** One subpath of the current path (device space). */
 using CanvasSubpath = std::vector<CanvasPoint>;
 
+/**
+ * A `CanvasGradient` handle: the colour stops plus the geometric definition of
+ * a linear or radial gradient. Gradients are owned by the canvas that created
+ * them, so a stale context handle resolves to no gradient instead of a dangling
+ * pointer. The DOM layer copies only the id around; the stops stay live, which
+ * is what makes `addColorStop` after `fillStyle = gradient` affect later fills.
+ */
+class CanvasGradient {
+ public:
+  enum class Type { Linear, Radial };
+
+  CanvasGradient(uint64_t id, Type type, float x0, float y0, float x1, float y1, float r0,
+                 float r1);
+
+  uint64_t id() const { return id_; }
+  Type type() const { return type_; }
+
+  /** Add a colour stop (offset clamped to 0..1, stops kept sorted by offset). */
+  void add_color_stop(float offset, const float color[4]);
+  /** Sample the gradient at a user-space point. A gradient with no stops is
+   * transparent black, so this always fills `out`. */
+  bool color_at(float x, float y, float out[4]) const;
+
+ private:
+  struct Stop {
+    float offset = 0.0f;
+    float color[4] = {0.0f, 0.0f, 0.0f, 1.0f};
+  };
+
+  uint64_t id_ = 0;
+  Type type_ = Type::Linear;
+  float x0_ = 0.0f, y0_ = 0.0f, x1_ = 0.0f, y1_ = 0.0f;
+  float r0_ = 0.0f, r1_ = 0.0f;
+  std::vector<Stop> stops_;
+};
+
+/** What a fill or stroke paints with: a solid colour, or a gradient sampled
+ * through the inverse of the current transform. `color` points into the
+ * canvas state and stays valid for the duration of one draw call. */
+struct CanvasPaint {
+  const float *color = nullptr;
+  const CanvasGradient *gradient = nullptr;
+  CanvasTransform inverse;
+};
+
 class Canvas2D {
  public:
   Canvas2D(int width, int height);
@@ -77,14 +126,30 @@ class Canvas2D {
   void transform(float a, float b, float c, float d, float e, float f);
   void set_transform(float a, float b, float c, float d, float e, float f);
   void reset_transform() { state_.transform = CanvasTransform(); }
+  const CanvasTransform &current_transform() const { return state_.transform; }
 
   /* -- style ------------------------------------------------------------- */
   void set_fill_style(const std::string &css);
   const std::string &fill_style() const { return state_.fill_style; }
   void set_stroke_style(const std::string &css);
   const std::string &stroke_style() const { return state_.stroke_style; }
+  /** Use a gradient created by this canvas (`0` restores the solid colour). */
+  void set_fill_gradient(uint64_t id);
+  void set_stroke_gradient(uint64_t id);
+  uint64_t fill_gradient_id() const { return state_.fill_gradient; }
+  uint64_t stroke_gradient_id() const { return state_.stroke_gradient; }
   void set_line_width(float width) { state_.line_width = width > 0.0f ? width : 0.0f; }
   float line_width() const { return state_.line_width; }
+  void set_line_cap(const std::string &value);
+  const std::string &line_cap() const { return state_.line_cap_string; }
+  void set_line_join(const std::string &value);
+  const std::string &line_join() const { return state_.line_join_string; }
+  void set_miter_limit(float limit);
+  float miter_limit() const { return state_.miter_limit; }
+  void set_line_dash(const std::vector<float> &segments);
+  const std::vector<float> &line_dash() const { return state_.line_dash; }
+  void set_line_dash_offset(float offset) { state_.line_dash_offset = offset; }
+  float line_dash_offset() const { return state_.line_dash_offset; }
   void set_global_alpha(float alpha);
   float global_alpha() const { return state_.global_alpha; }
   void set_font(const std::string &font);
@@ -94,13 +159,22 @@ class Canvas2D {
   void set_text_baseline(const std::string &value);
   const std::string &text_baseline() const { return state_.text_baseline_string; }
 
+  /* -- gradients --------------------------------------------------------- */
+  CanvasGradient *create_linear_gradient(float x0, float y0, float x1, float y1);
+  CanvasGradient *create_radial_gradient(float x0, float y0, float r0, float x1, float y1,
+                                         float r1);
+  CanvasGradient *find_gradient(uint64_t id) const;
+
   /* -- paths ------------------------------------------------------------- */
   void begin_path();
   void close_path();
   void move_to(float x, float y);
   void line_to(float x, float y);
   void rect(float x, float y, float width, float height);
+  void round_rect(float x, float y, float width, float height, float radius);
   void arc(float cx, float cy, float radius, float start, float end, bool counterclockwise);
+  void ellipse(float cx, float cy, float rx, float ry, float rotation, float start, float end,
+               bool counterclockwise);
   void quadratic_curve_to(float cpx, float cpy, float x, float y);
   void bezier_curve_to(float c1x, float c1y, float c2x, float c2y, float x, float y);
   void fill();
@@ -132,6 +206,11 @@ class Canvas2D {
     CanvasTransform transform;
     float line_width = 1.0f;
     float global_alpha = 1.0f;
+    int line_cap = 0;        // 0 butt, 1 round, 2 square
+    int line_join = 0;       // 0 miter, 1 round, 2 bevel
+    float miter_limit = 10.0f;
+    std::vector<float> line_dash;
+    float line_dash_offset = 0.0f;
     FontSpec font;
     std::string font_string = "10px sans-serif";
     int text_align = 0;      // 0 start/left, 1 center, 2 right/end
@@ -142,6 +221,10 @@ class Canvas2D {
     std::string stroke_style = "#000000";
     float fill_color[4] = {0.0f, 0.0f, 0.0f, 1.0f};
     float stroke_color[4] = {0.0f, 0.0f, 0.0f, 1.0f};
+    uint64_t fill_gradient = 0;
+    uint64_t stroke_gradient = 0;
+    std::string line_cap_string = "butt";
+    std::string line_join_string = "miter";
   };
 
   /** Transform a user-space point into device space. */
@@ -151,8 +234,23 @@ class Canvas2D {
   /** Add one device-space polygon loop to `out`. */
   void flatten_arc(float cx, float cy, float radius, float start, float end, bool ccw,
                    CanvasSubpath *out) const;
-  void stroke_subpath(const CanvasSubpath &points, bool closed, const float color[4]);
-  void paint_text(const std::string &text, float x, float y, const float color[4], bool stroke);
+  /** Append a flattened arc to the current subpath, moving/line-to its start as
+   * the canvas path rules require. Shared by `arc` and `ellipse`. */
+  void append_path_points(const CanvasSubpath &points);
+  /** Paint descriptors for the current state. */
+  CanvasPaint fill_paint() const;
+  CanvasPaint stroke_paint() const;
+  CanvasPaint make_paint(uint64_t gradient_id, const float color[4]) const;
+  void stroke_subpath(const CanvasSubpath &points, bool closed, const CanvasPaint &paint);
+  /** Stroke one polyline with caps and joins; `half` is half the device-space
+   * line width. Used by `stroke_subpath` for both solid and dashed paths. */
+  void stroke_polyline(const CanvasSubpath &points, bool closed, float half,
+                       const CanvasPaint &paint);
+  /** Split `points` into the "on" pieces of the current dash pattern. */
+  void dash_polyline(const CanvasSubpath &points, bool closed,
+                     std::vector<CanvasSubpath> *out) const;
+  void paint_text(const std::string &text, float x, float y, const CanvasPaint &paint,
+                  bool stroke);
 
   Image image_;
   uint64_t id_ = 0;
@@ -160,6 +258,7 @@ class Canvas2D {
   State state_;
   std::vector<State> stack_;
   std::vector<CanvasSubpath> path_;
+  std::unordered_map<uint64_t, std::unique_ptr<CanvasGradient>> gradients_;
 };
 
 /** The canvas with the given process-wide id, or null. Used by the renderer. */

package/runtime/ext_gui/canvas_gradient.cpp

@@ -0,0 +1,112 @@
+/*
+ * xbintsc GUI engine — CanvasGradient objects.
+ *
+ * A gradient is owned by the canvas that created it (`Canvas2D::gradients_`),
+ * so a handle that outlives the document resolves to no gradient instead of a
+ * dangling pointer. Colour stops stay live: a later `addColorStop` is visible
+ * to every fill that already uses the gradient, which is the canvas semantics
+ * the DOM layer exposes.
+ */
+
+#include <algorithm>
+#include <atomic>
+#include <cmath>
+
+#include "canvas.h"
+
+namespace xtgui {
+
+namespace {
+
+std::atomic<uint64_t> g_next_gradient_id{1};
+
+float clamp_unit(float value) {
+  if (value < 0.0f) return 0.0f;
+  if (value > 1.0f) return 1.0f;
+  return value;
+}
+
+}  // namespace
+
+CanvasGradient::CanvasGradient(uint64_t id, Type type, float x0, float y0, float x1, float y1,
+                               float r0, float r1)
+    : id_(id), type_(type), x0_(x0), y0_(y0), x1_(x1), y1_(y1), r0_(r0), r1_(r1) {}
+
+void CanvasGradient::add_color_stop(float offset, const float color[4]) {
+  Stop stop;
+  stop.offset = clamp_unit(offset);
+  for (int i = 0; i < 4; i++) stop.color[i] = color[i];
+  auto position = std::upper_bound(stops_.begin(), stops_.end(), stop,
+                                   [](const Stop &a, const Stop &b) { return a.offset < b.offset; });
+  stops_.insert(position, stop);
+}
+
+bool CanvasGradient::color_at(float x, float y, float out[4]) const {
+  if (stops_.empty()) {
+    out[0] = out[1] = out[2] = out[3] = 0.0f;
+    return true;
+  }
+  float t = 0.0f;
+  if (type_ == Type::Linear) {
+    const float dx = x1_ - x0_;
+    const float dy = y1_ - y0_;
+    const float lengthSquared = dx * dx + dy * dy;
+    if (lengthSquared > 1e-9f) {
+      t = ((x - x0_) * dx + (y - y0_) * dy) / lengthSquared;
+    }
+  } else {
+    const float dx = x - x1_;
+    const float dy = y - y1_;
+    const float distance = std::sqrt(dx * dx + dy * dy);
+    const float radiusDelta = r1_ - r0_;
+    if (std::fabs(radiusDelta) > 1e-6f) t = (distance - r0_) / radiusDelta;
+  }
+  t = clamp_unit(t);
+  if (t <= stops_.front().offset) {
+    for (int i = 0; i < 4; i++) out[i] = stops_.front().color[i];
+    return true;
+  }
+  if (t >= stops_.back().offset) {
+    for (int i = 0; i < 4; i++) out[i] = stops_.back().color[i];
+    return true;
+  }
+  for (size_t i = 1; i < stops_.size(); i++) {
+    const Stop &a = stops_[i - 1];
+    const Stop &b = stops_[i];
+    if (t > b.offset) continue;
+    const float span = b.offset - a.offset;
+    const float u = span > 1e-9f ? (t - a.offset) / span : 1.0f;
+    for (int channel = 0; channel < 4; channel++) {
+      out[channel] = a.color[channel] + (b.color[channel] - a.color[channel]) * u;
+    }
+    return true;
+  }
+  for (int i = 0; i < 4; i++) out[i] = stops_.back().color[i];
+  return true;
+}
+
+CanvasGradient *Canvas2D::create_linear_gradient(float x0, float y0, float x1, float y1) {
+  auto gradient = std::make_unique<CanvasGradient>(g_next_gradient_id.fetch_add(1),
+                                                   CanvasGradient::Type::Linear, x0, y0, x1, y1,
+                                                   0.0f, 1.0f);
+  CanvasGradient *raw = gradient.get();
+  gradients_[raw->id()] = std::move(gradient);
+  return raw;
+}
+
+CanvasGradient *Canvas2D::create_radial_gradient(float x0, float y0, float r0, float x1, float y1,
+                                                 float r1) {
+  auto gradient = std::make_unique<CanvasGradient>(g_next_gradient_id.fetch_add(1),
+                                                   CanvasGradient::Type::Radial, x0, y0, x1, y1, r0,
+                                                   r1);
+  CanvasGradient *raw = gradient.get();
+  gradients_[raw->id()] = std::move(gradient);
+  return raw;
+}
+
+CanvasGradient *Canvas2D::find_gradient(uint64_t id) const {
+  auto found = gradients_.find(id);
+  return found == gradients_.end() ? nullptr : found->second.get();
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/canvas_internal.h

@@ -21,22 +21,22 @@ namespace canvas_detail {
  * pixel. `alpha` folds in `globalAlpha`. */
 void blend_pixel(unsigned char *pixel, const float color[4], float coverage, float alpha);
 
-/** Fill one closed polygon loop (already in device space) with `color`,
+/** Fill one closed polygon loop (already in device space) with `paint`,
  * anti-aliased, blending source-over. */
 void fill_loop(std::vector<unsigned char> &pixels, int width, int height,
-               const std::vector<CanvasPoint> &loop, const float color[4], float alpha);
+               const std::vector<CanvasPoint> &loop, const CanvasPaint &paint, float alpha);
 
 /** Fill several loops as one path with the nonzero winding rule (so a contour
  * inside another punches a hole). */
 void fill_loops(std::vector<unsigned char> &pixels, int width, int height,
-                const std::vector<std::vector<CanvasPoint>> &loops, const float color[4],
+                const std::vector<std::vector<CanvasPoint>> &loops, const CanvasPaint &paint,
                 float alpha);
 
 /** Fill a device-space axis-aligned rectangle, anti-aliased. Used by the
  * `fillRect`/`clearRect` fast path when the transform preserves axis
  * alignment. */
 void fill_rect(std::vector<unsigned char> &pixels, int width, int height, float x0, float y0,
-               float x1, float y1, const float color[4], float alpha);
+               float x1, float y1, const CanvasPaint &paint, float alpha);
 
 /** Clear a device-space axis-aligned rectangle to transparent. */
 void clear_rect(std::vector<unsigned char> &pixels, int width, int height, float x0, float y0,
@@ -48,10 +48,10 @@ void draw_image(std::vector<unsigned char> &pixels, int width, int height, const
                 float dx, float dy, float dw, float dh, float sx, float sy, float sw, float sh,
                 float alpha);
 
-/** Composite one grayscale glyph bitmap at `(x, baselineY)` with `color`. */
+/** Composite one grayscale glyph bitmap at `(x, baselineY)` with `paint`. */
 void blit_glyph(std::vector<unsigned char> &pixels, int width, int height,
                 const std::vector<unsigned char> &glyph, int glyphWidth, int glyphHeight, int left,
-                int top, float x, float baselineY, const float color[4], float alpha);
+                int top, float x, float baselineY, const CanvasPaint &paint, float alpha);
 
 }  // namespace canvas_detail
 }  // namespace xtgui

package/runtime/ext_gui/canvas_raster.cpp

@@ -34,6 +34,22 @@ struct Crossing {
   int winding;
 };
 
+/** Resolve `paint` at a device-space pixel centre. Gradients are defined in
+ * user space, so the pixel is mapped back through the inverse transform. */
+void paint_color_at(const CanvasPaint &paint, float x, float y, float out[4]) {
+  if (paint.gradient != nullptr) {
+    const CanvasTransform &inverse = paint.inverse;
+    float userX = inverse.a * x + inverse.c * y + inverse.e;
+    float userY = inverse.b * x + inverse.d * y + inverse.f;
+    if (paint.gradient->color_at(userX, userY, out)) return;
+  }
+  if (paint.color != nullptr) {
+    for (int i = 0; i < 4; i++) out[i] = paint.color[i];
+    return;
+  }
+  out[0] = out[1] = out[2] = out[3] = 0.0f;
+}
+
 }  // namespace
 
 void blend_pixel(unsigned char *pixel, const float color[4], float coverage, float alpha) {
@@ -74,7 +90,7 @@ static void add_span(float *row, int rowOriginX, float xa, float xb, float weigh
 }
 
 void fill_loops(std::vector<unsigned char> &pixels, int width, int height,
-                const std::vector<std::vector<CanvasPoint>> &loops, const float color[4],
+                const std::vector<std::vector<CanvasPoint>> &loops, const CanvasPaint &paint,
                 float alpha) {
   if (width <= 0 || height <= 0 || loops.empty()) return;
   bool havePoint = false;
@@ -146,18 +162,20 @@ void fill_loops(std::vector<unsigned char> &pixels, int width, int height,
       float c = row[px];
       if (c <= 0.0f) continue;
       if (c > 1.0f) c = 1.0f;
+      float color[4];
+      paint_color_at(paint, (float)(x0 + px) + 0.5f, (float)py + 0.5f, color);
       blend_pixel(dst + (size_t)px * 4, color, c, alpha);
     }
   }
 }
 
 void fill_loop(std::vector<unsigned char> &pixels, int width, int height,
-               const std::vector<CanvasPoint> &loop, const float color[4], float alpha) {
-  fill_loops(pixels, width, height, std::vector<std::vector<CanvasPoint>>{loop}, color, alpha);
+               const std::vector<CanvasPoint> &loop, const CanvasPaint &paint, float alpha) {
+  fill_loops(pixels, width, height, std::vector<std::vector<CanvasPoint>>{loop}, paint, alpha);
 }
 
 void fill_rect(std::vector<unsigned char> &pixels, int width, int height, float x0, float y0,
-               float x1, float y1, const float color[4], float alpha) {
+               float x1, float y1, const CanvasPaint &paint, float alpha) {
   if (x1 < x0) std::swap(x0, x1);
   if (y1 < y0) std::swap(y0, y1);
   int ix0 = std::max(0, (int)std::floor(x0));
@@ -171,6 +189,8 @@ void fill_rect(std::vector<unsigned char> &pixels, int width, int height, float
     for (int px = ix0; px < ix1; px++) {
       float cx = std::min(x1, (float)(px + 1)) - std::max(x0, (float)px);
       if (cx <= 0.0f) continue;
+      float color[4];
+      paint_color_at(paint, (float)px + 0.5f, (float)py + 0.5f, color);
       blend_pixel(dst + (size_t)(px - ix0) * 4, color, cx * cy, alpha);
     }
   }
@@ -233,7 +253,7 @@ void draw_image(std::vector<unsigned char> &pixels, int width, int height, const
 
 void blit_glyph(std::vector<unsigned char> &pixels, int width, int height,
                 const std::vector<unsigned char> &glyph, int glyphWidth, int glyphHeight, int left,
-                int top, float x, float baselineY, const float color[4], float alpha) {
+                int top, float x, float baselineY, const CanvasPaint &paint, float alpha) {
   int originX = (int)std::lround(x) + left;
   int originY = (int)std::lround(baselineY) - top;
   for (int gy = 0; gy < glyphHeight; gy++) {
@@ -244,6 +264,8 @@ void blit_glyph(std::vector<unsigned char> &pixels, int width, int height,
       if (px < 0 || px >= width) continue;
       float coverage = glyph[(size_t)gy * (size_t)glyphWidth + (size_t)gx] / 255.0f;
       if (coverage <= 0.0f) continue;
+      float color[4];
+      paint_color_at(paint, (float)px + 0.5f, (float)py + 0.5f, color);
       blend_pixel(pixels.data() + ((size_t)py * (size_t)width + (size_t)px) * 4, color, coverage,
                   alpha);
     }

package/runtime/ext_gui/canvas_stroke.cpp

@@ -0,0 +1,252 @@
+/*
+ * xbintsc GUI engine — Canvas2D stroking.
+ *
+ * A stroked path is flattened into segments; each segment becomes a quad and
+ * every joint/cap is filled with the shape the current `lineJoin`/`lineCap`
+ * asks for. Dash patterns split a polyline into the "on" pieces first, so a
+ * dashed stroke is just a set of open polylines with the same cap rules.
+ *
+ * Everything here works in device space: `canvas.cpp` flattens the path and
+ * passes the paint (solid colour or gradient) through.
+ */
+
+#include <algorithm>
+#include <cmath>
+#include <vector>
+
+#include "canvas_internal.h"
+
+namespace xtgui {
+
+namespace {
+
+constexpr float kPi = 3.14159265358979323846f;
+
+CanvasPoint lerp_point(const CanvasPoint &a, const CanvasPoint &b, float t) {
+  return CanvasPoint{a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t};
+}
+
+bool same_point(const CanvasPoint &a, const CanvasPoint &b) {
+  return std::fabs(a.x - b.x) < 1e-6f && std::fabs(a.y - b.y) < 1e-6f;
+}
+
+}  // namespace
+
+void Canvas2D::stroke_subpath(const CanvasSubpath &points, bool closed, const CanvasPaint &paint) {
+  if (points.size() < 2) return;
+  float scale = state_.transform.scale();
+  if (!(scale > 0.0f)) scale = 1.0f;
+  float half = state_.line_width * scale * 0.5f;
+  if (half <= 0.0f) half = 0.5f;
+  if (!state_.line_dash.empty()) {
+    std::vector<CanvasSubpath> pieces;
+    dash_polyline(points, closed, &pieces);
+    for (const CanvasSubpath &piece : pieces) stroke_polyline(piece, false, half, paint);
+    return;
+  }
+  stroke_polyline(points, closed, half, paint);
+}
+
+void Canvas2D::stroke_polyline(const CanvasSubpath &points, bool closed, float half,
+                               const CanvasPaint &paint) {
+  CanvasSubpath pts = points;
+  if (closed && !same_point(pts.front(), pts.back())) pts.push_back(pts.front());
+  const size_t n = pts.size();
+  if (n < 2) return;
+
+  auto fill_loop = [&](const CanvasSubpath &loop) {
+    canvas_detail::fill_loop(image_.pixels, image_.width, image_.height, loop, paint,
+                             state_.global_alpha);
+  };
+  auto fill_disc = [&](const CanvasPoint &p) {
+    CanvasSubpath disc;
+    const int segments = 24;
+    disc.reserve((size_t)segments);
+    for (int i = 0; i < segments; i++) {
+      float angle = 2.0f * kPi * ((float)i / (float)segments);
+      disc.push_back(CanvasPoint{p.x + half * std::cos(angle), p.y + half * std::sin(angle)});
+    }
+    fill_loop(disc);
+  };
+
+  /* Segments. A square cap extends the first/last quad along the line by half
+   * the width; round caps add a disc at the endpoints below. */
+  for (size_t i = 0; i + 1 < n; i++) {
+    CanvasPoint p = pts[i];
+    CanvasPoint q = pts[i + 1];
+    float dx = q.x - p.x;
+    float dy = q.y - p.y;
+    float length = std::sqrt(dx * dx + dy * dy);
+    if (length <= 1e-6f) continue;
+    float ux = dx / length;
+    float uy = dy / length;
+    float nx = -uy * half;
+    float ny = ux * half;
+    if (!closed && i == 0 && state_.line_cap == 2) {
+      p.x -= ux * half;
+      p.y -= uy * half;
+    }
+    if (!closed && i + 2 == n && state_.line_cap == 2) {
+      q.x += ux * half;
+      q.y += uy * half;
+    }
+    CanvasSubpath quad{CanvasPoint{p.x + nx, p.y + ny}, CanvasPoint{q.x + nx, q.y + ny},
+                       CanvasPoint{q.x - nx, q.y - ny}, CanvasPoint{p.x - nx, p.y - ny}};
+    fill_loop(quad);
+  }
+
+  /* Joins: round adds a disc, bevel a triangle, miter the intersect of the two
+   * outer offset lines (clamped by `miterLimit`). */
+  auto add_join = [&](const CanvasPoint &previous, const CanvasPoint &p, const CanvasPoint &next) {
+    float v1x = p.x - previous.x;
+    float v1y = p.y - previous.y;
+    float v2x = next.x - p.x;
+    float v2y = next.y - p.y;
+    float len1 = std::sqrt(v1x * v1x + v1y * v1y);
+    float len2 = std::sqrt(v2x * v2x + v2y * v2y);
+    if (len1 <= 1e-6f || len2 <= 1e-6f) return;
+    v1x /= len1;
+    v1y /= len1;
+    v2x /= len2;
+    v2y /= len2;
+    float cross = v1x * v2y - v1y * v2x;
+    if (std::fabs(cross) < 1e-6f) return;
+    if (state_.line_join == 1) {
+      fill_disc(p);
+      return;
+    }
+    /* The outer side is the opposite side of the turn. */
+    float side = cross > 0.0f ? -1.0f : 1.0f;
+    CanvasPoint a{p.x - v1y * half * side, p.y + v1x * half * side};
+    CanvasPoint b{p.x - v2y * half * side, p.y + v2x * half * side};
+    if (state_.line_join == 2) {
+      fill_loop(CanvasSubpath{a, b, p});
+      return;
+    }
+    float t = ((b.x - a.x) * v2y - (b.y - a.y) * v2x) / cross;
+    CanvasPoint miter{a.x + v1x * t, a.y + v1y * t};
+    float miterLength = std::sqrt((miter.x - p.x) * (miter.x - p.x) +
+                                  (miter.y - p.y) * (miter.y - p.y));
+    if (std::isfinite(miterLength) && miterLength <= half * state_.miter_limit) {
+      fill_loop(CanvasSubpath{a, miter, b, p});
+    } else {
+      fill_loop(CanvasSubpath{a, b, p});
+    }
+  };
+
+  if (closed) {
+    const size_t unique = n - 1;
+    for (size_t i = 0; i < unique; i++) {
+      const CanvasPoint &previous = pts[(i + unique - 1) % unique];
+      const CanvasPoint &next = pts[(i + 1) % unique];
+      add_join(previous, pts[i], next);
+    }
+  } else {
+    for (size_t i = 1; i + 1 < n; i++) add_join(pts[i - 1], pts[i], pts[i + 1]);
+    if (state_.line_cap == 1) {
+      fill_disc(pts.front());
+      fill_disc(pts.back());
+    }
+  }
+}
+
+void Canvas2D::dash_polyline(const CanvasSubpath &points, bool closed,
+                             std::vector<CanvasSubpath> *out) const {
+  if (points.size() < 2) return;
+  float scale = state_.transform.scale();
+  if (!(scale > 0.0f)) scale = 1.0f;
+  std::vector<float> pattern;
+  pattern.reserve(state_.line_dash.size());
+  float total = 0.0f;
+  for (float entry : state_.line_dash) {
+    pattern.push_back(entry * scale);
+    total += entry * scale;
+  }
+  if (pattern.empty() || total <= 1e-6f) {
+    out->push_back(points);
+    return;
+  }
+
+  CanvasSubpath pts = points;
+  if (closed && !same_point(pts.front(), pts.back())) pts.push_back(pts.front());
+  const size_t n = pts.size();
+
+  /* Consume `lineDashOffset` from the repeating pattern before drawing. */
+  float dashOffset = state_.line_dash_offset;
+  if (!std::isfinite(dashOffset)) dashOffset = 0.0f;
+  float offset = std::fmod(dashOffset * scale, total);
+  if (offset < 0.0f) offset += total;
+  size_t index = 0;
+  float remain = pattern[0];
+  int guard = 0;
+  while (offset > 1e-6f && guard++ < 100000) {
+    if (offset >= remain) {
+      offset -= remain;
+      index = (index + 1) % pattern.size();
+      remain = pattern[index];
+    } else {
+      remain -= offset;
+      offset = 0.0f;
+    }
+  }
+  auto skip_empty = [&]() {
+    int skipped = 0;
+    while (remain <= 1e-6f && skipped++ < 100000) {
+      index = (index + 1) % pattern.size();
+      remain = pattern[index];
+    }
+  };
+  skip_empty();
+  bool on = (index % 2 == 0);
+
+  CanvasSubpath current;
+  bool have_current = false;
+  auto finish_dash = [&]() {
+    if (have_current) {
+      out->push_back(current);
+      current.clear();
+      have_current = false;
+    }
+  };
+
+  for (size_t i = 0; i + 1 < n; i++) {
+    const CanvasPoint &p = pts[i];
+    const CanvasPoint &q = pts[i + 1];
+    float dx = q.x - p.x;
+    float dy = q.y - p.y;
+    float length = std::sqrt(dx * dx + dy * dy);
+    if (length <= 1e-6f) continue;
+    float position = 0.0f;
+    while (position < length - 1e-6f) {
+      if (remain <= 1e-6f) {
+        skip_empty();
+        on = (index % 2 == 0);
+        continue;
+      }
+      float step = std::min(remain, length - position);
+      if (on) {
+        if (!have_current) {
+          current.clear();
+          current.push_back(lerp_point(p, q, position / length));
+          have_current = true;
+        }
+        position += step;
+        current.push_back(lerp_point(p, q, position / length));
+      } else {
+        position += step;
+      }
+      remain -= step;
+      if (remain <= 1e-6f) {
+        if (on) finish_dash();
+        index = (index + 1) % pattern.size();
+        remain = pattern[index];
+        on = (index % 2 == 0);
+        skip_empty();
+        on = (index % 2 == 0);
+      }
+    }
+  }
+  finish_dash();
+}
+
+}  // namespace xtgui