xbintsc 0.5.38 → 0.5.41

package/runtime/ext_gui/canvas.cpp

@@ -16,6 +16,7 @@
 #include <unordered_map>
 
 #include "canvas_internal.h"
+#include "perf.h"
 
 namespace xtgui {
 
@@ -85,11 +86,16 @@ void Canvas2D::resize(int width, int height) {
   image_.width = width;
   image_.height = height;
   image_.pixels.assign((size_t)width * (size_t)height * 4, 0);
+  /* The DOM resets the rendering context when the bitmap is resized; the clip
+   * region in particular has device-space dimensions and cannot survive. */
+  state_.clip.reset();
+  shadow_layer_.pixels.clear();
   if (!alpha_) {
     /* `{ alpha: false }`: the canvas has an opaque black backdrop, so cleared
      * pixels are black rather than transparent. */
     for (size_t i = 3; i < image_.pixels.size(); i += 4) image_.pixels[i] = 255;
   }
+  mark_all_dirty();
   generation_++;
 }
 
@@ -292,6 +298,57 @@ void Canvas2D::to_device(float x, float y, float *outX, float *outY) const {
   state_.transform.apply(x, y, outX, outY);
 }
 
+void Canvas2D::mark_dirty(float x0, float y0, float x1, float y1) {
+  if (x1 < x0) std::swap(x0, x1);
+  if (y1 < y0) std::swap(y0, y1);
+  const int ix0 = std::max(0, (int)std::floor(x0));
+  const int iy0 = std::max(0, (int)std::floor(y0));
+  const int ix1 = std::min(image_.width, (int)std::ceil(x1));
+  const int iy1 = std::min(image_.height, (int)std::ceil(y1));
+  if (ix1 <= ix0 || iy1 <= iy0) return;
+  if (dirty_.empty()) {
+    dirty_ = CanvasDirtyRect{ix0, iy0, ix1, iy1};
+    return;
+  }
+  dirty_.x0 = std::min(dirty_.x0, ix0);
+  dirty_.y0 = std::min(dirty_.y0, iy0);
+  dirty_.x1 = std::max(dirty_.x1, ix1);
+  dirty_.y1 = std::max(dirty_.y1, iy1);
+}
+
+void Canvas2D::mark_path_dirty(const std::vector<CanvasSubpath> &subpaths, float expand) {
+  bool have = false;
+  float minX = 0.0f, maxX = 0.0f, minY = 0.0f, maxY = 0.0f;
+  for (const CanvasSubpath &subpath : subpaths) {
+    for (const CanvasPoint &point : subpath) {
+      if (!have) {
+        minX = maxX = point.x;
+        minY = maxY = point.y;
+        have = true;
+      } else {
+        minX = std::min(minX, point.x);
+        maxX = std::max(maxX, point.x);
+        minY = std::min(minY, point.y);
+        maxY = std::max(maxY, point.y);
+      }
+    }
+  }
+  if (!have) return;
+  mark_dirty(minX - expand, minY - expand, maxX + expand, maxY + expand);
+}
+
+void Canvas2D::mark_all_dirty() {
+  dirty_ = CanvasDirtyRect{0, 0, image_.width, image_.height};
+}
+
+float Canvas2D::stroke_extent() const {
+  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;
+  return half * std::max(1.0f, state_.miter_limit) + 1.0f;
+}
+
 std::vector<CanvasSubpath> Canvas2D::device_subpaths() const {
   return device_subpaths_of(path_);
 }
@@ -320,6 +377,7 @@ CanvasPaint Canvas2D::make_paint(uint64_t gradient_id, uint64_t pattern_id,
   paint.gradient = gradient_id == 0 ? nullptr : find_gradient(gradient_id);
   paint.pattern = pattern_id == 0 ? nullptr : find_pattern(pattern_id);
   paint.inverse = state_.transform.inverted();
+  paint.composite = state_.global_composite;
   return paint;
 }
 
@@ -332,6 +390,12 @@ CanvasPaint Canvas2D::stroke_paint() const {
 }
 
 void Canvas2D::fill(bool even_odd) {
+  if (begin_shadow_layer()) {
+    fill(even_odd);
+    end_shadow_layer();
+    return;
+  }
+  g_perf_frame.canvasDraws += 1;
   std::vector<CanvasSubpath> subpaths = device_subpaths();
   std::vector<CanvasSubpath> loops;
   for (CanvasSubpath &subpath : subpaths) {
@@ -339,12 +403,19 @@ void Canvas2D::fill(bool even_odd) {
     loops.push_back(std::move(subpath));
   }
   if (loops.empty()) return;
+  mark_path_dirty(loops, 0.0f);
   canvas_detail::fill_loops(image_.pixels, image_.width, image_.height, loops, fill_paint(),
-                            state_.global_alpha, even_odd);
+                            state_.global_alpha, even_odd, clip_mask());
   generation_++;
 }
 
 void Canvas2D::fill_paths(const std::vector<CanvasSubpath> &paths, bool even_odd) {
+  if (begin_shadow_layer()) {
+    fill_paths(paths, even_odd);
+    end_shadow_layer();
+    return;
+  }
+  g_perf_frame.canvasDraws += 1;
   std::vector<CanvasSubpath> subpaths = device_subpaths_of(paths);
   std::vector<CanvasSubpath> loops;
   for (CanvasSubpath &subpath : subpaths) {
@@ -352,13 +423,21 @@ void Canvas2D::fill_paths(const std::vector<CanvasSubpath> &paths, bool even_odd
     loops.push_back(std::move(subpath));
   }
   if (loops.empty()) return;
+  mark_path_dirty(loops, 0.0f);
   canvas_detail::fill_loops(image_.pixels, image_.width, image_.height, loops, fill_paint(),
-                            state_.global_alpha, even_odd);
+                            state_.global_alpha, even_odd, clip_mask());
   generation_++;
 }
 
 void Canvas2D::stroke() {
+  if (begin_shadow_layer()) {
+    stroke();
+    end_shadow_layer();
+    return;
+  }
+  g_perf_frame.canvasDraws += 1;
   std::vector<CanvasSubpath> subpaths = device_subpaths();
+  mark_path_dirty(subpaths, stroke_extent());
   const CanvasPaint paint = stroke_paint();
   for (const CanvasSubpath &subpath : subpaths) {
     if (subpath.size() < 2) continue;
@@ -370,7 +449,14 @@ void Canvas2D::stroke() {
 }
 
 void Canvas2D::stroke_paths(const std::vector<CanvasSubpath> &paths) {
+  if (begin_shadow_layer()) {
+    stroke_paths(paths);
+    end_shadow_layer();
+    return;
+  }
+  g_perf_frame.canvasDraws += 1;
   std::vector<CanvasSubpath> subpaths = device_subpaths_of(paths);
+  mark_path_dirty(subpaths, stroke_extent());
   const CanvasPaint paint = stroke_paint();
   for (const CanvasSubpath &subpath : subpaths) {
     if (subpath.size() < 2) continue;
@@ -382,20 +468,30 @@ void Canvas2D::stroke_paths(const std::vector<CanvasSubpath> &paths) {
 }
 
 void Canvas2D::clear_rect(float x, float y, float width, float height) {
+  g_perf_frame.canvasDraws += 1;
   float x0, y0, x1, y1;
   to_device(x, y, &x0, &y0);
   to_device(x + width, y + height, &x1, &y1);
-  canvas_detail::clear_rect(image_.pixels, image_.width, image_.height, x0, y0, x1, y1);
+  mark_dirty(x0, y0, x1, y1);
+  canvas_detail::clear_rect(image_.pixels, image_.width, image_.height, x0, y0, x1, y1,
+                            clip_mask());
   generation_++;
 }
 
 void Canvas2D::fill_rect(float x, float y, float width, float height) {
+  if (begin_shadow_layer()) {
+    fill_rect(x, y, width, height);
+    end_shadow_layer();
+    return;
+  }
+  g_perf_frame.canvasDraws += 1;
   if (state_.transform.axis_aligned()) {
     float x0, y0, x1, y1;
     to_device(x, y, &x0, &y0);
     to_device(x + width, y + height, &x1, &y1);
+    mark_dirty(x0, y0, x1, y1);
     canvas_detail::fill_rect(image_.pixels, image_.width, image_.height, x0, y0, x1, y1,
-                             fill_paint(), state_.global_alpha);
+                             fill_paint(), state_.global_alpha, clip_mask());
   } else {
     CanvasSubpath loop;
     const float corners[4][2] = {
@@ -405,13 +501,20 @@ void Canvas2D::fill_rect(float x, float y, float width, float height) {
       to_device(corner[0], corner[1], &point.x, &point.y);
       loop.push_back(point);
     }
+    mark_path_dirty(std::vector<CanvasSubpath>{loop}, 0.0f);
     canvas_detail::fill_loop(image_.pixels, image_.width, image_.height, loop, fill_paint(),
-                             state_.global_alpha);
+                             state_.global_alpha, false, clip_mask());
   }
   generation_++;
 }
 
 void Canvas2D::stroke_rect(float x, float y, float width, float height) {
+  if (begin_shadow_layer()) {
+    stroke_rect(x, y, width, height);
+    end_shadow_layer();
+    return;
+  }
+  g_perf_frame.canvasDraws += 1;
   CanvasSubpath loop;
   const float corners[5][2] = {
       {x, y}, {x + width, y}, {x + width, y + height}, {x, y + height}, {x, y}};
@@ -421,103 +524,46 @@ void Canvas2D::stroke_rect(float x, float y, float width, float height) {
     loop.push_back(point);
   }
   stroke_subpath(loop, true, stroke_paint());
+  mark_path_dirty(std::vector<CanvasSubpath>{loop}, stroke_extent());
   generation_++;
 }
 
-float Canvas2D::measure_text(const std::string &text) const {
-  return xt_text_measure_width(text, state_.font);
-}
-
-void Canvas2D::paint_text(const std::string &text, float x, float y, const CanvasPaint &paint,
-                          bool stroke, float max_width) {
-  Font *font = xt_text_resolve(state_.font);
-  if (font == nullptr) return;
-  std::vector<ShapedGlyph> glyphs;
-  float width = xt_text_shape_run(text, font, glyphs);
-  float ascent = 0.0f, descent = 0.0f, lineHeight = 0.0f;
-  xt_text_metrics(state_.font, &ascent, &descent, &lineHeight);
-
-  /* The optional `maxWidth` condenses the run horizontally instead of clipping
-   * it: advances and glyph bitmaps are squeezed by the same factor. */
-  float horizontal = 1.0f;
-  if (max_width > 0.0f && width > max_width && width > 0.0001f) {
-    horizontal = max_width / width;
-  }
-
-  float originX = x;
-  if (state_.text_align == 1) {
-    originX -= width * horizontal * 0.5f;
-  } else if (state_.text_align == 2) {
-    originX -= width * horizontal;
-  }
-  float originY = y;
-  switch (state_.text_baseline) {
-    case 1:
-      originY += ascent;
-      break;
-    case 2:
-      originY += (ascent - descent) * 0.5f;
-      break;
-    case 3:
-      originY -= descent;
-      break;
-    case 4:
-      originY += ascent * 0.8f;
-      break;
-    case 5:
-      originY -= descent;
-      break;
-    default:
-      break;
-  }
-
-  float scale = state_.transform.scale();
-  if (scale <= 0.0001f) scale = 1.0f;
-  bool scaled = std::fabs(scale - 1.0f) > 0.01f;
-
-  float penX = 0.0f;
-  for (const ShapedGlyph &glyph : glyphs) {
-    float userX = originX + (penX + glyph.x_offset) * horizontal;
-    float userY = originY + glyph.y_offset;
-    float deviceX = 0.0f, deviceY = 0.0f;
-    to_device(userX, userY, &deviceX, &deviceY);
-    Font *face = glyph.font != nullptr ? glyph.font : font;
-    if (scaled) {
-      Font *sized = xt_text_scale(face, state_.font.pixel_size * scale);
-      if (sized != nullptr) face = sized;
-    }
-    GlyphImage image;
-    if (xt_text_rasterize(face, glyph.glyph, image) && image.width > 0 && image.height > 0) {
-      canvas_detail::blit_glyph(image_.pixels, image_.width, image_.height, image.pixels, image.width,
-                                image.height, image.left, image.top, deviceX, deviceY, horizontal,
-                                paint, state_.global_alpha);
-    }
-    penX += glyph.x_advance;
-  }
-  (void)stroke;
-  generation_++;
-}
-
-void Canvas2D::fill_text(const std::string &text, float x, float y, float max_width) {
-  paint_text(text, x, y, fill_paint(), false, max_width);
-}
-
-void Canvas2D::stroke_text(const std::string &text, float x, float y, float max_width) {
-  paint_text(text, x, y, stroke_paint(), true, max_width);
-}
-
 void Canvas2D::draw_image(const Image &source, float dx, float dy, float dw, float dh, float sx,
                           float sy, float sw, float sh) {
+  if (begin_shadow_layer()) {
+    draw_image(source, dx, dy, dw, dh, sx, sy, sw, sh);
+    end_shadow_layer();
+    return;
+  }
+  g_perf_frame.canvasDraws += 1;
   if (state_.transform.axis_aligned()) {
     float x0, y0, x1, y1;
     to_device(dx, dy, &x0, &y0);
     to_device(dx + dw, dy + dh, &x1, &y1);
+    mark_dirty(x0, y0, x1, y1);
     canvas_detail::draw_image(image_.pixels, image_.width, image_.height, source, x0, y0, x1 - x0,
-                              y1 - y0, sx, sy, sw, sh, state_.global_alpha);
+                              y1 - y0, sx, sy, sw, sh, state_.global_alpha,
+                              state_.image_smoothing, clip_mask());
   } else {
+    float minX = 0.0f, minY = 0.0f, maxX = 0.0f, maxY = 0.0f;
+    const float corners[4][2] = {{dx, dy}, {dx + dw, dy}, {dx + dw, dy + dh}, {dx, dy + dh}};
+    for (int i = 0; i < 4; i++) {
+      float px = 0.0f, py = 0.0f;
+      to_device(corners[i][0], corners[i][1], &px, &py);
+      if (i == 0) {
+        minX = maxX = px;
+        minY = maxY = py;
+      } else {
+        minX = std::min(minX, px);
+        maxX = std::max(maxX, px);
+        minY = std::min(minY, py);
+        maxY = std::max(maxY, py);
+      }
+    }
+    mark_dirty(minX, minY, maxX, maxY);
     canvas_detail::draw_image_affine(image_.pixels, image_.width, image_.height, source, dx, dy,
                                      dw, dh, sx, sy, sw, sh, state_.transform,
-                                     state_.global_alpha);
+                                     state_.global_alpha, state_.image_smoothing, clip_mask());
   }
   generation_++;
 }

package/runtime/ext_gui/canvas.h

@@ -52,6 +52,18 @@ struct CanvasPoint {
   float y = 0.0f;
 };
 
+/** One clip region: per-pixel coverage (0 = fully clipped, 255 = kept). A clip
+ * is baked into device space when `clip()` runs, exactly like a browser. */
+struct CanvasClipMask {
+  std::vector<uint8_t> data;
+  int width = 0;
+  int height = 0;
+  uint8_t at(int x, int y) const {
+    if (x < 0 || y < 0 || x >= width || y >= height) return 0;
+    return data[(size_t)y * (size_t)width + (size_t)x];
+  }
+};
+
 /** One subpath of the current path (device space). */
 using CanvasSubpath = std::vector<CanvasPoint>;
 
@@ -94,6 +106,36 @@ class CanvasGradient {
 class CanvasGradient;
 class CanvasPattern;
 
+/** `globalCompositeOperation` values, in the order the DOM layer maps names. */
+enum CanvasComposite {
+  kCanvasCompositeSourceOver = 0,
+  kCanvasCompositeSourceIn,
+  kCanvasCompositeSourceOut,
+  kCanvasCompositeSourceAtop,
+  kCanvasCompositeDestinationOver,
+  kCanvasCompositeDestinationIn,
+  kCanvasCompositeDestinationOut,
+  kCanvasCompositeDestinationAtop,
+  kCanvasCompositeLighter,
+  kCanvasCompositeCopy,
+  kCanvasCompositeXor,
+  kCanvasCompositeMultiply,
+  kCanvasCompositeScreen,
+  kCanvasCompositeOverlay,
+  kCanvasCompositeDarken,
+  kCanvasCompositeLighten,
+  kCanvasCompositeColorDodge,
+  kCanvasCompositeColorBurn,
+  kCanvasCompositeHardLight,
+  kCanvasCompositeSoftLight,
+  kCanvasCompositeDifference,
+  kCanvasCompositeExclusion,
+  kCanvasCompositeHue,
+  kCanvasCompositeSaturation,
+  kCanvasCompositeColor,
+  kCanvasCompositeLuminosity,
+};
+
 /** What a fill or stroke paints with: a solid colour, a gradient sampled through
  * the inverse of the current transform, or a repeating image pattern. `color`
  * points into the canvas state and stays valid for one draw call. */
@@ -102,6 +144,8 @@ struct CanvasPaint {
   const CanvasGradient *gradient = nullptr;
   const CanvasPattern *pattern = nullptr;
   CanvasTransform inverse;
+  /** `globalCompositeOperation` as the `CanvasComposite` enum value. */
+  int composite = 0;
 };
 
 /**
@@ -136,6 +180,15 @@ class Canvas2D {
   uint64_t id() const { return id_; }
   /** Bumped by every draw; the renderer re-uploads when it changes. */
   uint64_t generation() const { return generation_; }
+  /** Device-space bounds of the pixels changed since the renderer last uploaded
+   * them. Empty means nothing visible changed (a no-op or off-canvas draw), so
+   * the renderer can skip the upload entirely. */
+  struct CanvasDirtyRect {
+    int x0 = 0, y0 = 0, x1 = 0, y1 = 0;
+    bool empty() const { return x1 <= x0 || y1 <= y0; }
+  };
+  const CanvasDirtyRect &pending_dirty() const { return dirty_; }
+  void clear_dirty() { dirty_ = CanvasDirtyRect(); }
   const Image &image() const { return image_; }
   /** Resize the bitmap, discarding its contents (the DOM `canvas.width = …`
    * behaviour). */
@@ -187,6 +240,24 @@ class Canvas2D {
   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_global_composite_operation(const std::string &value);
+  const std::string &global_composite_operation() const {
+    return state_.global_composite_string;
+  }
+  void set_shadow_color(const std::string &css);
+  const std::string &shadow_color() const { return state_.shadow_color_string; }
+  void set_shadow_blur(float blur);
+  float shadow_blur() const { return state_.shadow_blur; }
+  void set_shadow_offset_x(float offset) { state_.shadow_offset_x = offset; }
+  float shadow_offset_x() const { return state_.shadow_offset_x; }
+  void set_shadow_offset_y(float offset) { state_.shadow_offset_y = offset; }
+  float shadow_offset_y() const { return state_.shadow_offset_y; }
+  void set_image_smoothing_enabled(bool enabled) { state_.image_smoothing = enabled; }
+  bool image_smoothing_enabled() const { return state_.image_smoothing; }
+  void set_image_smoothing_quality(const std::string &value);
+  const std::string &image_smoothing_quality() const {
+    return state_.image_smoothing_quality;
+  }
   void set_font(const std::string &font);
   const std::string &font() const { return state_.font_string; }
   void set_text_align(const std::string &value);
@@ -226,6 +297,15 @@ class Canvas2D {
    * space and are transformed with the current state, like the current path. */
   void fill_paths(const std::vector<CanvasSubpath> &paths, bool even_odd);
   void stroke_paths(const std::vector<CanvasSubpath> &paths);
+  /** Intersect the clip region with the current path (or a `Path2D`). */
+  void clip(bool even_odd = false);
+  void clip_paths(const std::vector<CanvasSubpath> &paths, bool even_odd);
+  /** Hit testing in the current user space. */
+  bool is_point_in_path(float x, float y, bool even_odd = false) const;
+  bool is_point_in_paths(const std::vector<CanvasSubpath> &paths, float x, float y,
+                         bool even_odd) const;
+  bool is_point_in_stroke(float x, float y) const;
+  bool is_point_in_stroke_paths(const std::vector<CanvasSubpath> &paths, float x, float y) const;
 
   /* -- rectangles -------------------------------------------------------- */
   void clear_rect(float x, float y, float width, float height);
@@ -286,10 +366,31 @@ class Canvas2D {
     uint64_t stroke_pattern = 0;
     std::string line_cap_string = "butt";
     std::string line_join_string = "miter";
+    int global_composite = kCanvasCompositeSourceOver;
+    std::string global_composite_string = "source-over";
+    float shadow_color[4] = {0.0f, 0.0f, 0.0f, 0.0f};
+    std::string shadow_color_string = "rgba(0, 0, 0, 0)";
+    float shadow_blur = 0.0f;
+    float shadow_offset_x = 0.0f;
+    float shadow_offset_y = 0.0f;
+    bool image_smoothing = true;
+    std::string image_smoothing_quality = "low";
+    /** Current clip region; `save`/`restore` share it (a later `clip` installs a
+     * new mask instead of mutating the saved one). */
+    std::shared_ptr<CanvasClipMask> clip;
   };
 
   /** Transform a user-space point into device space. */
   void to_device(float x, float y, float *outX, float *outY) const;
+  /** Union a device-space rectangle into the pending upload region. */
+  void mark_dirty(float x0, float y0, float x1, float y1);
+  /** Union the bounds of a device-space path (grown by `expand`) into the
+   * pending upload region. */
+  void mark_path_dirty(const std::vector<CanvasSubpath> &subpaths, float expand);
+  void mark_all_dirty();
+  /** How far a stroke can reach outside its centre line (half width, miter
+   * limit and a pixel of anti-aliasing slack). */
+  float stroke_extent() const;
   /** The current path transformed into device space. */
   std::vector<CanvasSubpath> device_subpaths() const;
   /** Any user-space path transformed into device space. */
@@ -314,11 +415,26 @@ class Canvas2D {
                      std::vector<CanvasSubpath> *out) const;
   void paint_text(const std::string &text, float x, float y, const CanvasPaint &paint,
                   bool stroke, float max_width);
+  /** True when the current state paints a shadow for a drawing operation. */
+  bool shadow_active() const;
+  /** Redirect the next draw into a scratch layer so its alpha can be turned
+   * into a shadow. Returns false while already inside the shadow layer (or when
+   * no shadow is active), in which case the caller draws directly. */
+  bool begin_shadow_layer();
+  void end_shadow_layer();
+  /** The current clip coverage, or null when the canvas is unclipped. */
+  const CanvasClipMask *clip_mask() const;
+  void composite_layer(const Image &layer);
+  void composite_shadow_layer(const Image &layer);
 
   Image image_;
+  /** Scratch bitmap a draw is rendered into while its shadow is built. */
+  Image shadow_layer_;
+  bool in_shadow_layer_ = false;
   bool alpha_ = true;
   uint64_t id_ = 0;
   uint64_t generation_ = 0;
+  CanvasDirtyRect dirty_;
   State state_;
   std::vector<State> stack_;
   std::vector<CanvasSubpath> path_;

package/runtime/ext_gui/canvas_clip.cpp

@@ -0,0 +1,143 @@
+/*
+ * xbintsc GUI engine — Canvas2D clipping and hit testing.
+ *
+ * `clip()` rasterises the current path into a device-space coverage mask and
+ * intersects it with the region already in effect. `save`/`restore` share the
+ * mask through a `shared_ptr`; a later `clip()` installs a new mask, so a saved
+ * state can never observe a mutated region.
+ *
+ * `isPointInPath`/`isPointInStroke` run against the same device-space geometry
+ * the rasteriser would use, which keeps them consistent with anti-aliasing and
+ * the current transform.
+ */
+
+#include "canvas_internal.h"
+
+#include <algorithm>
+#include <cmath>
+#include <memory>
+#include <vector>
+
+namespace xtgui {
+
+namespace {
+
+bool point_in_loops(const std::vector<CanvasSubpath> &loops, float x, float y, bool even_odd) {
+  int winding = 0;
+  int crossings = 0;
+  for (const CanvasSubpath &loop : loops) {
+    if (loop.size() < 2) continue;
+    for (size_t i = 0; i < loop.size(); i++) {
+      const CanvasPoint &p0 = loop[i];
+      const CanvasPoint &p1 = loop[(i + 1) % loop.size()];
+      if ((p0.y > y) == (p1.y > y)) continue;
+      const float intersection = p0.x + (y - p0.y) * (p1.x - p0.x) / (p1.y - p0.y);
+      if (intersection <= x) continue;
+      if (p1.y > p0.y) winding++;
+      else winding--;
+      crossings++;
+    }
+  }
+  return even_odd ? (crossings % 2) != 0 : winding != 0;
+}
+
+float distance_to_segment(const CanvasPoint &p, const CanvasPoint &a, const CanvasPoint &b) {
+  const float dx = b.x - a.x;
+  const float dy = b.y - a.y;
+  const float lengthSquared = dx * dx + dy * dy;
+  if (lengthSquared <= 1e-9f) return std::hypot(p.x - a.x, p.y - a.y);
+  float t = ((p.x - a.x) * dx + (p.y - a.y) * dy) / lengthSquared;
+  t = std::max(0.0f, std::min(1.0f, t));
+  const float cx = a.x + t * dx;
+  const float cy = a.y + t * dy;
+  return std::hypot(p.x - cx, p.y - cy);
+}
+
+bool point_in_stroke_loops(const std::vector<CanvasSubpath> &loops, float x, float y, float half) {
+  const CanvasPoint point{x, y};
+  for (const CanvasSubpath &loop : loops) {
+    if (loop.size() < 2) continue;
+    for (size_t i = 0; i + 1 < loop.size(); i++) {
+      if (distance_to_segment(point, loop[i], loop[i + 1]) <= half) return true;
+    }
+    if (loop.front().x != loop.back().x || loop.front().y != loop.back().y) {
+      if (distance_to_segment(point, loop.back(), loop.front()) <= half) return true;
+    }
+  }
+  return false;
+}
+
+}  // namespace
+
+void Canvas2D::clip(bool even_odd) { clip_paths(path_, even_odd); }
+
+void Canvas2D::clip_paths(const std::vector<CanvasSubpath> &paths, bool even_odd) {
+  std::vector<CanvasSubpath> subpaths = device_subpaths_of(paths);
+  std::vector<CanvasSubpath> loops;
+  for (CanvasSubpath &subpath : subpaths) {
+    if (subpath.size() < 3) continue;
+    loops.push_back(std::move(subpath));
+  }
+  auto mask = std::make_shared<CanvasClipMask>();
+  mask->width = image_.width;
+  mask->height = image_.height;
+  mask->data.assign((size_t)image_.width * (size_t)image_.height, 0);
+  canvas_detail::CoverageGrid coverage;
+  canvas_detail::compute_coverage(image_.width, image_.height, loops, even_odd, &coverage);
+  if (!coverage.empty()) {
+    const int rows = coverage.y1 - coverage.y0;
+    for (int r = 0; r < rows; r++) {
+      const uint32_t begin = coverage.row_offset[(size_t)r];
+      const uint32_t end = coverage.row_offset[(size_t)r + 1];
+      if (begin >= end) continue;
+      const int y = coverage.y0 + r;
+      const int rx = coverage.row_x[(size_t)r];
+      const float *values = coverage.values.data() + begin;
+      uint8_t *out = mask->data.data() + (size_t)y * (size_t)image_.width + (size_t)rx;
+      for (uint32_t i = begin; i < end; i++) {
+        float value = std::max(0.0f, std::min(1.0f, values[i - begin]));
+        out[i - begin] = (uint8_t)(value * 255.0f + 0.5f);
+      }
+    }
+  }
+  if (state_.clip) {
+    const CanvasClipMask &previous = *state_.clip;
+    if (previous.width == mask->width && previous.height == mask->height) {
+      for (size_t i = 0; i < mask->data.size(); i++) {
+        mask->data[i] = (uint8_t)((unsigned)mask->data[i] * (unsigned)previous.data[i] / 255u);
+      }
+    }
+  }
+  state_.clip = std::move(mask);
+  /* A clip changes future draws only; it touches no pixels, so it must not
+   * schedule a texture upload. */
+}
+
+bool Canvas2D::is_point_in_path(float x, float y, bool even_odd) const {
+  return is_point_in_paths(path_, x, y, even_odd);
+}
+
+bool Canvas2D::is_point_in_paths(const std::vector<CanvasSubpath> &paths, float x, float y,
+                                 bool even_odd) const {
+  float deviceX = 0.0f;
+  float deviceY = 0.0f;
+  to_device(x, y, &deviceX, &deviceY);
+  return point_in_loops(device_subpaths_of(paths), deviceX, deviceY, even_odd);
+}
+
+bool Canvas2D::is_point_in_stroke(float x, float y) const {
+  return is_point_in_stroke_paths(path_, x, y);
+}
+
+bool Canvas2D::is_point_in_stroke_paths(const std::vector<CanvasSubpath> &paths, float x,
+                                        float y) const {
+  float scale = state_.transform.scale();
+  if (!(scale > 0.0f)) scale = 1.0f;
+  const float half = std::max(0.5f, state_.line_width * scale * 0.5f);
+  float deviceX = 0.0f;
+  float deviceY = 0.0f;
+  to_device(x, y, &deviceX, &deviceY);
+  return point_in_stroke_loops(device_subpaths_of(paths), deviceX, deviceY, half);
+}
+
+}  // namespace xtgui