xbintsc 0.5.21 → 0.5.22

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