xbintsc 0.5.31 → 0.5.32

package/runtime/ext_gui/renderer.cpp

@@ -39,35 +39,6 @@ bool g_atlas_dirty = false;
 int g_atlas_dirty_x0 = 0, g_atlas_dirty_y0 = 0, g_atlas_dirty_x1 = 0, g_atlas_dirty_y1 = 0;
 bool g_atlas_full_logged = false;
 
-void pushRect(std::vector<Vertex> &verts, const xtgui::PaintRect &rect) {
-  float hw = rect.width * 0.5f;
-  float hh = rect.height * 0.5f;
-  float cx = rect.x + hw;
-  float cy = rect.y + hh;
-  float radius = std::min(rect.radius, std::min(hw, hh));
-
-  const float local_x[4] = {-hw, hw, hw, -hw};
-  const float local_y[4] = {-hh, -hh, hh, hh};
-  Vertex corners[4];
-  for (int i = 0; i < 4; i++) {
-    /* `local` keeps the distance-field coordinates in the box's own frame, so
-     * a rotated/scaled shape still gets a rounded rectangle (the radius scales
-     * with the matrix instead of staying circular). */
-    rect.transform.apply(cx + local_x[i], cy + local_y[i], &corners[i].x, &corners[i].y);
-    corners[i].lx = local_x[i];
-    corners[i].ly = local_y[i];
-    corners[i].hx = hw;
-    corners[i].hy = hh;
-    corners[i].radius = radius;
-    corners[i].r = rect.color.r;
-    corners[i].g = rect.color.g;
-    corners[i].b = rect.color.b;
-    corners[i].a = rect.color.a;
-  }
-  static const int order[6] = {0, 1, 2, 0, 2, 3};
-  for (int i = 0; i < 6; i++) verts.push_back(corners[order[i]]);
-}
-
 /** Upload `count` vertices (of `stride` bytes) into `geometry`, reusing or
  * growing its GPU buffer. Does nothing when `count` is zero. */
 void uploadVertices(SDL_GPUDevice *device, XtGuiGeometry *geometry, const void *data,
@@ -277,8 +248,14 @@ void xt_gui_geometry_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
   using namespace xtgui::renderer_detail;
   std::vector<Vertex> verts;
   verts.reserve(list.rects.size() * 6);
-  geometry->op_counts.assign(list.rects.size(), 6);
-  for (const xtgui::PaintRect &rect : list.rects) pushRect(verts, rect);
+  geometry->op_counts.assign(list.rects.size(), 0);
+  /* Walk painter order so each rectangle carries its op's clip path. */
+  for (const xtgui::PaintOp &op : list.ops) {
+    if (op.kind != xtgui::PaintKind::Rect || op.index >= list.rects.size()) continue;
+    uint32_t before = (uint32_t)verts.size();
+    pushShape(verts, list.rects[op.index], op.clip, list);
+    geometry->op_counts[op.index] = (uint32_t)verts.size() - before;
+  }
   uploadVertices(device, geometry, verts.data(), (uint32_t)verts.size(), sizeof(Vertex));
 }
 

package/runtime/ext_gui/renderer_clip.cpp

@@ -0,0 +1,196 @@
+/*
+ * xbintsc GUI engine — CPU geometry clipping for `clip-path`.
+ *
+ * Every painted shape is a convex quad. The paint pass leaves each clip path as
+ * a triangulated device-space polygon; clipping a convex quad by one triangle
+ * keeps it convex, so the result is emitted as a triangle fan. Clipping against
+ * a concave path is correct because its triangles partition the path.
+ */
+
+#include "renderer_internal.h"
+
+#include <algorithm>
+#include <vector>
+
+namespace xtgui {
+namespace renderer_detail {
+
+namespace {
+
+float side(const ClipTriangle &triangle, int edge, float x, float y) {
+  int next = (edge + 1) % 3;
+  float ax = triangle.x[edge];
+  float ay = triangle.y[edge];
+  float bx = triangle.x[next];
+  float by = triangle.y[next];
+  return (bx - ax) * (y - ay) - (by - ay) * (x - ax);
+}
+
+bool triangleOrientation(const ClipTriangle &triangle, float *orientation) {
+  float cross = (triangle.x[1] - triangle.x[0]) * (triangle.y[2] - triangle.y[0]) -
+                (triangle.y[1] - triangle.y[0]) * (triangle.x[2] - triangle.x[0]);
+  if (cross > -0.00001f && cross < 0.00001f) return false;
+  *orientation = cross > 0.0f ? 1.0f : -1.0f;
+  return true;
+}
+
+template <typename V, typename Mix>
+std::vector<V> clipToTriangle(const std::vector<V> &subject, const ClipTriangle &triangle,
+                              Mix mix) {
+  float orientation = 0.0f;
+  if (!triangleOrientation(triangle, &orientation)) return std::vector<V>();
+  std::vector<V> out = subject;
+  for (int edge = 0; edge < 3 && !out.empty(); edge++) {
+    std::vector<V> input = out;
+    out.clear();
+    for (size_t i = 0; i < input.size(); i++) {
+      const V &current = input[i];
+      const V &previous = input[(i + input.size() - 1) % input.size()];
+      float currentSide = side(triangle, edge, current.x, current.y) * orientation;
+      float previousSide = side(triangle, edge, previous.x, previous.y) * orientation;
+      bool currentInside = currentSide >= -0.0001f;
+      bool previousInside = previousSide >= -0.0001f;
+      if (currentInside) {
+        if (!previousInside) {
+          float t = previousSide / (previousSide - currentSide);
+          out.push_back(mix(previous, current, t));
+        }
+        out.push_back(current);
+      } else if (previousInside) {
+        float t = previousSide / (previousSide - currentSide);
+        out.push_back(mix(previous, current, t));
+      }
+    }
+  }
+  return out;
+}
+
+template <typename V>
+void appendFan(const std::vector<V> &polygon, std::vector<V> *out) {
+  for (size_t i = 1; i + 1 < polygon.size(); i++) {
+    out->push_back(polygon[0]);
+    out->push_back(polygon[i]);
+    out->push_back(polygon[i + 1]);
+  }
+}
+
+const ClipPathGeometry *pathAt(const DisplayList &list, int index) {
+  if (index < 0 || (size_t)index >= list.clip_paths.size()) return nullptr;
+  return &list.clip_paths[(size_t)index];
+}
+
+template <typename V, typename Mix>
+uint32_t appendClipped(std::vector<V> &out, const std::vector<V> &quad, const PaintClip &clip,
+                       const DisplayList &list, Mix mix) {
+  if (clip.path_count <= 0) {
+    appendFan(quad, &out);
+    return 6;
+  }
+  const ClipPathGeometry *first = pathAt(list, clip.paths[0]);
+  if (first == nullptr || first->triangles.empty()) return 0;
+  uint32_t before = (uint32_t)out.size();
+  if (clip.path_count == 1) {
+    for (const ClipTriangle &triangle : first->triangles) {
+      std::vector<V> clipped = clipToTriangle(quad, triangle, mix);
+      if (clipped.size() >= 3) appendFan(clipped, &out);
+    }
+  } else {
+    const ClipPathGeometry *second = pathAt(list, clip.paths[1]);
+    if (second == nullptr || second->triangles.empty()) return 0;
+    for (const ClipTriangle &outer : first->triangles) {
+      std::vector<V> firstClip = clipToTriangle(quad, outer, mix);
+      if (firstClip.size() < 3) continue;
+      for (const ClipTriangle &inner : second->triangles) {
+        std::vector<V> secondClip = clipToTriangle(firstClip, inner, mix);
+        if (secondClip.size() >= 3) appendFan(secondClip, &out);
+      }
+    }
+  }
+  return (uint32_t)out.size() - before;
+}
+
+Vertex mixVertex(const Vertex &a, const Vertex &b, float t) {
+  Vertex out;
+  out.x = a.x + (b.x - a.x) * t;
+  out.y = a.y + (b.y - a.y) * t;
+  out.lx = a.lx + (b.lx - a.lx) * t;
+  out.ly = a.ly + (b.ly - a.ly) * t;
+  out.hx = a.hx + (b.hx - a.hx) * t;
+  out.hy = a.hy + (b.hy - a.hy) * t;
+  out.radius = a.radius + (b.radius - a.radius) * t;
+  out.r = a.r + (b.r - a.r) * t;
+  out.g = a.g + (b.g - a.g) * t;
+  out.b = a.b + (b.b - a.b) * t;
+  out.a = a.a + (b.a - a.a) * t;
+  return out;
+}
+
+TextVertex mixTextVertex(const TextVertex &a, const TextVertex &b, float t) {
+  TextVertex out;
+  out.x = a.x + (b.x - a.x) * t;
+  out.y = a.y + (b.y - a.y) * t;
+  out.u = a.u + (b.u - a.u) * t;
+  out.v = a.v + (b.v - a.v) * t;
+  out.r = a.r + (b.r - a.r) * t;
+  out.g = a.g + (b.g - a.g) * t;
+  out.b = a.b + (b.b - a.b) * t;
+  out.a = a.a + (b.a - a.a) * t;
+  return out;
+}
+
+}  // namespace
+
+uint32_t pushShape(std::vector<Vertex> &verts, const PaintRect &rect, const PaintClip &clip,
+                   const DisplayList &list) {
+  float hw = rect.width * 0.5f;
+  float hh = rect.height * 0.5f;
+  float cx = rect.x + hw;
+  float cy = rect.y + hh;
+  float radius = std::min(rect.radius, std::min(hw, hh));
+  const float local_x[4] = {-hw, hw, hw, -hw};
+  const float local_y[4] = {-hh, -hh, hh, hh};
+  std::vector<Vertex> quad(4);
+  for (int i = 0; i < 4; i++) {
+    rect.transform.apply(cx + local_x[i], cy + local_y[i], &quad[i].x, &quad[i].y);
+    quad[i].lx = local_x[i];
+    quad[i].ly = local_y[i];
+    quad[i].hx = hw;
+    quad[i].hy = hh;
+    quad[i].radius = radius;
+    quad[i].r = rect.color.r;
+    quad[i].g = rect.color.g;
+    quad[i].b = rect.color.b;
+    quad[i].a = rect.color.a;
+  }
+  return appendClipped(verts, quad, clip, list, mixVertex);
+}
+
+uint32_t pushQuad(std::vector<TextVertex> &verts, const float corners_x[4],
+                  const float corners_y[4], const float u[4], const float v[4],
+                  const Color &color, const Matrix2D &transform, const PaintClip &clip,
+                  const DisplayList &list) {
+  std::vector<TextVertex> quad(4);
+  for (int i = 0; i < 4; i++) {
+    transform.apply(corners_x[i], corners_y[i], &quad[i].x, &quad[i].y);
+    quad[i].u = u[i];
+    quad[i].v = v[i];
+    quad[i].r = color.r;
+    quad[i].g = color.g;
+    quad[i].b = color.b;
+    quad[i].a = color.a;
+  }
+  return appendClipped(verts, quad, clip, list, mixTextVertex);
+}
+
+uint32_t pushGlyph(std::vector<TextVertex> &verts, float x, float y, float width, float height,
+                   const GlyphEntry &entry, const Color &color, const Matrix2D &transform,
+                   const PaintClip &clip, const DisplayList &list) {
+  const float corners_x[4] = {x, x + width, x + width, x};
+  const float corners_y[4] = {y, y, y + height, y + height};
+  const float u[4] = {entry.u0, entry.u1, entry.u1, entry.u0};
+  const float v[4] = {entry.v0, entry.v0, entry.v1, entry.v1};
+  return pushQuad(verts, corners_x, corners_y, u, v, color, transform, clip, list);
+}
+
+}  // namespace renderer_detail
+}  // namespace xtgui

package/runtime/ext_gui/renderer_image.cpp

@@ -13,6 +13,7 @@
 #include "image.h"
 #include "media.h"
 #include "svg.h"
+#include "webgl.h"
 
 #include "renderer_shaders.h"
 
@@ -114,8 +115,12 @@ static SDL_GPUTexture *ensureMediaTexture(SDL_GPUDevice *device, uint64_t media_
 }
 
 /** Ensure the texture for `canvas_id` exists and holds the canvas's newest
- * pixels. Returns `nullptr` for an unknown or empty canvas. */
+ * pixels. A WebGL canvas already owns its colour target, so it is returned
+ * directly and nothing is copied through the CPU. */
 static SDL_GPUTexture *ensureCanvasTexture(SDL_GPUDevice *device, uint64_t canvas_id) {
+  if (xtgui::WebGLContext *webgl = xtgui::xt_webgl_by_id(canvas_id)) {
+    return webgl->color_texture();
+  }
   xtgui::Canvas2D *canvas = xtgui::xt_canvas_by_id(canvas_id);
   if (canvas == nullptr) return nullptr;
   const xtgui::Image &image = canvas->image();
@@ -315,14 +320,14 @@ void xt_gui_image_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
   if (scale <= 0.0f) scale = 1.0f;
   std::vector<TextVertex> verts;
   verts.reserve(list.images.size() * 6);
-  xtgui::Color white{1.0f, 1.0f, 1.0f, 1.0f};
   GlyphEntry full;
   full.u0 = 0.0f;
   full.v0 = 0.0f;
   full.u1 = 1.0f;
   full.v1 = 1.0f;
-  for (size_t index = 0; index < list.images.size(); index++) {
-    const xtgui::PaintImage &image = list.images[index];
+  for (const xtgui::PaintOp &op : list.ops) {
+    if (op.kind != xtgui::PaintKind::Image || op.index >= list.images.size()) continue;
+    const xtgui::PaintImage &image = list.images[op.index];
     if (image.width <= 0.0f || image.height <= 0.0f) continue;
     /* Draw-time device pixels: an SVG (file or inline) is rasterised at this
      * size so it stays crisp on HiDPI and when scaled. */
@@ -341,10 +346,10 @@ void xt_gui_image_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
       texture = ensureImageTexture(device, image.src, pixel_width, pixel_height);
     }
     if (texture == nullptr) continue;
-    pushGlyph(verts, image.x, image.y, image.width, image.height, full, white,
-              image.transform);
-    geometry->op_counts[index] = 6;
-    geometry->op_textures[index] = texture;
+    uint32_t count = pushGlyph(verts, image.x, image.y, image.width, image.height, full,
+                               image.tint, image.transform, op.clip, list);
+    geometry->op_counts[op.index] = count;
+    geometry->op_textures[op.index] = texture;
   }
   uploadVertices(device, geometry, verts.data(), (uint32_t)verts.size(), sizeof(TextVertex));
 }

package/runtime/ext_gui/renderer_internal.h

@@ -79,14 +79,21 @@ extern bool g_atlas_full_logged;
 
 /* -- geometry helpers ----------------------------------------------------- */
 
-void pushRect(std::vector<Vertex> &verts, const xtgui::PaintRect &rect);
-void pushGlyph(std::vector<TextVertex> &verts, float x, float y, float width, float height,
-               const GlyphEntry &entry, const xtgui::Color &color,
-               const xtgui::Matrix2D &transform);
-/** Push a textured quad, applying a `transform` matrix to its four corners. */
-void pushQuad(std::vector<TextVertex> &verts, const float corners_x[4], const float corners_y[4],
-              const float u[4], const float v[4], const xtgui::Color &color,
-              const xtgui::Matrix2D &transform);
+/** Push one rounded rectangle, clipped by the op's `clip-path` polygons (if
+ * any). Returns the number of vertices appended. */
+uint32_t pushShape(std::vector<Vertex> &verts, const xtgui::PaintRect &rect,
+                   const xtgui::PaintClip &clip, const xtgui::DisplayList &list);
+/** Push one glyph quad, clipped by `clip-path`. */
+uint32_t pushGlyph(std::vector<TextVertex> &verts, float x, float y, float width, float height,
+                   const GlyphEntry &entry, const xtgui::Color &color,
+                   const xtgui::Matrix2D &transform, const xtgui::PaintClip &clip,
+                   const xtgui::DisplayList &list);
+/** Push a textured quad, applying a `transform` matrix to its four corners and
+ * clipping it by `clip-path`. */
+uint32_t pushQuad(std::vector<TextVertex> &verts, const float corners_x[4],
+                  const float corners_y[4], const float u[4], const float v[4],
+                  const xtgui::Color &color, const xtgui::Matrix2D &transform,
+                  const xtgui::PaintClip &clip, const xtgui::DisplayList &list);
 void uploadVertices(SDL_GPUDevice *device, XtGuiGeometry *geometry, const void *data,
                     uint32_t count, uint32_t stride);
 

package/runtime/ext_gui/renderer_text.cpp

@@ -22,33 +22,6 @@ namespace renderer_detail {
 constexpr float kMinGlyphScale = 0.5f;
 constexpr float kMaxGlyphScale = 4.0f;
 
-void pushQuad(std::vector<TextVertex> &verts, const float corners_x[4], const float corners_y[4],
-              const float u[4], const float v[4], const xtgui::Color &color,
-              const xtgui::Matrix2D &transform) {
-  TextVertex corners[4];
-  for (int i = 0; i < 4; i++) {
-    transform.apply(corners_x[i], corners_y[i], &corners[i].x, &corners[i].y);
-    corners[i].u = u[i];
-    corners[i].v = v[i];
-    corners[i].r = color.r;
-    corners[i].g = color.g;
-    corners[i].b = color.b;
-    corners[i].a = color.a;
-  }
-  static const int order[6] = {0, 1, 2, 0, 2, 3};
-  for (int i = 0; i < 6; i++) verts.push_back(corners[order[i]]);
-}
-
-void pushGlyph(std::vector<TextVertex> &verts, float x, float y, float width, float height,
-               const GlyphEntry &entry, const xtgui::Color &color,
-               const xtgui::Matrix2D &transform) {
-  const float corners_x[4] = {x, x + width, x + width, x};
-  const float corners_y[4] = {y, y, y + height, y + height};
-  const float u[4] = {entry.u0, entry.u1, entry.u1, entry.u0};
-  const float v[4] = {entry.v0, entry.v0, entry.v1, entry.v1};
-  pushQuad(verts, corners_x, corners_y, u, v, color, transform);
-}
-
 bool ensureAtlasTexture(SDL_GPUDevice *device) {
   if (g_atlas_texture != nullptr) return true;
   SDL_GPUTextureCreateInfo info;
@@ -307,8 +280,9 @@ void xt_gui_text_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
 
   std::vector<TextVertex> verts;
   geometry->op_counts.assign(list.texts.size(), 0);
-  for (size_t index = 0; index < list.texts.size(); index++) {
-    const xtgui::PaintText &run = list.texts[index];
+  for (const xtgui::PaintOp &op : list.ops) {
+    if (op.kind != xtgui::PaintKind::Text || op.index >= list.texts.size()) continue;
+    const xtgui::PaintText &run = list.texts[op.index];
     if (run.text.empty() || run.color.a <= 0.0f) continue;
     xtgui::Font *logical = xtgui::xt_text_resolve(run.font);
     if (logical == nullptr) continue;
@@ -341,12 +315,13 @@ void xt_gui_text_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
           float quad_y = run.baseline + glyph.y_offset - (float)entry.top / glyph_scale;
           float quad_w = (float)entry.width / glyph_scale;
           float quad_h = (float)entry.height / glyph_scale;
-          pushGlyph(verts, quad_x, quad_y, quad_w, quad_h, entry, run.color, run.transform);
+          pushGlyph(verts, quad_x, quad_y, quad_w, quad_h, entry, run.color, run.transform,
+                    op.clip, list);
         }
       }
       pen_x += glyph.x_advance;
     }
-    geometry->op_counts[index] = (uint32_t)verts.size() - before;
+    geometry->op_counts[op.index] = (uint32_t)verts.size() - before;
   }
   uploadVertices(device, geometry, verts.data(), (uint32_t)verts.size(), sizeof(TextVertex));
   flushAtlas(device);