xbintsc 0.5.37 → 0.5.41

package/runtime/ext_gui/canvas_raster.cpp

@@ -19,8 +19,6 @@ namespace canvas_detail {
 
 namespace {
 
-constexpr int kSubSamples = 4;
-
 int clamp_byte(float value) {
   int result = (int)(value + 0.5f);
   if (result < 0) result = 0;
@@ -28,12 +26,6 @@ int clamp_byte(float value) {
   return result;
 }
 
-/** One edge crossing on the current sub-scanline. */
-struct Crossing {
-  float x;
-  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]) {
@@ -54,175 +46,157 @@ void paint_color_at(const CanvasPaint &paint, float x, float y, float out[4]) {
   out[0] = out[1] = out[2] = out[3] = 0.0f;
 }
 
+/** True when the paint is a single colour, so the per-pixel colour resolution
+ * (a branch on gradient/pattern and a 4-float copy) can be hoisted out of the
+ * pixel loop. A solid paint is the common case in a multi-element scene. */
+bool paint_is_solid(const CanvasPaint &paint) {
+  return paint.gradient == nullptr && paint.pattern == nullptr && paint.color != nullptr;
+}
+
+void copy_color(const float color[4], float out[4]) {
+  out[0] = color[0];
+  out[1] = color[1];
+  out[2] = color[2];
+  out[3] = color[3];
+}
+
+unsigned char color_byte(float value) {
+  value = value < 0.0f ? 0.0f : (value > 1.0f ? 1.0f : value);
+  return (unsigned char)(value * 255.0f + 0.5f);
+}
+
+/** True when a source-over paint writes its colour unchanged at full coverage
+ * (opaque colour, opaque globalAlpha): the rasteriser can store bytes directly
+ * instead of running the compositing math per pixel. */
+bool paint_is_opaque_source(const CanvasPaint &paint, float alpha) {
+  return paint_is_solid(paint) && paint.composite == kCanvasCompositeSourceOver &&
+         alpha >= 0.999f && paint.color[3] >= 0.999f;
+}
+
 }  // namespace
 
 void blend_pixel(unsigned char *pixel, const float color[4], float coverage, float alpha) {
-  /* Fully opaque source-over is a plain copy; this is the hot path for paper
-     textures, terrain and the opaque parts of every sprite. */
-  if (alpha >= 0.999f && coverage >= 0.999f && color[3] >= 0.999f) {
-    pixel[0] = (unsigned char)clamp_byte(color[0] * 255.0f);
-    pixel[1] = (unsigned char)clamp_byte(color[1] * 255.0f);
-    pixel[2] = (unsigned char)clamp_byte(color[2] * 255.0f);
-    pixel[3] = 255;
-    return;
-  }
-  float sa = color[3] * coverage * alpha;
-  if (sa <= 0.0f) return;
-  if (sa > 1.0f) sa = 1.0f;
-  float da = pixel[3] / 255.0f;
-  float out_a = sa + da * (1.0f - sa);
-  if (out_a <= 0.0f) {
-    pixel[0] = pixel[1] = pixel[2] = pixel[3] = 0;
-    return;
-  }
-  const float inv = 1.0f / out_a;
-  pixel[0] = (unsigned char)clamp_byte((color[0] * sa + (pixel[0] / 255.0f) * da * (1.0f - sa)) * inv * 255.0f);
-  pixel[1] = (unsigned char)clamp_byte((color[1] * sa + (pixel[1] / 255.0f) * da * (1.0f - sa)) * inv * 255.0f);
-  pixel[2] = (unsigned char)clamp_byte((color[2] * sa + (pixel[2] / 255.0f) * da * (1.0f - sa)) * inv * 255.0f);
-  pixel[3] = (unsigned char)clamp_byte(out_a * 255.0f);
+  blend_pixel_mode(pixel, color, coverage, alpha, kCanvasCompositeSourceOver);
 }
 
-/** Add the horizontal span `[xa, xb)` into a bbox-relative coverage row. */
-static 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;
+/** Source-over with a clip mask applied to the coverage. */
+static void blend_clipped(unsigned char *pixel, const float color[4], float coverage, float alpha,
+                          const CanvasPaint &paint, const CanvasClipMask *clip, int x, int y) {
+  if (clip != nullptr) {
+    const float clipCoverage = clip->at(x, y) / 255.0f;
+    if (clipCoverage <= 0.0f) return;
+    coverage *= clipCoverage;
   }
-  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;
+  blend_pixel_mode(pixel, color, coverage, alpha, paint.composite);
 }
 
 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) {
-  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;
-
-  int boxWidth = x1 - x0;
-  std::vector<float> coverage((size_t)boxWidth * (size_t)(y1 - y0), 0.0f);
-  const float weight = 1.0f / (float)kSubSamples;
-
-  std::vector<Crossing> crossings;
-  for (int py = y0; py < y1; py++) {
-    float *row = coverage.data() + (size_t)(py - y0) * (size_t)boxWidth;
-    for (int sample = 0; sample < kSubSamples; sample++) {
-      float sy = (float)py + ((float)sample + 0.5f) / (float)kSubSamples;
-      crossings.clear();
-      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;
-          float top = std::min(p0.y, p1.y);
-          float bottom = std::max(p0.y, p1.y);
-          if (sy < top || sy >= bottom) continue;
-          float t = (sy - p0.y) / (p1.y - p0.y);
-          Crossing crossing;
-          crossing.x = p0.x + t * (p1.x - p0.x);
-          crossing.winding = p1.y > p0.y ? 1 : -1;
-          crossings.push_back(crossing);
-        }
-      }
-      if (crossings.empty()) continue;
-      std::sort(crossings.begin(), crossings.end(),
-                [](const Crossing &a, const Crossing &b) { return a.x < b.x; });
-      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) {
-          add_span(row, x0, crossings[i].x, crossings[i + 1].x, weight, x0, x1);
-        }
-        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) add_span(row, x0, spanStart, crossing.x, weight, x0, x1);
-      }
-    }
-  }
-
-  for (int py = y0; py < y1; py++) {
-    const float *row = coverage.data() + (size_t)(py - y0) * (size_t)boxWidth;
-    unsigned char *dst = pixels.data() + ((size_t)py * (size_t)width + (size_t)x0) * 4;
-    for (int px = 0; px < boxWidth; px++) {
-      float c = row[px];
+                float alpha, bool even_odd, const CanvasClipMask *clip) {
+  CoverageGrid coverage;
+  compute_coverage(width, height, loops, even_odd, &coverage);
+  if (coverage.empty()) return;
+  const bool solid = paint_is_solid(paint);
+  float solid_color[4];
+  if (solid) copy_color(paint.color, solid_color);
+  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 py = coverage.y0 + r;
+    const int rx = coverage.row_x[(size_t)r];
+    const float *row = coverage.values.data() + begin;
+    const int row_width = (int)(end - begin);
+    unsigned char *dst = pixels.data() + ((size_t)py * (size_t)width + (size_t)rx) * 4;
+    for (int i = 0; i < row_width; i++) {
+      float c = row[i];
       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);
+      if (solid) {
+        copy_color(solid_color, color);
+      } else {
+        paint_color_at(paint, (float)(rx + i) + 0.5f, (float)py + 0.5f, color);
+      }
+      blend_clipped(dst + (size_t)i * 4, color, c, alpha, paint, clip, rx + i, py);
     }
   }
 }
 
 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) {
+               bool even_odd, const CanvasClipMask *clip) {
   fill_loops(pixels, width, height, std::vector<std::vector<CanvasPoint>>{loop}, paint, alpha,
-             even_odd);
+             even_odd, clip);
 }
 
 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) {
   if (x1 < x0) std::swap(x0, x1);
   if (y1 < y0) std::swap(y0, y1);
   int ix0 = std::max(0, (int)std::floor(x0));
   int ix1 = std::min(width, (int)std::ceil(x1));
   int iy0 = std::max(0, (int)std::floor(y0));
   int iy1 = std::min(height, (int)std::ceil(y1));
+  const bool solid = paint_is_solid(paint);
+  float solid_color[4];
+  if (solid) copy_color(paint.color, solid_color);
+  /* A fully opaque solid fill at full coverage is a byte store: the same bytes
+   * `blend_pixel_mode` would compute, without the per-pixel compositing math.
+   * Fractional edges (and clipped or translucent fills) keep the general path,
+   * so the output is unchanged for every other case. */
+  unsigned char opaque_bytes[4] = {0, 0, 0, 0};
+  const bool opaque = paint_is_opaque_source(paint, alpha) && clip == nullptr;
+  if (opaque) {
+    opaque_bytes[0] = color_byte(solid_color[0]);
+    opaque_bytes[1] = color_byte(solid_color[1]);
+    opaque_bytes[2] = color_byte(solid_color[2]);
+    opaque_bytes[3] = 255;
+  }
   for (int py = iy0; py < iy1; py++) {
     float cy = std::min(y1, (float)(py + 1)) - std::max(y0, (float)py);
     if (cy <= 0.0f) continue;
     unsigned char *dst = pixels.data() + ((size_t)py * (size_t)width + (size_t)ix0) * 4;
+    if (opaque && cy >= 0.999f) {
+      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;
+        unsigned char *pixel = dst + (size_t)(px - ix0) * 4;
+        if (cx >= 0.999f) {
+          std::memcpy(pixel, opaque_bytes, 4);
+        } else {
+          float color[4];
+          copy_color(solid_color, color);
+          blend_pixel(pixel, color, cx, alpha);
+        }
+      }
+      continue;
+    }
     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);
+      if (solid) {
+        copy_color(solid_color, color);
+      } else {
+        paint_color_at(paint, (float)px + 0.5f, (float)py + 0.5f, color);
+      }
+      blend_clipped(dst + (size_t)(px - ix0) * 4, color, cx * cy, alpha, paint, clip, px, py);
     }
   }
 }
 
 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) {
   if (x1 < x0) std::swap(x0, x1);
   if (y1 < y0) std::swap(y0, y1);
+  if (clip == nullptr && x0 <= 0.0f && y0 <= 0.0f && x1 >= (float)width &&
+      y1 >= (float)height) {
+    std::fill(pixels.begin(), pixels.end(), (unsigned char)0);
+    return;
+  }
   int ix0 = std::max(0, (int)std::floor(x0));
   int ix1 = std::min(width, (int)std::ceil(x1));
   int iy0 = std::max(0, (int)std::floor(y0));
@@ -235,7 +209,9 @@ void clear_rect(std::vector<unsigned char> &pixels, int width, int height, float
       float cx = std::min(x1, (float)(px + 1)) - std::max(x0, (float)px);
       if (cx <= 0.0f) continue;
       unsigned char *pixel = dst + (size_t)(px - ix0) * 4;
-      float keep = 1.0f - cx * cy;
+      float amount = cx * cy;
+      if (clip != nullptr) amount *= clip->at(px, py) / 255.0f;
+      float keep = 1.0f - amount;
       if (keep <= 0.0f) {
         pixel[0] = pixel[1] = pixel[2] = pixel[3] = 0;
       } else {
@@ -245,9 +221,55 @@ void clear_rect(std::vector<unsigned char> &pixels, int width, int height, float
   }
 }
 
+/** Sample one source image pixel at continuous coordinates (`0..width`).
+ * `smooth` selects bilinear filtering, otherwise the containing texel is used. */
+static void sample_source(const Image &source, float fx, float fy, bool smooth, float out[4]) {
+  auto texel_at = [&](int x, int y, float outPixel[4]) {
+    if (x < 0) x = 0;
+    if (y < 0) y = 0;
+    if (x >= source.width) x = source.width - 1;
+    if (y >= source.height) y = source.height - 1;
+    const unsigned char *texel =
+        source.pixels.data() + ((size_t)y * (size_t)source.width + (size_t)x) * 4;
+    for (int i = 0; i < 4; i++) outPixel[i] = texel[i] / 255.0f;
+  };
+  if (!smooth) {
+    texel_at((int)fx, (int)fy, out);
+    return;
+  }
+  const float x = fx - 0.5f;
+  const float y = fy - 0.5f;
+  int x0 = (int)std::floor(x);
+  int y0 = (int)std::floor(y);
+  const float tx = x - (float)x0;
+  const float ty = y - (float)y0;
+  float top[4];
+  float bottom[4];
+  float a[4];
+  float b[4];
+  texel_at(x0, y0, a);
+  texel_at(x0 + 1, y0, b);
+  for (int i = 0; i < 4; i++) top[i] = a[i] + (b[i] - a[i]) * tx;
+  texel_at(x0, y0 + 1, a);
+  texel_at(x0 + 1, y0 + 1, b);
+  for (int i = 0; i < 4; i++) bottom[i] = a[i] + (b[i] - a[i]) * tx;
+  for (int i = 0; i < 4; i++) out[i] = top[i] + (bottom[i] - top[i]) * ty;
+}
+
+/** Source pixel centre for a destination pixel of `drawImage`. */
+static void draw_image_pixel(std::vector<unsigned char> &pixels, int width, const Image &source,
+                             const CanvasPaint &paint, int px, int py, float u, float v, float sx,
+                             float sy, float sw, float sh, float alpha, bool smooth,
+                             const CanvasClipMask *clip) {
+  float sampled[4];
+  sample_source(source, sx + u * sw, sy + v * sh, smooth, sampled);
+  unsigned char *dst = pixels.data() + ((size_t)py * (size_t)width + (size_t)px) * 4;
+  blend_clipped(dst, sampled, 1.0f, alpha, paint, clip, px, py);
+}
+
 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) {
   if (source.width <= 0 || source.height <= 0 || dw <= 0.0f || dh <= 0.0f || sw <= 0.0f ||
       sh <= 0.0f)
     return;
@@ -255,30 +277,46 @@ void draw_image(std::vector<unsigned char> &pixels, int width, int height, const
   int ix1 = std::min(width, (int)std::ceil(dx + dw));
   int iy0 = std::max(0, (int)std::floor(dy));
   int iy1 = std::min(height, (int)std::ceil(dy + dh));
+  const CanvasPaint paint;
+  /* A 1:1 blit at integer offsets samples exactly one texel per pixel: skip the
+   * per-pixel divide and the four bilinear taps. Sprite/offscreen-canvas
+   * compositing in a multi-element scene is usually this case. */
+  const int dx_int = (int)std::lround(dx);
+  const int dy_int = (int)std::lround(dy);
+  const int sx_int = (int)std::lround(sx);
+  const int sy_int = (int)std::lround(sy);
+  const bool one_to_one = std::fabs(dw - sw) < 0.001f && std::fabs(dh - sh) < 0.001f &&
+                          std::fabs(dx - (float)dx_int) < 0.001f &&
+                          std::fabs(dy - (float)dy_int) < 0.001f &&
+                          std::fabs(sx - (float)sx_int) < 0.001f &&
+                          std::fabs(sy - (float)sy_int) < 0.001f;
+  if (one_to_one) {
+    for (int py = iy0; py < iy1; py++) {
+      int texelY = sy_int + (py - dy_int);
+      if (texelY < 0) texelY = 0;
+      if (texelY >= source.height) texelY = source.height - 1;
+      const unsigned char *source_row =
+          source.pixels.data() + (size_t)texelY * (size_t)source.width * 4;
+      unsigned char *dst = pixels.data() + ((size_t)py * (size_t)width + (size_t)ix0) * 4;
+      for (int px = ix0; px < ix1; px++) {
+        int texelX = sx_int + (px - dx_int);
+        if (texelX < 0) texelX = 0;
+        if (texelX >= source.width) texelX = source.width - 1;
+        const unsigned char *texel = source_row + (size_t)texelX * 4;
+        float sampled[4] = {texel[0] / 255.0f, texel[1] / 255.0f, texel[2] / 255.0f,
+                            texel[3] / 255.0f};
+        blend_clipped(dst + (size_t)(px - ix0) * 4, sampled, 1.0f, alpha, paint, clip, px, py);
+      }
+    }
+    return;
+  }
   for (int py = iy0; py < iy1; py++) {
     for (int px = ix0; px < ix1; px++) {
       float u = ((float)px + 0.5f - dx) / dw;
       float v = ((float)py + 0.5f - dy) / dh;
       if (u < 0.0f || u >= 1.0f || v < 0.0f || v >= 1.0f) continue;
-      int sxi = (int)(sx + u * sw);
-      int syi = (int)(sy + v * sh);
-      if (sxi < 0) sxi = 0;
-      if (syi < 0) syi = 0;
-      if (sxi >= source.width) sxi = source.width - 1;
-      if (syi >= source.height) syi = source.height - 1;
-      const unsigned char *texel =
-          source.pixels.data() + ((size_t)syi * (size_t)source.width + (size_t)sxi) * 4;
-      unsigned char *dst = pixels.data() + ((size_t)py * (size_t)width + (size_t)px) * 4;
-      if (alpha >= 0.999f) {
-        const unsigned char ta = texel[3];
-        if (ta == 255) {
-          dst[0] = texel[0]; dst[1] = texel[1]; dst[2] = texel[2]; dst[3] = 255;
-          continue;
-        }
-        if (ta == 0) continue;
-      }
-      float color[4] = {texel[0] / 255.0f, texel[1] / 255.0f, texel[2] / 255.0f, texel[3] / 255.0f};
-      blend_pixel(dst, color, 1.0f, alpha);
+      draw_image_pixel(pixels, width, source, paint, px, py, u, v, sx, sy, sw, sh, alpha, smooth,
+                       clip);
     }
   }
 }
@@ -287,7 +325,7 @@ 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) {
   if (source.width <= 0 || source.height <= 0 || dw <= 0.0f || dh <= 0.0f || sw <= 0.0f ||
       sh <= 0.0f)
     return;
@@ -312,6 +350,7 @@ void draw_image_affine(std::vector<unsigned char> &pixels, int width, int height
   int ix1 = std::min(width, (int)std::ceil(maxX));
   int iy0 = std::max(0, (int)std::floor(minY));
   int iy1 = std::min(height, (int)std::ceil(maxY));
+  const CanvasPaint paint;
   for (int py = iy0; py < iy1; py++) {
     for (int px = ix0; px < ix1; px++) {
       float ux = 0.0f;
@@ -320,25 +359,8 @@ void draw_image_affine(std::vector<unsigned char> &pixels, int width, int height
       float u = (ux - dx) / dw;
       float v = (uy - dy) / dh;
       if (u < 0.0f || u >= 1.0f || v < 0.0f || v >= 1.0f) continue;
-      int sxi = (int)(sx + u * sw);
-      int syi = (int)(sy + v * sh);
-      if (sxi < 0) sxi = 0;
-      if (syi < 0) syi = 0;
-      if (sxi >= source.width) sxi = source.width - 1;
-      if (syi >= source.height) syi = source.height - 1;
-      const unsigned char *texel =
-          source.pixels.data() + ((size_t)syi * (size_t)source.width + (size_t)sxi) * 4;
-      unsigned char *dst = pixels.data() + ((size_t)py * (size_t)width + (size_t)px) * 4;
-      if (alpha >= 0.999f) {
-        const unsigned char ta = texel[3];
-        if (ta == 255) {
-          dst[0] = texel[0]; dst[1] = texel[1]; dst[2] = texel[2]; dst[3] = 255;
-          continue;
-        }
-        if (ta == 0) continue;
-      }
-      float color[4] = {texel[0] / 255.0f, texel[1] / 255.0f, texel[2] / 255.0f, texel[3] / 255.0f};
-      blend_pixel(dst, color, 1.0f, alpha);
+      draw_image_pixel(pixels, width, source, paint, px, py, u, v, sx, sy, sw, sh, alpha, smooth,
+                       clip);
     }
   }
 }
@@ -346,7 +368,7 @@ void draw_image_affine(std::vector<unsigned char> &pixels, int width, int height
 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) {
   if (glyphWidth <= 0 || glyphHeight <= 0) return;
   if (scale_x <= 0.0f) scale_x = 1.0f;
   bool condense = scale_x < 0.999f;
@@ -354,6 +376,9 @@ void blit_glyph(std::vector<unsigned char> &pixels, int width, int height,
                            : glyphWidth;
   int originX = (int)std::lround(x) + (int)std::lround((float)left * scale_x);
   int originY = (int)std::lround(baselineY) - top;
+  const bool solid = paint_is_solid(paint);
+  float solid_color[4];
+  if (solid) copy_color(paint.color, solid_color);
   for (int gy = 0; gy < glyphHeight; gy++) {
     int py = originY + gy;
     if (py < 0 || py >= height) continue;
@@ -365,9 +390,13 @@ void blit_glyph(std::vector<unsigned char> &pixels, int width, int height,
       float coverage = glyph[(size_t)gy * (size_t)glyphWidth + (size_t)sourceX] / 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);
+      if (solid) {
+        copy_color(solid_color, color);
+      } else {
+        paint_color_at(paint, (float)px + 0.5f, (float)py + 0.5f, color);
+      }
+      blend_clipped(pixels.data() + ((size_t)py * (size_t)width + (size_t)px) * 4, color,
+                    coverage, alpha, paint, clip, px, py);
     }
   }
 }

package/runtime/ext_gui/canvas_shadow.cpp

@@ -0,0 +1,161 @@
+/*
+ * xbintsc GUI engine — Canvas2D shadows and clip-region compositing.
+ *
+ * A drawing operation that has a visible `shadowColor` is rendered into a
+ * scratch layer first, so the shadow is derived from exactly the pixels the
+ * operation covers (including glyph coverage and image alpha). The layer's
+ * alpha is offset and box-blurred, tinted with `shadowColor`, composited, and
+ * only then is the operation's own colour composited on top.
+ *
+ * The scratch layer is deliberately drawn *without* the clip mask: the shadow
+ * must be able to leave the clip region and be clipped once, at composite time.
+ */
+
+#include "canvas_internal.h"
+
+#include <algorithm>
+#include <cmath>
+#include <utility>
+#include <vector>
+
+namespace xtgui {
+
+namespace {
+
+void box_blur_pass(std::vector<float> &source, std::vector<float> &temp, int width, int height,
+                   int radius) {
+  if (radius <= 0) return;
+  const float scale = 1.0f / (float)(radius * 2 + 1);
+  temp.resize(source.size());
+  /* Horizontal. */
+  for (int y = 0; y < height; y++) {
+    const float *row = source.data() + (size_t)y * (size_t)width;
+    float *out = temp.data() + (size_t)y * (size_t)width;
+    float sum = 0.0f;
+    for (int x = -radius; x <= radius; x++) sum += row[std::min(width - 1, std::max(0, x))];
+    for (int x = 0; x < width; x++) {
+      out[x] = sum * scale;
+      const int remove = std::min(width - 1, std::max(0, x - radius));
+      const int add = std::min(width - 1, std::max(0, x + radius + 1));
+      sum += row[add] - row[remove];
+    }
+  }
+  /* Vertical. */
+  for (int x = 0; x < width; x++) {
+    float sum = 0.0f;
+    for (int y = -radius; y <= radius; y++) {
+      sum += temp[(size_t)std::min(height - 1, std::max(0, y)) * (size_t)width + (size_t)x];
+    }
+    for (int y = 0; y < height; y++) {
+      source[(size_t)y * (size_t)width + (size_t)x] = sum * scale;
+      const int remove = std::min(height - 1, std::max(0, y - radius));
+      const int add = std::min(height - 1, std::max(0, y + radius + 1));
+      sum += temp[(size_t)add * (size_t)width + (size_t)x] -
+             temp[(size_t)remove * (size_t)width + (size_t)x];
+    }
+  }
+}
+
+}  // namespace
+
+bool Canvas2D::shadow_active() const {
+  if (in_shadow_layer_) return false;
+  return state_.shadow_color[3] > 0.0f;
+}
+
+const CanvasClipMask *Canvas2D::clip_mask() const {
+  /* The scratch shadow layer is painted unclipped; the mask is applied when the
+   * finished layer is composited back. */
+  if (in_shadow_layer_ || !state_.clip) return nullptr;
+  return state_.clip.get();
+}
+
+bool Canvas2D::begin_shadow_layer() {
+  if (in_shadow_layer_ || !shadow_active()) return false;
+  shadow_layer_.width = image_.width;
+  shadow_layer_.height = image_.height;
+  shadow_layer_.pixels.assign((size_t)image_.width * (size_t)image_.height * 4, 0);
+  std::swap(shadow_layer_.pixels, image_.pixels);
+  in_shadow_layer_ = true;
+  return true;
+}
+
+void Canvas2D::end_shadow_layer() {
+  if (!in_shadow_layer_) return;
+  in_shadow_layer_ = false;
+  std::swap(image_.pixels, shadow_layer_.pixels);
+  composite_shadow_layer(shadow_layer_);
+  composite_layer(shadow_layer_);
+  /* The shadow can reach beyond the draw's own bounds (offset + blur), so the
+   * conservative upload region is the whole canvas. */
+  mark_all_dirty();
+  generation_++;
+}
+
+void Canvas2D::composite_layer(const Image &layer) {
+  if (layer.width != image_.width || layer.height != image_.height) return;
+  const CanvasClipMask *clip = clip_mask();
+  for (int y = 0; y < layer.height; y++) {
+    const unsigned char *src = layer.pixels.data() + (size_t)y * (size_t)layer.width * 4;
+    unsigned char *dst = image_.pixels.data() + (size_t)y * (size_t)image_.width * 4;
+    for (int x = 0; x < layer.width; x++) {
+      const unsigned char *texel = src + (size_t)x * 4;
+      if (texel[3] == 0) continue;
+      float color[4] = {texel[0] / 255.0f, texel[1] / 255.0f, texel[2] / 255.0f,
+                        texel[3] / 255.0f};
+      float coverage = clip != nullptr ? clip->at(x, y) / 255.0f : 1.0f;
+      if (coverage <= 0.0f) continue;
+      canvas_detail::blend_pixel_mode(dst + (size_t)x * 4, color, coverage, 1.0f,
+                                      state_.global_composite);
+    }
+  }
+}
+
+void Canvas2D::composite_shadow_layer(const Image &layer) {
+  if (layer.width != image_.width || layer.height != image_.height) return;
+  if (state_.shadow_color[3] <= 0.0f) return;
+  const int width = layer.width;
+  const int height = layer.height;
+  std::vector<float> alpha((size_t)width * (size_t)height, 0.0f);
+  for (int y = 0; y < height; y++) {
+    const unsigned char *row = layer.pixels.data() + (size_t)y * (size_t)width * 4;
+    float *out = alpha.data() + (size_t)y * (size_t)width;
+    for (int x = 0; x < width; x++) out[x] = row[(size_t)x * 4 + 3] / 255.0f;
+  }
+
+  /* `shadowBlur` is the diameter of the blur; three box passes approximate a
+   * Gaussian closely enough for UI work and stay O(width * height). */
+  const float blur = std::isfinite(state_.shadow_blur) ? state_.shadow_blur : 0.0f;
+  if (blur > 0.0f) {
+    int radius = (int)std::lround(blur * 0.5f);
+    if (radius < 1) radius = 1;
+    if (radius > 64) radius = 64;
+    std::vector<float> temp;
+    for (int pass = 0; pass < 3; pass++) box_blur_pass(alpha, temp, width, height, radius);
+  }
+
+  const int offsetX = (int)std::lround(state_.shadow_offset_x);
+  const int offsetY = (int)std::lround(state_.shadow_offset_y);
+  const CanvasClipMask *clip = clip_mask();
+  const float shadowAlpha = state_.shadow_color[3];
+  for (int y = 0; y < height; y++) {
+    const int sourceY = y - offsetY;
+    if (sourceY < 0 || sourceY >= height) continue;
+    const float *row = alpha.data() + (size_t)sourceY * (size_t)width;
+    unsigned char *dst = image_.pixels.data() + (size_t)y * (size_t)image_.width * 4;
+    for (int x = 0; x < width; x++) {
+      const int sourceX = x - offsetX;
+      if (sourceX < 0 || sourceX >= width) continue;
+      const float coverage = row[sourceX];
+      if (coverage <= 0.0f) continue;
+      float color[4] = {state_.shadow_color[0], state_.shadow_color[1], state_.shadow_color[2],
+                        shadowAlpha};
+      float clipCoverage = clip != nullptr ? clip->at(x, y) / 255.0f : 1.0f;
+      if (clipCoverage <= 0.0f) continue;
+      canvas_detail::blend_pixel_mode(dst + (size_t)x * 4, color, coverage * clipCoverage, 1.0f,
+                                      kCanvasCompositeSourceOver);
+    }
+  }
+}
+
+}  // namespace xtgui