xbintsc 0.5.38 → 0.5.41

package/runtime/ext_gui/canvas_composite.cpp

@@ -0,0 +1,241 @@
+/*
+ * xbintsc GUI engine — Canvas2D `globalCompositeOperation`.
+ *
+ * Every raster path funnels its per-pixel work through `blend_pixel_mode`,
+ * which implements the Porter-Duff operators and the separable/non-separable
+ * blend modes from the CSS compositing specification. Colours are kept
+ * non-premultiplied (the canvas bitmap is RGBA8 straight alpha); the composite
+ * is evaluated in premultiplied form and divided back out.
+ */
+
+#include "canvas_internal.h"
+
+#include <algorithm>
+#include <cmath>
+
+namespace xtgui {
+namespace canvas_detail {
+
+namespace {
+
+float clamp_unit(float value) { return value < 0.0f ? 0.0f : (value > 1.0f ? 1.0f : value); }
+
+float channel_blend(int mode, float s, float d) {
+  switch (mode) {
+    case kCanvasCompositeMultiply:
+      return s * d;
+    case kCanvasCompositeScreen:
+      return s + d - s * d;
+    case kCanvasCompositeOverlay:
+      return d <= 0.5f ? 2.0f * s * d : 1.0f - 2.0f * (1.0f - s) * (1.0f - d);
+    case kCanvasCompositeDarken:
+      return std::min(s, d);
+    case kCanvasCompositeLighten:
+      return std::max(s, d);
+    case kCanvasCompositeColorDodge:
+      if (d <= 0.0f) return 0.0f;
+      if (s >= 1.0f) return 1.0f;
+      return std::min(1.0f, d / (1.0f - s));
+    case kCanvasCompositeColorBurn:
+      if (d >= 1.0f) return 1.0f;
+      if (s <= 0.0f) return 0.0f;
+      return 1.0f - std::min(1.0f, (1.0f - d) / s);
+    case kCanvasCompositeHardLight:
+      return s <= 0.5f ? 2.0f * s * d : 1.0f - 2.0f * (1.0f - s) * (1.0f - d);
+    case kCanvasCompositeSoftLight: {
+      if (s <= 0.5f) return d - (1.0f - 2.0f * s) * d * (1.0f - d);
+      float d2 = d <= 0.25f ? ((16.0f * d - 12.0f) * d + 4.0f) * d : std::sqrt(d);
+      return d + (2.0f * s - 1.0f) * (d2 - d);
+    }
+    case kCanvasCompositeDifference:
+      return std::fabs(s - d);
+    case kCanvasCompositeExclusion:
+      return s + d - 2.0f * s * d;
+    default:
+      return s;
+  }
+}
+
+float luminance(const float c[3]) { return 0.3f * c[0] + 0.59f * c[1] + 0.11f * c[2]; }
+
+void clip_color(float c[3]) {
+  const float l = luminance(c);
+  float n = std::min(c[0], std::min(c[1], c[2]));
+  float x = std::max(c[0], std::max(c[1], c[2]));
+  if (n < 0.0f) {
+    const float scale = l / (l - n);
+    for (int i = 0; i < 3; i++) c[i] = l + (c[i] - l) * scale;
+  }
+  if (x > 1.0f) {
+    const float scale = (1.0f - l) / (x - l);
+    for (int i = 0; i < 3; i++) c[i] = l + (c[i] - l) * scale;
+  }
+}
+
+void set_luminance(float c[3], float l) {
+  const float delta = l - luminance(c);
+  for (int i = 0; i < 3; i++) c[i] += delta;
+  clip_color(c);
+}
+
+float saturation(const float c[3]) {
+  return std::max(c[0], std::max(c[1], c[2])) - std::min(c[0], std::min(c[1], c[2]));
+}
+
+void set_saturation(float c[3], float s) {
+  int maxIndex = 0;
+  int minIndex = 0;
+  for (int i = 1; i < 3; i++) {
+    if (c[i] > c[maxIndex]) maxIndex = i;
+    if (c[i] < c[minIndex]) minIndex = i;
+  }
+  if (maxIndex == minIndex) return;
+  float out[3] = {0.0f, 0.0f, 0.0f};
+  out[maxIndex] = s;
+  out[minIndex] = 0.0f;
+  int middle = 3 - maxIndex - minIndex;
+  out[middle] = s * (c[middle] - c[minIndex]) / (c[maxIndex] - c[minIndex]);
+  for (int i = 0; i < 3; i++) c[i] = out[i];
+}
+
+/** Non-separable modes (`hue`…`luminosity`). */
+void non_separable_blend(int mode, const float s[3], const float d[3], float out[3]) {
+  float source[3] = {s[0], s[1], s[2]};
+  float dest[3] = {d[0], d[1], d[2]};
+  switch (mode) {
+    case kCanvasCompositeHue:
+      set_saturation(source, saturation(dest));
+      set_luminance(source, luminance(dest));
+      break;
+    case kCanvasCompositeSaturation:
+      set_saturation(dest, saturation(source));
+      set_luminance(dest, luminance(dest));
+      for (int i = 0; i < 3; i++) source[i] = dest[i];
+      break;
+    case kCanvasCompositeColor:
+      set_luminance(source, luminance(dest));
+      break;
+    case kCanvasCompositeLuminosity:
+      set_luminance(dest, luminance(source));
+      for (int i = 0; i < 3; i++) source[i] = dest[i];
+      break;
+    default:
+      break;
+  }
+  for (int i = 0; i < 3; i++) out[i] = clamp_unit(source[i]);
+}
+
+bool is_non_separable(int mode) {
+  return mode == kCanvasCompositeHue || mode == kCanvasCompositeSaturation ||
+         mode == kCanvasCompositeColor || mode == kCanvasCompositeLuminosity;
+}
+
+bool is_separable_blend(int mode) {
+  return mode >= kCanvasCompositeMultiply && mode <= kCanvasCompositeExclusion && !is_non_separable(mode);
+}
+
+}  // namespace
+
+void blend_pixel_mode(unsigned char *pixel, const float color[4], float coverage, float alpha,
+                      int composite) {
+  if (composite == kCanvasCompositeSourceOver && alpha >= 0.999f && coverage >= 0.999f &&
+      color[3] >= 0.999f) {
+    pixel[0] = (unsigned char)(clamp_unit(color[0]) * 255.0f + 0.5f);
+    pixel[1] = (unsigned char)(clamp_unit(color[1]) * 255.0f + 0.5f);
+    pixel[2] = (unsigned char)(clamp_unit(color[2]) * 255.0f + 0.5f);
+    pixel[3] = 255;
+    return;
+  }
+
+  float src[3] = {clamp_unit(color[0]), clamp_unit(color[1]), clamp_unit(color[2])};
+  const float sa = clamp_unit(color[3] * alpha);
+  float dst[3] = {pixel[0] / 255.0f, pixel[1] / 255.0f, pixel[2] / 255.0f};
+  const float da = pixel[3] / 255.0f;
+
+  float outA = 0.0f;
+  float outC[3] = {0.0f, 0.0f, 0.0f};  // premultiplied
+
+  if (is_separable_blend(composite) || is_non_separable(composite)) {
+    float blended[3];
+    if (is_non_separable(composite)) {
+      non_separable_blend(composite, src, dst, blended);
+    } else {
+      for (int i = 0; i < 3; i++) blended[i] = channel_blend(composite, src[i], dst[i]);
+    }
+    outA = sa + da - sa * da;
+    for (int i = 0; i < 3; i++) {
+      outC[i] = (1.0f - da) * src[i] * sa + (1.0f - sa) * dst[i] * da + sa * da * blended[i];
+    }
+  } else {
+    switch (composite) {
+      case kCanvasCompositeSourceIn:
+        outA = sa * da;
+        for (int i = 0; i < 3; i++) outC[i] = src[i] * sa * da;
+        break;
+      case kCanvasCompositeSourceOut:
+        outA = sa * (1.0f - da);
+        for (int i = 0; i < 3; i++) outC[i] = src[i] * sa * (1.0f - da);
+        break;
+      case kCanvasCompositeSourceAtop:
+        outA = da;
+        for (int i = 0; i < 3; i++) outC[i] = src[i] * sa * da + dst[i] * da * (1.0f - sa);
+        break;
+      case kCanvasCompositeDestinationOver:
+        outA = da + sa * (1.0f - da);
+        for (int i = 0; i < 3; i++) outC[i] = dst[i] * da + src[i] * sa * (1.0f - da);
+        break;
+      case kCanvasCompositeDestinationIn:
+        outA = da * sa;
+        for (int i = 0; i < 3; i++) outC[i] = dst[i] * da * sa;
+        break;
+      case kCanvasCompositeDestinationOut:
+        outA = da * (1.0f - sa);
+        for (int i = 0; i < 3; i++) outC[i] = dst[i] * da * (1.0f - sa);
+        break;
+      case kCanvasCompositeDestinationAtop:
+        outA = sa;
+        for (int i = 0; i < 3; i++) outC[i] = dst[i] * da * sa + src[i] * sa * (1.0f - da);
+        break;
+      case kCanvasCompositeLighter:
+        outA = std::min(1.0f, sa + da);
+        for (int i = 0; i < 3; i++) outC[i] = std::min(1.0f, src[i] * sa + dst[i] * da);
+        break;
+      case kCanvasCompositeCopy:
+        outA = sa;
+        for (int i = 0; i < 3; i++) outC[i] = src[i] * sa;
+        break;
+      case kCanvasCompositeXor:
+        outA = sa * (1.0f - da) + da * (1.0f - sa);
+        for (int i = 0; i < 3; i++) {
+          outC[i] = src[i] * sa * (1.0f - da) + dst[i] * da * (1.0f - sa);
+        }
+        break;
+      default:  // source-over
+        outA = sa + da * (1.0f - sa);
+        for (int i = 0; i < 3; i++) outC[i] = src[i] * sa + dst[i] * da * (1.0f - sa);
+        break;
+    }
+  }
+
+  /* Partial coverage (anti-aliasing or a clip edge) interpolates between the
+   * untouched destination and the full composite, which is correct for every
+   * operator, including `destination-in`/`copy`. */
+  if (coverage < 0.999f) {
+    const float c = clamp_unit(coverage);
+    outA = da * (1.0f - c) + outA * c;
+    for (int i = 0; i < 3; i++) outC[i] = dst[i] * da * (1.0f - c) + outC[i] * c;
+  }
+
+  if (outA <= 0.00001f) {
+    pixel[0] = pixel[1] = pixel[2] = pixel[3] = 0;
+    return;
+  }
+  const float inverse = 1.0f / outA;
+  for (int i = 0; i < 3; i++) {
+    pixel[i] = (unsigned char)(clamp_unit(outC[i] * inverse) * 255.0f + 0.5f);
+  }
+  pixel[3] = (unsigned char)(clamp_unit(outA) * 255.0f + 0.5f);
+}
+
+}  // namespace canvas_detail
+}  // namespace xtgui

package/runtime/ext_gui/canvas_coverage.cpp

@@ -0,0 +1,241 @@
+/*
+ * xbintsc GUI engine — path coverage rasteriser.
+ *
+ * Fills a device-space polygon with 4 vertical sub-scanlines per pixel row and
+ * analytic horizontal coverage, using the non-zero winding rule or the even-odd
+ * rule. Two properties keep this cheap for a multi-element scene:
+ *
+ *   - edges are bucketed into an **active-edge list**, so a row only pays for
+ *     the edges that actually cross it (the naive version scanned every edge of
+ *     every sub-scanline);
+ *   - only the **covered span of each row** is materialised, so a thin diagonal
+ *     stroke costs its own pixels rather than its bounding box.
+ *
+ * The coverage is returned as concatenated row spans (`CoverageGrid`); blending
+ * and clip-mask construction live in `canvas_raster.cpp` / `canvas_clip.cpp`.
+ */
+
+#include "canvas_internal.h"
+
+#include <algorithm>
+#include <cmath>
+#include <vector>
+
+namespace xtgui {
+namespace canvas_detail {
+
+namespace {
+
+constexpr int kSubSamples = 4;
+
+/** One edge crossing on the current sub-scanline. */
+struct Crossing {
+  float x;
+  int winding;
+};
+
+/** Add the horizontal span `[xa, xb)` into a coverage row whose first device
+ * pixel is `rowOriginX`. */
+void add_span(float *row, int rowOriginX, float xa, float xb, float weight, int clipX0,
+              int clipX1) {
+  if (xb <= xa) return;
+  if (xa < (float)clipX0) xa = (float)clipX0;
+  if (xb > (float)clipX1) xb = (float)clipX1;
+  if (xb <= xa) return;
+  int ia = (int)std::floor(xa);
+  int ib = (int)std::ceil(xb) - 1;
+  if (ib < ia) return;
+  if (ia == ib) {
+    row[ia - rowOriginX] += (xb - xa) * weight;
+    return;
+  }
+  row[ia - rowOriginX] += ((float)(ia + 1) - xa) * weight;
+  for (int x = ia + 1; x < ib; x++) row[x - rowOriginX] += weight;
+  float last = xb - (float)ib;
+  if (last > 0.0f) row[ib - rowOriginX] += last * weight;
+}
+
+/** Order crossings left to right. A scanline usually has a handful of them, so
+ * an insertion sort beats `std::sort`'s setup cost; a pathological path still
+ * falls back to the library sort. */
+void sort_crossings(std::vector<Crossing> &crossings) {
+  const size_t count = crossings.size();
+  if (count > 16) {
+    std::sort(crossings.begin(), crossings.end(),
+              [](const Crossing &a, const Crossing &b) { return a.x < b.x; });
+    return;
+  }
+  for (size_t i = 1; i < count; i++) {
+    const Crossing value = crossings[i];
+    size_t j = i;
+    while (j > 0 && crossings[j - 1].x > value.x) {
+      crossings[j] = crossings[j - 1];
+      j -= 1;
+    }
+    crossings[j] = value;
+  }
+}
+
+}  // namespace
+
+void compute_coverage(int width, int height,
+                      const std::vector<std::vector<CanvasPoint>> &loops, bool even_odd,
+                      CoverageGrid *out) {
+  out->x0 = out->y0 = out->x1 = out->y1 = 0;
+  out->values.clear();
+  out->row_offset.clear();
+  out->row_x.clear();
+  if (width <= 0 || height <= 0 || loops.empty()) return;
+  bool havePoint = false;
+  float minX = 0.0f, maxX = 0.0f, minY = 0.0f, maxY = 0.0f;
+  for (const std::vector<CanvasPoint> &loop : loops) {
+    for (const CanvasPoint &point : loop) {
+      if (!havePoint) {
+        minX = maxX = point.x;
+        minY = maxY = point.y;
+        havePoint = 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 (!havePoint) return;
+  int x0 = std::max(0, (int)std::floor(minX));
+  int x1 = std::min(width, (int)std::ceil(maxX));
+  int y0 = std::max(0, (int)std::floor(minY));
+  int y1 = std::min(height, (int)std::ceil(maxY));
+  if (x1 <= x0 || y1 <= y0) return;
+
+  out->x0 = x0;
+  out->y0 = y0;
+  out->x1 = x1;
+  out->y1 = y1;
+  out->row_offset.reserve((size_t)(y1 - y0) + 1);
+  out->row_x.reserve((size_t)(y1 - y0));
+  out->row_offset.push_back(0);
+  const float weight = 1.0f / (float)kSubSamples;
+
+  /* Build one edge record per non-horizontal segment and the row range it can
+   * cross. */
+  struct Edge {
+    float x0 = 0.0f, y0 = 0.0f;  // upper endpoint
+    float x1 = 0.0f, y1 = 0.0f;  // lower endpoint
+    int winding = 0;
+    int first_row = 0;
+    int last_row = 0;  // exclusive
+  };
+  std::vector<Edge> edges;
+  for (const std::vector<CanvasPoint> &loop : loops) {
+    if (loop.size() < 3) 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 == p1.y) continue;
+      Edge edge;
+      if (p0.y < p1.y) {
+        edge.x0 = p0.x;
+        edge.y0 = p0.y;
+        edge.x1 = p1.x;
+        edge.y1 = p1.y;
+        edge.winding = 1;
+      } else {
+        edge.x0 = p1.x;
+        edge.y0 = p1.y;
+        edge.x1 = p0.x;
+        edge.y1 = p0.y;
+        edge.winding = -1;
+      }
+      edge.first_row = (int)std::floor(edge.y0);
+      edge.last_row = (int)std::ceil(edge.y1);
+      edges.push_back(edge);
+    }
+  }
+  if (edges.empty()) return;
+  std::sort(edges.begin(), edges.end(),
+            [](const Edge &a, const Edge &b) { return a.first_row < b.first_row; });
+
+  struct Span {
+    float xa = 0.0f;
+    float xb = 0.0f;
+  };
+  std::vector<Crossing> crossings;
+  std::vector<Span> spans;
+  std::vector<float> row_values;
+  std::vector<int> active;
+  size_t nextEdge = 0;
+  for (int py = y0; py < y1; py++) {
+    while (nextEdge < edges.size() && edges[nextEdge].first_row <= py) {
+      active.push_back((int)nextEdge);
+      nextEdge += 1;
+    }
+    /* Drop edges whose bottom is above this row. */
+    size_t kept = 0;
+    for (size_t i = 0; i < active.size(); i++) {
+      const Edge &edge = edges[(size_t)active[i]];
+      if (edge.last_row > py) active[kept++] = active[i];
+    }
+    active.resize(kept);
+    spans.clear();
+    for (int sample = 0; sample < kSubSamples; sample++) {
+      float sy = (float)py + ((float)sample + 0.5f) / (float)kSubSamples;
+      crossings.clear();
+      for (int index : active) {
+        const Edge &edge = edges[(size_t)index];
+        if (sy < edge.y0 || sy >= edge.y1) continue;
+        const float t = (sy - edge.y0) / (edge.y1 - edge.y0);
+        Crossing crossing;
+        crossing.x = edge.x0 + t * (edge.x1 - edge.x0);
+        crossing.winding = edge.winding;
+        crossings.push_back(crossing);
+      }
+      if (crossings.empty()) continue;
+      sort_crossings(crossings);
+      if (even_odd) {
+        /* Every second crossing toggles the covered span, regardless of the
+         * direction each contour is wound. */
+        for (size_t i = 0; i + 1 < crossings.size(); i += 2) {
+          spans.push_back(Span{crossings[i].x, crossings[i + 1].x});
+        }
+        continue;
+      }
+      int winding = 0;
+      float spanStart = 0.0f;
+      for (const Crossing &crossing : crossings) {
+        if (winding == 0) spanStart = crossing.x;
+        winding += crossing.winding;
+        if (winding == 0) spans.push_back(Span{spanStart, crossing.x});
+      }
+    }
+    if (spans.empty()) {
+      out->row_offset.push_back((uint32_t)out->values.size());
+      out->row_x.push_back(0);
+      continue;
+    }
+    float minSpan = spans[0].xa;
+    float maxSpan = spans[0].xb;
+    for (const Span &span : spans) {
+      minSpan = std::min(minSpan, span.xa);
+      maxSpan = std::max(maxSpan, span.xb);
+    }
+    const int rx0 = std::max(x0, (int)std::floor(minSpan));
+    const int rx1 = std::min(x1, (int)std::ceil(maxSpan));
+    if (rx1 <= rx0) {
+      out->row_offset.push_back((uint32_t)out->values.size());
+      out->row_x.push_back(0);
+      continue;
+    }
+    row_values.assign((size_t)(rx1 - rx0), 0.0f);
+    for (const Span &span : spans) {
+      add_span(row_values.data(), rx0, span.xa, span.xb, weight, x0, x1);
+    }
+    out->row_x.push_back(rx0);
+    out->values.insert(out->values.end(), row_values.begin(), row_values.end());
+    out->row_offset.push_back((uint32_t)out->values.size());
+  }
+}
+
+}  // namespace canvas_detail
+}  // namespace xtgui

package/runtime/ext_gui/canvas_gradient.cpp

@@ -55,11 +55,48 @@ bool CanvasGradient::color_at(float x, float y, float out[4]) const {
       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);
+    /* Two-circle radial gradient (CSS/Canvas): find the smallest t >= 0 for
+     * which the point lies on the circle
+     *     centre = c0 + t * (c1 - c0),  radius = r0 + t * (r1 - r0).
+     * This reduces to a quadratic, and it makes a non-concentric inner circle
+     * produce the cone a browser draws. */
+    const float dx = x1_ - x0_;
+    const float dy = y1_ - y0_;
+    const float qx = x - x0_;
+    const float qy = y - y0_;
     const float radiusDelta = r1_ - r0_;
-    if (std::fabs(radiusDelta) > 1e-6f) t = (distance - r0_) / radiusDelta;
+    const float innerDistance = std::sqrt(qx * qx + qy * qy);
+    const float a = dx * dx + dy * dy - radiusDelta * radiusDelta;
+    const float b = -2.0f * (qx * dx + qy * dy + r0_ * radiusDelta);
+    const float c = qx * qx + qy * qy - r0_ * r0_;
+    if (innerDistance <= std::fabs(r0_) + 1e-4f) {
+      /* Inside the inner circle every ray starts at t = 0. */
+      t = 0.0f;
+    } else if (std::fabs(a) < 1e-6f) {
+      if (std::fabs(b) > 1e-6f) {
+        t = -c / b;
+      } else {
+        t = innerDistance < std::fabs(r0_) ? 0.0f : 1.0f;
+      }
+    } else {
+      const float discriminant = b * b - 4.0f * a * c;
+      if (discriminant < 0.0f) {
+        t = innerDistance < std::fabs(r0_) ? 0.0f : 1.0f;
+      } else {
+        const float root = std::sqrt(discriminant);
+        const float t0 = (-b - root) / (2.0f * a);
+        const float t1 = (-b + root) / (2.0f * a);
+        const float low = std::min(t0, t1);
+        const float high = std::max(t0, t1);
+        if (low >= 0.0f) {
+          t = low;
+        } else if (high >= 0.0f) {
+          t = high;
+        } else {
+          t = innerDistance < std::fabs(r0_) ? 0.0f : 1.0f;
+        }
+      }
+    }
   }
   t = clamp_unit(t);
   if (t <= stops_.front().offset) {

package/runtime/ext_gui/canvas_image_data.cpp

@@ -15,6 +15,8 @@
 #include <cstring>
 #include <vector>
 
+#include "perf.h"
+
 namespace xtgui {
 
 void Canvas2D::set_image_data(const std::vector<unsigned char> &rgba, int data_width,
@@ -38,6 +40,7 @@ void Canvas2D::set_image_data(const std::vector<unsigned char> &rgba, int data_w
   int dest_y0 = std::max(0, dy + source_y0);
   int dest_x1 = std::min(image_.width, dx + source_x1);
   int dest_y1 = std::min(image_.height, dy + source_y1);
+  mark_dirty((float)dest_x0, (float)dest_y0, (float)dest_x1, (float)dest_y1);
   for (int py = dest_y0; py < dest_y1; py++) {
     int source_row = py - dy;
     const unsigned char *src =
@@ -46,6 +49,7 @@ void Canvas2D::set_image_data(const std::vector<unsigned char> &rgba, int data_w
         image_.pixels.data() + ((size_t)py * (size_t)image_.width + (size_t)dest_x0) * 4;
     memcpy(dst, src, (size_t)(dest_x1 - dest_x0) * 4);
   }
+  g_perf_frame.canvasDraws += 1;
   generation_++;
 }
 

package/runtime/ext_gui/canvas_internal.h

@@ -21,33 +21,58 @@ namespace canvas_detail {
  * pixel. `alpha` folds in `globalAlpha`. */
 void blend_pixel(unsigned char *pixel, const float color[4], float coverage, float alpha);
 
+/** The full `globalCompositeOperation` matrix; `composite` is a
+ * `CanvasComposite` value. */
+void blend_pixel_mode(unsigned char *pixel, const float color[4], float coverage, float alpha,
+                      int composite);
+
+/** One path's anti-aliased coverage, clipped to the canvas bitmap. Only the
+ * covered span of each row is stored, so a thin diagonal stroke costs its own
+ * pixels instead of its (potentially huge) bounding box. */
+struct CoverageGrid {
+  int x0 = 0, y0 = 0, x1 = 0, y1 = 0;
+  /** Concatenated row spans; row `r` owns `[row_offset[r], row_offset[r+1])`. */
+  std::vector<float> values;
+  /** One past-the-end index per row, plus a final entry (size = rows + 1). */
+  std::vector<uint32_t> row_offset;
+  /** Device-space x of the first stored coverage value of each row. */
+  std::vector<int> row_x;
+  bool empty() const { return x1 <= x0 || y1 <= y0; }
+};
+
+/** Rasterise `loops` (device space) into a coverage grid. */
+void compute_coverage(int width, int height,
+                      const std::vector<std::vector<CanvasPoint>> &loops, bool even_odd,
+                      CoverageGrid *out);
+
 /** 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 CanvasPaint &paint, float alpha,
-               bool even_odd = false);
+               bool even_odd = false, const CanvasClipMask *clip = nullptr);
 
 /** Fill several loops as one path with the nonzero winding rule (so a contour
  * inside another punches a hole), or the even-odd rule. */
 void fill_loops(std::vector<unsigned char> &pixels, int width, int height,
                 const std::vector<std::vector<CanvasPoint>> &loops, const CanvasPaint &paint,
-                float alpha, bool even_odd = false);
+                float alpha, bool even_odd = false, const CanvasClipMask *clip = nullptr);
 
 /** 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 CanvasPaint &paint, float alpha);
+               float x1, float y1, const CanvasPaint &paint, float alpha,
+               const CanvasClipMask *clip = nullptr);
 
 /** 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,
-                float x1, float y1);
+                float x1, float y1, const CanvasClipMask *clip = nullptr);
 
-/** Blit an RGBA8 source image into the destination rectangle using nearest
- * sampling, source-over. Runs in device space (no transform). */
+/** Blit an RGBA8 source image into the destination rectangle, source-over.
+ * Runs in device space (no transform). `smooth` selects bilinear sampling. */
 void draw_image(std::vector<unsigned char> &pixels, int width, int height, const Image &source,
                 float dx, float dy, float dw, float dh, float sx, float sy, float sw, float sh,
-                float alpha);
+                float alpha, bool smooth, const CanvasClipMask *clip = nullptr);
 
 /** Blit an RGBA8 source through a full affine transform. The destination
  * rectangle is mapped to a parallelogram by `transform`; each device pixel is
@@ -57,14 +82,14 @@ void draw_image(std::vector<unsigned char> &pixels, int width, int height, const
 void draw_image_affine(std::vector<unsigned char> &pixels, int width, int height,
                        const Image &source, float dx, float dy, float dw, float dh, float sx,
                        float sy, float sw, float sh, const CanvasTransform &transform,
-                       float alpha);
+                       float alpha, bool smooth, const CanvasClipMask *clip = nullptr);
 
 /** Composite one grayscale glyph bitmap at `(x, baselineY)` with `paint`.
  * `scale_x` < 1 condenses the bitmap horizontally (`fillText`'s `maxWidth`). */
 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, float scale_x, const CanvasPaint &paint,
-                float alpha);
+                float alpha, const CanvasClipMask *clip = nullptr);
 
 }  // namespace canvas_detail
 }  // namespace xtgui