xbintsc 0.5.45 → 0.5.52

package/runtime/ext_gui/renderer_internal.h

@@ -135,6 +135,16 @@ void drawRuns(SDL_GPURenderPass *pass, const std::vector<XtGuiDrawRun> &runs, si
  * 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);
+/** True when the `backdrop-filter` snapshot/filter pipeline was created. */
+bool backdropRendererReady(SDL_GPUDevice *device);
+/** Filter `source` into the active scene pass inside the element's rounded
+ * border box. No-op when the pipeline is unavailable. */
+void drawBackdropPass(SDL_GPUCommandBuffer *cmd, SDL_GPURenderPass *pass,
+                      SDL_GPUTexture *source, const xtgui::DisplayList &list,
+                      const XtGuiDrawRun &run, int target_width, int target_height,
+                      float pixel_density);
+/** Release the backdrop pipeline and sampler. */
+void backdropRendererDestroy(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. */
@@ -159,6 +169,17 @@ SDL_GPUTexture *createImageTexture(SDL_GPUDevice *device, const xtgui::Image &im
 SDL_GPUTexture *ensureImageTexture(SDL_GPUDevice *device, const std::string &src, int pixel_width,
                                    int pixel_height, XtGuiUploadBatch *batch);
 
+/* -- CPU-rasterised shadows ---------------------------------------------- */
+
+/** Upload (once) the blurred mask of a `box-shadow`/`text-shadow` layer and
+ * return its cached texture. Bracket the frame's image upload with
+ * `beginBitmapUpload`/`finishBitmapUpload` so stale masks are reclaimed. */
+SDL_GPUTexture *ensureBitmapTexture(SDL_GPUDevice *device, const xtgui::PaintBitmap &bitmap,
+                                    XtGuiUploadBatch *batch);
+void beginBitmapUpload();
+void finishBitmapUpload(SDL_GPUDevice *device);
+void releaseBitmapTextures(SDL_GPUDevice *device);
+
 /* -- background gradients ------------------------------------------------- */
 
 /** Rasterise a `PaintImage` radial gradient into an RGBA texture and cache it by

package/runtime/ext_gui/renderer_layer.cpp

@@ -17,14 +17,16 @@
 
 #include "renderer_internal.h"
 
+#include <algorithm>
+#include <cmath>
 #include <cstdio>
 #include <cstring>
 #include <string>
 #include <vector>
 
+#include "gpu_shader_api.h"
 #include "perf.h"
 #include "webgl_glsl.h"
-#include "webgl_msl.h"
 
 namespace xtgui {
 namespace renderer_detail {
@@ -136,6 +138,7 @@ SDL_GPUSampler *g_layer_sampler = nullptr;
 SDL_GPUTextureFormat g_layer_format = SDL_GPU_TEXTUREFORMAT_INVALID;
 bool g_layer_failed = false;
 
+
 struct BlendParams {
   int mode;
   int padding[3];
@@ -154,8 +157,13 @@ void pushMode(SDL_GPUCommandBuffer *cmd, int mode) {
 bool prepareStage(const std::string &source, bool fragment, SDL_GPUShaderFormat formats,
                   std::vector<uint32_t> *spirv, std::string *text, const Uint8 **code,
                   size_t *code_size, std::string *entry, std::string *log) {
+  const GpuShaderApi *api = gpu_shader_api();
+  if (api == nullptr) {
+    *log = "shader translation was not linked (the 'gpu' link feature is inactive)";
+    return false;
+  }
   GlslShaderInfo info;
-  scan_glsl(source, fragment, &info);
+  api->scan_glsl(source, fragment, &info);
   if (!info.unsupported.empty()) {
     *log = info.unsupported;
     return false;
@@ -167,11 +175,11 @@ bool prepareStage(const std::string &source, bool fragment, SDL_GPUShaderFormat
     layout.samplers["u_layer"] = 1;
     layout.block_members = info.uniforms;
   }
-  const std::string rewritten = rewrite_glsl(source, fragment, layout, info);
-  if (!compile_glsl(rewritten, fragment, spirv, log)) return false;
+  const std::string rewritten = api->rewrite_glsl(source, fragment, layout, info);
+  if (!api->compile_glsl(rewritten, fragment, spirv, log)) return false;
 
   if ((formats & SDL_GPU_SHADERFORMAT_MSL) != 0) {
-    if (!cross_compile_msl(*spirv, fragment, text, entry, log)) return false;
+    if (!api->cross_compile_msl(*spirv, fragment, text, entry, log)) return false;
     *code = (const Uint8 *)text->data();
     *code_size = text->size();
     return true;
@@ -450,10 +458,31 @@ void renderSequence(SceneContext &context, size_t begin, size_t end, int depth,
       continue;
     }
     if (run.pipeline == XtGuiDrawRun::LayerEnd) continue;
+    if (run.pipeline == XtGuiDrawRun::Backdrop) {
+      if (g_layer_pipeline == nullptr) continue;
+      SDL_EndGPURenderPass(pass);
+      SDL_GPUTexture *scene = sceneTexture(context.shapes, depth, context.parity[depth]);
+      SDL_GPUTexture *scratch =
+          sceneTexture(context.shapes, depth, context.parity[depth] ^ 1);
+      if (scene != nullptr && scratch != nullptr) {
+        /* Copy the scene first: a blur samples around every pixel, so it cannot
+         * read the target it is writing. */
+        compositePass(context, scratch, scene, scene, -1);
+        beginPass(context.cmd, scene, false, nullptr, &pass);
+        if (pass == nullptr) return;
+        drawBackdropPass(context.cmd, pass, scratch, *context.list, run, context.target_width,
+                         context.target_height, context.pixel_density);
+      } else {
+        beginPass(context.cmd, scene, false, nullptr, &pass);
+        if (pass == nullptr) return;
+      }
+      continue;
+    }
 
     size_t segment_end = i;
     while (segment_end < end && runs[segment_end].pipeline != XtGuiDrawRun::LayerBegin &&
-           runs[segment_end].pipeline != XtGuiDrawRun::LayerEnd) {
+           runs[segment_end].pipeline != XtGuiDrawRun::LayerEnd &&
+           runs[segment_end].pipeline != XtGuiDrawRun::Backdrop) {
       segment_end++;
     }
     drawRuns(pass, runs, i, segment_end, context.shapes, context.texts, context.images,
@@ -467,6 +496,7 @@ void renderSequence(SceneContext &context, size_t begin, size_t end, int depth,
 
 bool layerRendererReady(SDL_GPUDevice *device) { return ensureLayerPipeline(device); }
 
+
 bool drawLayeredScene(SDL_GPUCommandBuffer *cmd, SDL_GPUTexture *swapchain,
                       const float clear_color[4], XtGuiGeometry *shapes, XtGuiGeometry *texts,
                       XtGuiGeometry *images, const DisplayList &list, float viewport_width,
@@ -546,6 +576,7 @@ void layerRendererDestroy(SDL_GPUDevice *device) {
   }
   g_layer_format = SDL_GPU_TEXTUREFORMAT_INVALID;
   g_layer_failed = false;
+  backdropRendererDestroy(device);
 }
 
 }  // namespace renderer_detail

package/runtime/ext_gui/renderer_text.cpp

@@ -299,7 +299,8 @@ void xt_gui_text_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
     if (glyph_scale < kMinGlyphScale) glyph_scale = kMinGlyphScale;
     if (glyph_scale > kMaxGlyphScale) glyph_scale = kMaxGlyphScale;
 
-    const xtgui::ShapedRun *shaped = xtgui::xt_text_shape_cached(run.text, logical);
+    const xtgui::ShapedRun *shaped =
+        xtgui::xt_text_shape_cached(run.text, logical, run.font.letter_spacing);
     if (shaped == nullptr) continue;
     float pen_x = run.x;
     uint32_t before = (uint32_t)verts.size();