xbintsc 0.3.46 → 0.3.61

package/runtime/ext_gui/layout_flow.cpp

@@ -48,6 +48,8 @@ float Layouter::preferredContentWidth(const LayoutBox *box, float available) con
   float best = 0;
   for (const std::unique_ptr<LayoutBox> &child : box->children) {
     if (child->display == Display::None) continue;
+    /* Out-of-flow children do not contribute to the parent's intrinsic width. */
+    if (isAbsoluteChild(child.get())) continue;
     if (child->is_text) {
       best = std::max(best, textWidth(child->text, *child->style));
     } else {
@@ -91,18 +93,107 @@ void Layouter::resolveEdges(LayoutBox *box, float containingWidth) const {
   }
 }
 
+bool Layouter::establishesContainingBlock(const LayoutBox *box) {
+  return box->style != nullptr && box->style->position != Position::Static;
+}
+
+const LayoutBox *Layouter::containingBlockAncestor(const LayoutBox *box) const {
+  /* Absolute boxes resolve against the padding box of the nearest ancestor with
+   * `position != static`; when there is none, the caller falls back to the
+   * initial containing block (the viewport). */
+  for (const LayoutBox *ancestor = box; ancestor != nullptr; ancestor = ancestor->parent) {
+    if (establishesContainingBlock(ancestor)) return ancestor;
+  }
+  return nullptr;
+}
+
+void Layouter::setContainingBlock(LayoutBox *box, const LayoutBox *ancestor) const {
+  if (ancestor != nullptr) {
+    /* The padding box of the ancestor. Its height is only known once the
+     * ancestor's own layout has finished, which is why `publishContainingBlock`
+     * is called again at the end of `layoutBlock` for the box that owns it. */
+    box->cb_x = ancestor->content_x - ancestor->padding_left;
+    box->cb_y = ancestor->content_y - ancestor->padding_top;
+    box->cb_width = ancestor->padding_left + ancestor->content_width + ancestor->padding_right;
+    box->cb_height = ancestor->padding_top + ancestor->content_height + ancestor->padding_bottom;
+    return;
+  }
+  /* No positioned ancestor: the initial containing block is the viewport. */
+  box->cb_x = 0;
+  box->cb_y = 0;
+  box->cb_width = vw;
+  box->cb_height = vh;
+}
+
+void Layouter::publishContainingBlock(LayoutBox *box) const {
+  if (!establishesContainingBlock(box)) return;
+  for (const std::unique_ptr<LayoutBox> &child : box->children) setContainingBlock(child.get(), box);
+}
+
+void Layouter::applyPosition(LayoutBox *box) const {
+  if (box->style == nullptr) return;
+  const XtStyle &style = *box->style;
+  if (style.position == Position::Static) return;
+  float em = style.font_size;
+
+  if (style.position == Position::Relative) {
+    /* Relative positioning offsets the box (and its subtree) without changing
+     * the space it occupies in the flow. */
+    float dx = 0;
+    float dy = 0;
+    if (!isAuto(style.left)) dx = px(style.left, box->cb_width, em);
+    else if (!isAuto(style.right)) dx = -px(style.right, box->cb_width, em);
+    if (!isAuto(style.top)) dy = px(style.top, box->cb_height, em);
+    else if (!isAuto(style.bottom)) dy = -px(style.bottom, box->cb_height, em);
+    if (dx != 0 || dy != 0) translate(box, dx, dy);
+    return;
+  }
+
+  /* Absolute (and fixed, which resolves against the viewport): the static
+   * position stands in for every `auto` inset. */
+  float x = box->x;
+  float y = box->y;
+  if (!isAuto(style.left)) x = box->cb_x + px(style.left, box->cb_width, em) + box->margin_left;
+  else if (!isAuto(style.right)) {
+    x = box->cb_x + box->cb_width - px(style.right, box->cb_width, em) - box->margin_right - box->width;
+  }
+  if (!isAuto(style.top)) y = box->cb_y + px(style.top, box->cb_height, em) + box->margin_top;
+  else if (!isAuto(style.bottom)) {
+    y = box->cb_y + box->cb_height - px(style.bottom, box->cb_height, em) - box->margin_bottom - box->height;
+  }
+  translate(box, x - box->x, y - box->y);
+}
+
 float Layouter::layoutBlock(LayoutBox *box, float x, float y, float availableWidth,
                             float availableHeight, float forcedContentWidth,
-                            float forcedContentHeight) const {
+                            float forcedContentHeight, bool inFlow) const {
   const XtStyle &style = *box->style;
   float em = style.font_size;
   resolveEdges(box, availableWidth);
 
   float contentWidth;
+  bool outOfFlow = style.position == Position::Absolute || style.position == Position::Fixed;
   if (forcedContentWidth >= 0) {
     contentWidth = forcedContentWidth;
   } else if (isAuto(style.width)) {
-    contentWidth = availableWidth - horizontalEdges(box);
+    if (outOfFlow && !isAuto(style.left) && !isAuto(style.right)) {
+      /* Both horizontal insets are set, so `auto` fills the space between them
+       * (the padding box of the containing block). */
+      contentWidth = box->cb_width - horizontalEdges(box) - px(style.left, box->cb_width, em) -
+                     px(style.right, box->cb_width, em);
+      if (contentWidth < 0) contentWidth = 0;
+    } else if (outOfFlow) {
+      /* An out-of-flow box does not fill its containing block: an `auto` width
+       * is shrink-to-fit — its preferred width, capped by the space available
+       * (the containing block's width, not the parent's content box, because an
+       * absolute box is laid out against the former). */
+      float available = box->cb_width - horizontalEdges(box);
+      float preferred = preferredContentWidth(box, availableWidth);
+      contentWidth = preferred < available ? preferred : available;
+      if (contentWidth < 0) contentWidth = 0;
+    } else {
+      contentWidth = availableWidth - horizontalEdges(box);
+    }
   } else {
     contentWidth = px(style.width, availableWidth, em);
   }
@@ -142,9 +233,32 @@ float Layouter::layoutBlock(LayoutBox *box, float x, float y, float availableWid
   box->height =
       box->border_top + box->padding_top + contentHeight + box->padding_bottom + box->border_bottom;
   box->baseline = box->height;
+  /* Now that this box has its final size, its padding box is the containing
+   * block its own children resolve against — and only now can an out-of-flow
+   * child be placed with `bottom`/`right`. */
+  publishContainingBlock(box);
+  layoutAbsoluteChildren(box, contentWidth, availableHeight);
+  applyPosition(box);
+  /* An absolutely positioned box consumes no space in its parent's flow. */
+  if (!inFlow) return 0;
   return box->margin_top + box->height + box->margin_bottom;
 }
 
+bool Layouter::isAbsoluteChild(const LayoutBox *box) {
+  return box->style != nullptr && (box->style->position == Position::Absolute ||
+                                   box->style->position == Position::Fixed);
+}
+
+void Layouter::layoutAbsoluteChildren(LayoutBox *block, float contentWidth,
+                                      float availableHeight) const {
+  for (const std::unique_ptr<LayoutBox> &child : block->children) {
+    if (child->display == Display::None || !isAbsoluteChild(child.get())) continue;
+    setContainingBlock(child.get(), block);
+    layoutBlock(child.get(), block->content_x, block->content_y, contentWidth, availableHeight, -1,
+                -1, false);
+  }
+}
+
 float Layouter::layoutChildren(LayoutBox *block, float contentWidth, float availableHeight,
                                float definiteHeight) const {
   if (block->style->display == Display::Flex)
@@ -155,14 +269,30 @@ float Layouter::layoutChildren(LayoutBox *block, float contentWidth, float avail
   std::vector<LayoutBox *> inlineRun;
   auto flush = [&]() {
     if (inlineRun.empty()) return;
-    y += layoutInlineRun(block, inlineRun, contentWidth, y);
+    /* Source whitespace between block boxes collapses away (HTML's model), so a
+     * run that carries no visible content produces no line at all. */
+    bool visible = false;
+    for (LayoutBox *box : inlineRun) {
+      if (!isCollapsibleText(box)) {
+        visible = true;
+        break;
+      }
+    }
+    if (visible) y += layoutInlineRun(block, inlineRun, contentWidth, y);
     inlineRun.clear();
   };
   for (const std::unique_ptr<LayoutBox> &child : block->children) {
     Display display = child->display;
     if (display == Display::None) continue;
-    if (display == Display::Block || display == Display::ListItem || display == Display::Flex) {
+    if (isAbsoluteChild(child.get())) {
+      /* Out of flow: `layoutAbsoluteChildren` places it once this block knows
+       * its own size. */
+      continue;
+    }
+    if (display == Display::Block || display == Display::ListItem || display == Display::Flex ||
+        child->style == nullptr) {
       flush();
+      setContainingBlock(child.get(), containingBlockAncestor(block));
       y += layoutBlock(child.get(), block->content_x, y, contentWidth, availableHeight);
     } else {
       inlineRun.push_back(child.get());

package/runtime/ext_gui/layout_flow_internal.h

@@ -62,6 +62,17 @@ inline bool isAuto(const Length &length) {
   return length.unit == Unit::Auto || length.unit == Unit::Invalid || length.unit == Unit::None;
 }
 
+/** True for a text node that holds nothing but HTML source whitespace. HTML
+ * collapses those away between block-level boxes, which is what keeps a
+ * document's indentation from becoming part of the page (the browser model). */
+inline bool isCollapsibleText(const LayoutBox *box) {
+  if (!box->is_text) return false;
+  for (char c : box->text) {
+    if (c != ' ' && c != '\t' && c != '\n' && c != '\r') return false;
+  }
+  return true;
+}
+
 /* Per-character advance as a fraction of the font size is no longer needed
  * here: text metrics come from the shaping stack (see `text.h`). */
 
@@ -117,14 +128,42 @@ struct Layouter {
 
   void resolveEdges(LayoutBox *box, float containingWidth) const;
 
-  /** Lay out `box` at (x, y) and return its outer height (margins included). */
+  /** Lay out `box` at (x, y) and return its outer height (margins included).
+   * `inFlow` is false for an absolutely positioned child: it is still laid out,
+   * but the caller ignores the returned height (it is out of flow). */
   float layoutBlock(LayoutBox *box, float x, float y, float availableWidth, float availableHeight,
-                    float forcedContentWidth = -1, float forcedContentHeight = -1) const;
+                    float forcedContentWidth = -1, float forcedContentHeight = -1,
+                    bool inFlow = true) const;
 
   /** Lay out the children of `block`; returns the used content height. */
   float layoutChildren(LayoutBox *block, float contentWidth, float availableHeight,
                        float definiteHeight) const;
 
+  /** Lay out the absolutely positioned children of `block`. Called once the
+   * block has its final size, because those children resolve `bottom`/`right`
+   * against its padding box. */
+  void layoutAbsoluteChildren(LayoutBox *block, float contentWidth, float availableHeight) const;
+
+  /** True when `box` establishes a containing block for absolute descendants. */
+  static bool establishesContainingBlock(const LayoutBox *box);
+
+  /** True for an out-of-flow child (`position: absolute` or `fixed`). */
+  static bool isAbsoluteChild(const LayoutBox *box);
+
+  /** Nearest ancestor (or `box` itself) that is a containing block, else null. */
+  const LayoutBox *containingBlockAncestor(const LayoutBox *box) const;
+
+  /** Re-publish the containing block of `box`'s children once `box` has its own
+   * final size (an absolute child resolves `bottom`/`right` against it). */
+  void publishContainingBlock(LayoutBox *box) const;
+
+  /** Publish `box`'s padding box as the containing block for absolute
+   * descendants of the nearest positioned ancestor (null means the viewport). */
+  void setContainingBlock(LayoutBox *box, const LayoutBox *ancestor) const;
+
+  /** Resolve the static/relative/absolute offsets of an already laid-out box. */
+  void applyPosition(LayoutBox *box) const;
+
   void flattenInline(LayoutBox *box, float contentWidth, std::vector<InlineItem> &out) const;
 
   void computeInlineGeometry(LayoutBox *box) const;

package/runtime/ext_gui/layout_inline.cpp

@@ -48,6 +48,7 @@ void Layouter::flattenInline(LayoutBox *box, float contentWidth,
   if (box->display == Display::InlineBlock) {
     float available = contentWidth;
     float intrinsic = preferredContentWidth(box, available);
+    setContainingBlock(box, containingBlockAncestor(box));
     layoutBlock(box, 0, 0, available, -1, intrinsic);
     InlineItem item;
     item.box = box;
@@ -163,9 +164,16 @@ float Layouter::layoutInlineRun(LayoutBox *container, const std::vector<LayoutBo
     }
     for (InlineItem *item : current) {
       if (item->atomic) {
-        float dx = x + item->box->margin_left - item->box->x;
-        float dy = cursorY + item->box->margin_top - item->box->y;
-        translate(item->box, dx, dy);
+        /* An out-of-flow item was already placed against its containing block by
+         * `layoutBlock`, so it must not be moved back onto the line. */
+        if (!isAbsoluteChild(item->box)) {
+          float dx = x + item->box->margin_left - item->box->x;
+          float dy = cursorY + item->box->margin_top - item->box->y;
+          translate(item->box, dx, dy);
+          /* `position: relative` on an inline-block shifts it after line
+           * placement, so the line box keeps the space it reserved. */
+          applyPosition(item->box);
+        }
       } else {
         item->box->fragments.push_back({x, cursorY, item->width, height, item->text});
       }

package/runtime/ext_gui/paint.cpp

@@ -67,6 +67,12 @@ void paintBox(const LayoutBox *box, DisplayList &out) {
   if (box == nullptr) return;
   const XtStyle *style = box->style;
 
+  /* A fully transparent box paints nothing — not itself, and not its subtree.
+   * `opacity` is otherwise unsupported: a shape carries its colour's alpha only,
+   * so a partly transparent box (an `opacity` transition mid-flight, say) is
+   * still painted opaque. */
+  if (style != nullptr && style->opacity <= 0.0f) return;
+
   if (style != nullptr && box->display != Display::None) {
     if (box->is_text) {
       addTextRuns(box, *style, out);

package/runtime/ext_gui/renderer.cpp

@@ -130,30 +130,32 @@ bool xt_gui_renderer_ensure(SDL_GPUDevice *device, SDL_Window *reference) {
   using namespace xtgui::renderer_detail;
   if (g_pipeline != nullptr) return true;
   if (g_renderer_failed) return false;
-  if ((SDL_GetGPUShaderFormats(device) & SDL_GPU_SHADERFORMAT_MSL) == 0) {
+  const ShaderSource fill_vs = selectShader(device, ShaderProgram::Fill, false);
+  const ShaderSource fill_fs = selectShader(device, ShaderProgram::Fill, true);
+  if (!fill_vs.valid() || !fill_fs.valid()) {
     fprintf(stderr,
-            "xt_gui: backend has no MSL shader support; shape/text painting disabled "
-            "(Vulkan/D3D12 shader blobs are a TODO)\n");
+            "xt_gui: backend supports neither Metal nor D3D12 shaders; shape/text painting "
+            "disabled (Vulkan SPIR-V blobs are a TODO)\n");
     g_renderer_failed = 1;
     return false;
   }
 
   SDL_GPUShaderCreateInfo vs_info;
   memset(&vs_info, 0, sizeof(vs_info));
-  vs_info.code_size = strlen(kFillMSL);
-  vs_info.code = (const Uint8 *)kFillMSL;
-  vs_info.entrypoint = "vs_main";
-  vs_info.format = SDL_GPU_SHADERFORMAT_MSL;
+  vs_info.code_size = fill_vs.size;
+  vs_info.code = fill_vs.code;
+  vs_info.entrypoint = fill_vs.entry;
+  vs_info.format = fill_vs.format;
   vs_info.stage = SDL_GPU_SHADERSTAGE_VERTEX;
   vs_info.num_uniform_buffers = 1;
   SDL_GPUShader *vs = SDL_CreateGPUShader(device, &vs_info);
 
   SDL_GPUShaderCreateInfo fs_info;
   memset(&fs_info, 0, sizeof(fs_info));
-  fs_info.code_size = strlen(kFillMSL);
-  fs_info.code = (const Uint8 *)kFillMSL;
-  fs_info.entrypoint = "fs_main";
-  fs_info.format = SDL_GPU_SHADERFORMAT_MSL;
+  fs_info.code_size = fill_fs.size;
+  fs_info.code = fill_fs.code;
+  fs_info.entrypoint = fill_fs.entry;
+  fs_info.format = fill_fs.format;
   fs_info.stage = SDL_GPU_SHADERSTAGE_FRAGMENT;
   SDL_GPUShader *fs = SDL_CreateGPUShader(device, &fs_info);
 

package/runtime/ext_gui/renderer_image.cpp

@@ -17,22 +17,26 @@ namespace xtgui {
 namespace renderer_detail {
 
 SDL_GPUGraphicsPipeline *createImagePipeline(SDL_GPUDevice *device, SDL_Window *reference) {
+  const ShaderSource image_vs = selectShader(device, ShaderProgram::Image, false);
+  const ShaderSource image_fs = selectShader(device, ShaderProgram::Image, true);
+  if (!image_vs.valid() || !image_fs.valid()) return nullptr;
+
   SDL_GPUShaderCreateInfo vs_info;
   memset(&vs_info, 0, sizeof(vs_info));
-  vs_info.code_size = strlen(kTextMSL);
-  vs_info.code = (const Uint8 *)kTextMSL;
-  vs_info.entrypoint = "vs_text";
-  vs_info.format = SDL_GPU_SHADERFORMAT_MSL;
+  vs_info.code_size = image_vs.size;
+  vs_info.code = image_vs.code;
+  vs_info.entrypoint = image_vs.entry;
+  vs_info.format = image_vs.format;
   vs_info.stage = SDL_GPU_SHADERSTAGE_VERTEX;
   vs_info.num_uniform_buffers = 1;
   SDL_GPUShader *vs = SDL_CreateGPUShader(device, &vs_info);
 
   SDL_GPUShaderCreateInfo fs_info;
   memset(&fs_info, 0, sizeof(fs_info));
-  fs_info.code_size = strlen(kTextMSL);
-  fs_info.code = (const Uint8 *)kTextMSL;
-  fs_info.entrypoint = "fs_image";
-  fs_info.format = SDL_GPU_SHADERFORMAT_MSL;
+  fs_info.code_size = image_fs.size;
+  fs_info.code = image_fs.code;
+  fs_info.entrypoint = image_fs.entry;
+  fs_info.format = image_fs.format;
   fs_info.stage = SDL_GPU_SHADERSTAGE_FRAGMENT;
   fs_info.num_samplers = 1;
   SDL_GPUShader *fs = SDL_CreateGPUShader(device, &fs_info);

package/runtime/ext_gui/renderer_shaders.h

@@ -1,13 +1,39 @@
 /*
- * xbintsc GUI engine — SDL_GPU Metal (MSL) shader sources.
+ * xbintsc GUI engine — shader sources.
  *
- * Shared by `renderer.cpp` (fills), `renderer_text.cpp` (glyphs) and
- * `renderer_image.cpp` (images). Text and image quads reuse `kTextMSL`; only
- * the fragment entry point differs (`fs_text` vs `fs_image`).
+ * `renderer.cpp` (fills), `renderer_text.cpp` (glyphs) and `renderer_image.cpp`
+ * (images) each build one SDL_GPU graphics pipeline. Three shader families back
+ * them, one per SDL_GPU backend:
+ *
+ *   - Metal: the MSL string literals below, which SDL_GPU compiles at runtime.
+ *   - Vulkan: SPIR-V blobs in `renderer_shaders_data.h`, compiled from
+ *     `spirv/*.{vert,frag}` by `scripts/build-gui-shaders.mjs`.
+ *   - Direct3D 12: DXIL blobs from the same header, compiled from `shaders.hlsl`.
+ *
+ * `selectShader` resolves a logical program and stage to whichever of those the
+ * device accepts. The backend rejects any other format, so a missing blob means
+ * "no pipeline", never a mismatched one.
+ *
+ * Text and image quads share the vertex program; only the fragment entry point
+ * differs (`fs_text` vs `fs_image`).
+ *
+ * Note the entry-point names differ per format: MSL/DXIL keep the descriptive
+ * names from their sources, while glslc emits the GLSL `main`.
  */
 #ifndef XT_GUI_RENDERER_SHADERS_H
 #define XT_GUI_RENDERER_SHADERS_H
 
+#include <SDL3/SDL.h>
+#include <cstring>
+
+#include "renderer_shaders_data.h"
+
+namespace xtgui {
+namespace renderer_detail {
+
+/** The three pipeline programs the engine builds. */
+enum class ShaderProgram { Fill, Text, Image };
+
 /* Rounded-rectangle fill. Vertex attributes (matching SDL_GPUVertexAttribute):
  *   0 -> position (pixels, viewport-relative)
  *   1 -> local   (pixels, relative to the rectangle centre)
@@ -105,4 +131,105 @@ fragment float4 fs_image(TextOut in [[stage_in]],
 }
 )MSL";
 
+/** One stage of one pipeline program, in whichever format the device accepts. */
+struct ShaderSource {
+  SDL_GPUShaderFormat format = 0;
+  const unsigned char *code = nullptr;
+  size_t size = 0;
+  const char *entry = nullptr;
+
+  bool valid() const { return code != nullptr; }
+};
+
+/** The MSL text backing `program` (one literal covers both stages). */
+inline const char *mslSource(ShaderProgram program) {
+  return program == ShaderProgram::Fill ? kFillMSL : kTextMSL;
+}
+
+/** MSL entry point names for `program`, matching the literals below. */
+inline const char *vertexEntry(ShaderProgram program) {
+  return program == ShaderProgram::Fill ? "vs_main" : "vs_text";
+}
+
+inline const char *fragmentEntry(ShaderProgram program) {
+  if (program == ShaderProgram::Fill) return "fs_main";
+  return program == ShaderProgram::Text ? "fs_text" : "fs_image";
+}
+
+/** A blob pair for one shader format: bytes plus the entry-point names it uses.
+ * The names are stored in `ShaderSource` rather than resolved at the call site
+ * because cross-compilers rename entry points (glslc emits `main`, dxc keeps the
+ * HLSL name, MSL keeps the Metal name). */
+struct ShaderBlobs {
+  const unsigned char *vertex;
+  size_t vertex_size;
+  const char *vertex_entry;
+  const unsigned char *fragment;
+  size_t fragment_size;
+  const char *fragment_entry;
+};
+
+/** SPIR-V blobs for `program` (Vulkan). glslc names every entry point `main`. */
+inline ShaderBlobs spirvBlobs(ShaderProgram program) {
+  switch (program) {
+    case ShaderProgram::Fill:
+      return {kFillSpirvVs, kFillSpirvVsSize, "main", kFillSpirvFs, kFillSpirvFsSize, "main"};
+    case ShaderProgram::Text:
+      return {kTextSpirvVs, kTextSpirvVsSize, "main", kTextSpirvFs, kTextSpirvFsSize, "main"};
+    case ShaderProgram::Image:
+      return {kTextSpirvVs, kTextSpirvVsSize, "main", kImageSpirvFs, kImageSpirvFsSize, "main"};
+  }
+  return {nullptr, 0, nullptr, nullptr, 0, nullptr};
+}
+
+/** DXIL blobs for `program` (Direct3D 12); one blob per entry point. */
+inline ShaderBlobs dxilBlobs(ShaderProgram program) {
+  switch (program) {
+    case ShaderProgram::Fill:
+      return {kFillDxilVs, kFillDxilVsSize, "vs_main", kFillDxilFs, kFillDxilFsSize, "fs_main"};
+    case ShaderProgram::Text:
+      return {kTextDxilVs, kTextDxilVsSize, "vs_text", kTextDxilFs, kTextDxilFsSize, "fs_text"};
+    case ShaderProgram::Image:
+      return {kTextDxilVs, kTextDxilVsSize, "vs_text", kImageDxilFs, kImageDxilFsSize, "fs_image"};
+  }
+  return {nullptr, 0, nullptr, nullptr, 0, nullptr};
+}
+
+/** MSL for `program`: a single source holds both stages, so it is expressed as a
+ * blob pair sharing one buffer. */
+inline ShaderBlobs mslBlobs(ShaderProgram program) {
+  const char *msl = mslSource(program);
+  const size_t size = strlen(msl);
+  const unsigned char *code = (const unsigned char *)msl;
+  return {code, size, vertexEntry(program), code, size, fragmentEntry(program)};
+}
+
+/** Resolve `program`'s vertex and fragment stages to shaders the device accepts.
+ * Returns an invalid source when the backend supports none of the formats the
+ * engine ships. */
+inline ShaderSource selectShader(SDL_GPUDevice *device, ShaderProgram program, bool fragment) {
+  ShaderSource source;
+  const SDL_GPUShaderFormat formats = SDL_GetGPUShaderFormats(device);
+  ShaderBlobs blobs;
+  if ((formats & SDL_GPU_SHADERFORMAT_MSL) != 0) {
+    source.format = SDL_GPU_SHADERFORMAT_MSL;
+    blobs = mslBlobs(program);
+  } else if ((formats & SDL_GPU_SHADERFORMAT_SPIRV) != 0) {
+    source.format = SDL_GPU_SHADERFORMAT_SPIRV;
+    blobs = spirvBlobs(program);
+  } else if ((formats & SDL_GPU_SHADERFORMAT_DXIL) != 0) {
+    source.format = SDL_GPU_SHADERFORMAT_DXIL;
+    blobs = dxilBlobs(program);
+  } else {
+    return source;
+  }
+  source.code = fragment ? blobs.fragment : blobs.vertex;
+  source.size = fragment ? blobs.fragment_size : blobs.vertex_size;
+  source.entry = fragment ? blobs.fragment_entry : blobs.vertex_entry;
+  return source;
+}
+
+}  // namespace renderer_detail
+}  // namespace xtgui
+
 #endif /* XT_GUI_RENDERER_SHADERS_H */