xbintsc 0.5.41 → 0.5.43

package/runtime/ext_gui/renderer_gradient.cpp

@@ -0,0 +1,156 @@
+/*
+ * xbintsc GUI engine — radial `background-image` rasterisation.
+ *
+ * The shape pipeline fills one shape with one flat colour, and the bands a
+ * radial gradient used to be drawn as are nested ellipses: every band covers the
+ * whole interior, so each band's alpha composites over the previous ones and a
+ * vignette whose stops fade to `transparent` ends up opaque. The ramp is
+ * therefore resolved per pixel into an RGBA texture, which the image pipeline
+ * draws as one quad and composites exactly once.
+ */
+
+#include "renderer_internal.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdio>
+#include <string>
+#include <unordered_map>
+
+namespace xtgui {
+namespace renderer_detail {
+
+namespace {
+
+/** A rasterised gradient, keyed by the paint pass's cache key plus the logical
+ * box size. The texture is re-rasterised in place when the device pixel size
+ * changes (a DPI change), so a resized gradient never leaves a stale texture. */
+struct GradientTexture {
+  SDL_GPUTexture *texture = nullptr;
+  int width = 0;
+  int height = 0;
+  /** Set by the upload pass that draws this gradient; see `finishGradientUpload`. */
+  bool used = false;
+};
+
+std::unordered_map<std::string, GradientTexture> g_gradient_textures;
+
+/** How many rasterised gradients that are no longer drawn are kept. A gradient's
+ * stops can animate (a `hue-rotate` loop, say), which would otherwise rasterise a
+ * fresh texture every frame and never free the old ones. */
+constexpr size_t kMaxStaleGradients = 8;
+
+/** Largest texture edge a gradient is rasterised at. A radial ramp is smooth, so
+ * a larger box is rasterised smaller and stretched: the sampled colours are
+ * unchanged (the stretch is uniform), only the resolution of the ramp drops. */
+constexpr int kMaxGradientEdge = 1024;
+
+unsigned char byteOf(float value) {
+  if (!(value > 0.0f)) return 0;  // NaN and negatives
+  if (value > 1.0f) value = 1.0f;
+  return (unsigned char)(value * 255.0f + 0.5f);
+}
+
+/** Rasterise `gradient` into `out`: the box maps 1:1 onto the texture. The ramp
+ * covers the whole box — past the ending shape CSS keeps the last stop's colour
+ * rather than fading out — so there is no shape edge to antialias; the texels
+ * are sampled with linear filtering. */
+void rasterizeGradient(const PaintGradient &gradient, float logical_width, float logical_height,
+                       int pixel_width, int pixel_height, Image *out) {
+  out->width = pixel_width;
+  out->height = pixel_height;
+  out->pixels.assign((size_t)pixel_width * (size_t)pixel_height * 4u, 0);
+  const float pixel_x = logical_width / (float)pixel_width;  // logical px per texel
+  const float pixel_y = logical_height / (float)pixel_height;
+  const float inv_rx = 1.0f / gradient.radius_x;
+  const float inv_ry = 1.0f / gradient.radius_y;
+  for (int y = 0; y < pixel_height; y++) {
+    const float local_y = ((float)y + 0.5f) * pixel_y;
+    unsigned char *row = out->pixels.data() + (size_t)y * (size_t)pixel_width * 4u;
+    for (int x = 0; x < pixel_width; x++) {
+      const float local_x = ((float)x + 0.5f) * pixel_x;
+      const float u = (local_x - gradient.center_x) * inv_rx;
+      const float v = (local_y - gradient.center_y) * inv_ry;
+      const float t = std::sqrt(u * u + v * v);
+      Color color =
+          paint_detail::gradientColorAt(gradient.stops, gradient.repeating, gradient.period, t);
+      if (color.a <= 0.0f) continue;
+      unsigned char *texel = row + (size_t)x * 4u;
+      texel[0] = byteOf(color.r);
+      texel[1] = byteOf(color.g);
+      texel[2] = byteOf(color.b);
+      texel[3] = byteOf(color.a);
+    }
+  }
+}
+
+/** The device size a gradient of `pixel_width` x `pixel_height` is rasterised at,
+ * preserving its aspect ratio under `kMaxGradientEdge`. */
+void rasterSize(int pixel_width, int pixel_height, int *width, int *height) {
+  *width = std::max(1, pixel_width);
+  *height = std::max(1, pixel_height);
+  if (*width <= kMaxGradientEdge && *height <= kMaxGradientEdge) return;
+  float shrink = (float)kMaxGradientEdge / (float)std::max(*width, *height);
+  *width = std::max(1, (int)((float)*width * shrink + 0.5f));
+  *height = std::max(1, (int)((float)*height * shrink + 0.5f));
+}
+
+}  // namespace
+
+void beginGradientUpload() {
+  for (auto &entry : g_gradient_textures) entry.second.used = false;
+}
+
+void finishGradientUpload(SDL_GPUDevice *device) {
+  if (g_gradient_textures.size() <= kMaxStaleGradients) return;
+  /* The display list of the frame being built may hold pointers to the textures
+   * it used, so only gradients it did *not* use can go. */
+  for (auto it = g_gradient_textures.begin(); it != g_gradient_textures.end();) {
+    if (it->second.used) {
+      ++it;
+      continue;
+    }
+    if (it->second.texture != nullptr) SDL_ReleaseGPUTexture(device, it->second.texture);
+    it = g_gradient_textures.erase(it);
+  }
+}
+
+SDL_GPUTexture *ensureGradientTexture(SDL_GPUDevice *device, const xtgui::PaintImage &image,
+                                      int pixel_width, int pixel_height, XtGuiUploadBatch *batch) {
+  if (image.gradient == nullptr || image.width <= 0.0f || image.height <= 0.0f) return nullptr;
+  const xtgui::PaintGradient &gradient = *image.gradient;
+  if (gradient.radius_x <= 0.0f || gradient.radius_y <= 0.0f || gradient.stops.size() < 2) {
+    return nullptr;
+  }
+  int width = 0;
+  int height = 0;
+  rasterSize(pixel_width, pixel_height, &width, &height);
+  /* The key carries the ramp, its geometry and the logical box size: two boxes
+   * of different sizes can resolve the same px radius but not the same picture. */
+  char box[64];
+  std::snprintf(box, sizeof(box), "@%.3f,%.3f", image.width, image.height);
+  std::string key = gradient.key + box;
+  GradientTexture &entry = g_gradient_textures[key];
+  entry.used = true;
+  if (entry.texture != nullptr && entry.width == width && entry.height == height) {
+    return entry.texture;
+  }
+  Image raster;
+  rasterizeGradient(gradient, image.width, image.height, width, height, &raster);
+  SDL_GPUTexture *texture = createImageTexture(device, raster, batch);
+  if (entry.texture != nullptr) SDL_ReleaseGPUTexture(device, entry.texture);
+  entry.texture = texture;
+  entry.width = texture != nullptr ? width : 0;
+  entry.height = texture != nullptr ? height : 0;
+  return texture;
+}
+
+void releaseGradientTextures(SDL_GPUDevice *device) {
+  for (auto &entry : g_gradient_textures) {
+    if (entry.second.texture != nullptr) SDL_ReleaseGPUTexture(device, entry.second.texture);
+  }
+  g_gradient_textures.clear();
+}
+
+}  // namespace renderer_detail
+}  // namespace xtgui

package/runtime/ext_gui/renderer_image.cpp

@@ -379,6 +379,7 @@ void xt_gui_image_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
   full.v0 = 0.0f;
   full.u1 = 1.0f;
   full.v1 = 1.0f;
+  beginGradientUpload();
   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];
@@ -390,7 +391,9 @@ void xt_gui_image_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
     if (pixel_width < 1) pixel_width = 1;
     if (pixel_height < 1) pixel_height = 1;
     SDL_GPUTexture *texture = nullptr;
-    if (image.canvas_id != 0) {
+    if (image.gradient != nullptr) {
+      texture = ensureGradientTexture(device, image, pixel_width, pixel_height, batch);
+    } else if (image.canvas_id != 0) {
       texture = ensureCanvasTexture(device, image.canvas_id, batch);
     } else if (image.media_id != 0) {
       texture = ensureMediaTexture(device, image.media_id, batch);
@@ -405,11 +408,13 @@ void xt_gui_image_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
     geometry->op_counts[op.index] = count;
     geometry->op_textures[op.index] = texture;
   }
+  finishGradientUpload(device);
   uploadVertices(device, geometry, verts.data(), (uint32_t)verts.size(), sizeof(TextVertex), batch);
 }
 
 void xt_gui_image_textures_destroy(SDL_GPUDevice *device) {
   using namespace xtgui::renderer_detail;
+  releaseGradientTextures(device);
   for (auto &entry : g_image_textures) {
     if (entry.second != nullptr) SDL_ReleaseGPUTexture(device, entry.second);
   }

package/runtime/ext_gui/renderer_internal.h

@@ -14,6 +14,7 @@
 #include <unordered_map>
 #include <vector>
 
+#include "image.h"
 #include "paint.h"
 #include "renderer.h"
 
@@ -68,6 +69,8 @@ struct GlyphKeyHash {
 };
 
 extern SDL_GPUTexture *g_atlas_texture;
+extern SDL_GPUDevice *g_device;
+extern SDL_GPUTextureFormat g_swapchain_format;
 extern std::vector<unsigned char> g_atlas_mirror;
 extern std::unordered_map<GlyphKey, GlyphEntry, GlyphKeyHash> g_glyphs;
 extern int g_atlas_x;
@@ -118,9 +121,37 @@ void flushAtlas(SDL_GPUDevice *device, XtGuiUploadBatch *batch);
 SDL_GPUGraphicsPipeline *createTextPipeline(SDL_GPUDevice *device, SDL_Window *reference);
 SDL_GPUSampler *createSampler(SDL_GPUDevice *device);
 
+/* -- draw runs ------------------------------------------------------------ */
+
+/** Draw the drawable runs in `[begin, end)` into an active pass. Layer markers
+ * are skipped. State is re-bound after a pass restart. */
+void drawRuns(SDL_GPURenderPass *pass, const std::vector<XtGuiDrawRun> &runs, size_t begin,
+              size_t end, XtGuiGeometry *shapes, XtGuiGeometry *texts, XtGuiGeometry *images,
+              int target_width, int target_height, float pixel_density);
+
+/* -- mix-blend-mode layers ------------------------------------------------ */
+
+/** True when the runtime blend pipeline was created (and the backend consumes
+ * SPIR-V or MSL). D3D12/DXIL has no shader compiler here, so it falls back to
+ * the ordinary single-pass painter. */
+bool layerRendererReady(SDL_GPUDevice *device);
+/** Render `list` through the offscreen layer compositor into `swapchain`.
+ * Returns false before recording any pass when the scene textures cannot be
+ * created, so the caller can fall back to the ordinary painter. */
+bool drawLayeredScene(SDL_GPUCommandBuffer *cmd, SDL_GPUTexture *swapchain,
+                      const float clear_color[4], XtGuiGeometry *shapes, XtGuiGeometry *texts,
+                      XtGuiGeometry *images, const xtgui::DisplayList &list,
+                      float viewport_width, float viewport_height, float pixel_density);
+/** Release the blend pipeline and sampler. */
+void layerRendererDestroy(SDL_GPUDevice *device);
+
 /* -- images --------------------------------------------------------------- */
 
 SDL_GPUGraphicsPipeline *createImagePipeline(SDL_GPUDevice *device, SDL_Window *reference);
+/** Create an RGBA texture holding `image` and upload its pixels. Returns null
+ * (after reporting the SDL error) when either step fails. */
+SDL_GPUTexture *createImageTexture(SDL_GPUDevice *device, const xtgui::Image &image,
+                                   XtGuiUploadBatch *batch);
 /** Decode `src` (cached) and upload it as an RGBA texture. `pixel_width` /
  * `pixel_height` are the drawn size in device pixels; vector sources (SVG) are
  * rasterised at that size, raster sources ignore it. The texture cache is keyed
@@ -128,6 +159,23 @@ SDL_GPUGraphicsPipeline *createImagePipeline(SDL_GPUDevice *device, SDL_Window *
 SDL_GPUTexture *ensureImageTexture(SDL_GPUDevice *device, const std::string &src, int pixel_width,
                                    int pixel_height, XtGuiUploadBatch *batch);
 
+/* -- background gradients ------------------------------------------------- */
+
+/** Rasterise a `PaintImage` radial gradient into an RGBA texture and cache it by
+ * the paint pass's key. The ramp is resolved per device pixel, so a translucent
+ * gradient composites once instead of once per band. Bracket a frame's uploads
+ * with `beginGradientUpload`/`finishGradientUpload` so textures the frame no
+ * longer draws can be reclaimed; returns null when it cannot be created. */
+SDL_GPUTexture *ensureGradientTexture(SDL_GPUDevice *device, const xtgui::PaintImage &image,
+                                      int pixel_width, int pixel_height, XtGuiUploadBatch *batch);
+/** Mark every cached gradient unused; `ensureGradientTexture` marks the ones the
+ * upload pass draws. */
+void beginGradientUpload();
+/** Release cached gradients the pass did not draw, keeping the cache bounded. */
+void finishGradientUpload(SDL_GPUDevice *device);
+/** Release every rasterised gradient texture. */
+void releaseGradientTextures(SDL_GPUDevice *device);
+
 }  // namespace renderer_detail
 }  // namespace xtgui