xbintsc 0.3.25 → 0.3.46

package/runtime/ext_gui/renderer_image.cpp

@@ -0,0 +1,233 @@
+/*
+ * xbintsc GUI engine — SDL_GPU 2D renderer: image textures and geometry.
+ */
+
+#include "renderer_internal.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+
+#include "image.h"
+
+#include "renderer_shaders.h"
+
+namespace xtgui {
+namespace renderer_detail {
+
+SDL_GPUGraphicsPipeline *createImagePipeline(SDL_GPUDevice *device, SDL_Window *reference) {
+  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.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.stage = SDL_GPU_SHADERSTAGE_FRAGMENT;
+  fs_info.num_samplers = 1;
+  SDL_GPUShader *fs = SDL_CreateGPUShader(device, &fs_info);
+
+  if (vs == nullptr || fs == nullptr) {
+    fprintf(stderr, "xt_gui: image shader creation failed: %s\n", SDL_GetError());
+    if (vs != nullptr) SDL_ReleaseGPUShader(device, vs);
+    if (fs != nullptr) SDL_ReleaseGPUShader(device, fs);
+    return nullptr;
+  }
+
+  SDL_GPUVertexBufferDescription vb_desc;
+  memset(&vb_desc, 0, sizeof(vb_desc));
+  vb_desc.slot = 0;
+  vb_desc.pitch = sizeof(TextVertex);
+  vb_desc.input_rate = SDL_GPU_VERTEXINPUTRATE_VERTEX;
+
+  SDL_GPUVertexAttribute attrs[3];
+  memset(attrs, 0, sizeof(attrs));
+  attrs[0] = {0, 0, SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2, (Uint32)offsetof(TextVertex, x)};
+  attrs[1] = {1, 0, SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2, (Uint32)offsetof(TextVertex, u)};
+  attrs[2] = {2, 0, SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, (Uint32)offsetof(TextVertex, r)};
+
+  SDL_GPUColorTargetDescription color_target;
+  memset(&color_target, 0, sizeof(color_target));
+  color_target.format = SDL_GetGPUSwapchainTextureFormat(device, reference);
+  color_target.blend_state.enable_blend = true;
+  color_target.blend_state.src_color_blendfactor = SDL_GPU_BLENDFACTOR_SRC_ALPHA;
+  color_target.blend_state.dst_color_blendfactor = SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
+  color_target.blend_state.color_blend_op = SDL_GPU_BLENDOP_ADD;
+  color_target.blend_state.src_alpha_blendfactor = SDL_GPU_BLENDFACTOR_ONE;
+  color_target.blend_state.dst_alpha_blendfactor = SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
+  color_target.blend_state.alpha_blend_op = SDL_GPU_BLENDOP_ADD;
+
+  SDL_GPUGraphicsPipelineCreateInfo info;
+  memset(&info, 0, sizeof(info));
+  info.vertex_shader = vs;
+  info.fragment_shader = fs;
+  info.vertex_input_state.vertex_buffer_descriptions = &vb_desc;
+  info.vertex_input_state.num_vertex_buffers = 1;
+  info.vertex_input_state.vertex_attributes = attrs;
+  info.vertex_input_state.num_vertex_attributes = 3;
+  info.primitive_type = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST;
+  info.rasterizer_state.fill_mode = SDL_GPU_FILLMODE_FILL;
+  info.rasterizer_state.cull_mode = SDL_GPU_CULLMODE_NONE;
+  info.rasterizer_state.front_face = SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE;
+  info.multisample_state.sample_count = SDL_GPU_SAMPLECOUNT_1;
+  info.target_info.color_target_descriptions = &color_target;
+  info.target_info.num_color_targets = 1;
+
+  SDL_GPUGraphicsPipeline *pipeline = SDL_CreateGPUGraphicsPipeline(device, &info);
+  SDL_ReleaseGPUShader(device, vs);
+  SDL_ReleaseGPUShader(device, fs);
+  if (pipeline == nullptr) {
+    fprintf(stderr, "xt_gui: image pipeline creation failed: %s\n", SDL_GetError());
+  }
+  return pipeline;
+}
+
+/** Decode `src` (cached) and upload it as an RGBA texture (cached by path). */
+SDL_GPUTexture *ensureImageTexture(SDL_GPUDevice *device, const std::string &src) {
+  auto found = g_image_textures.find(src);
+  if (found != g_image_textures.end()) return found->second;
+
+  const xtgui::Image *image = xtgui::xt_image_load(src);
+  if (image == nullptr || image->width <= 0 || image->height <= 0) {
+    fprintf(stderr, "xt_gui: could not decode image '%s'\n", src.c_str());
+    g_image_textures.emplace(src, nullptr);
+    return nullptr;
+  }
+
+  SDL_GPUTextureCreateInfo info;
+  memset(&info, 0, sizeof(info));
+  info.type = SDL_GPU_TEXTURETYPE_2D;
+  info.format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
+  info.usage = SDL_GPU_TEXTUREUSAGE_SAMPLER;
+  info.width = (Uint32)image->width;
+  info.height = (Uint32)image->height;
+  info.layer_count_or_depth = 1;
+  info.num_levels = 1;
+  info.sample_count = SDL_GPU_SAMPLECOUNT_1;
+  SDL_GPUTexture *texture = SDL_CreateGPUTexture(device, &info);
+  if (texture == nullptr) {
+    fprintf(stderr, "xt_gui: image texture creation failed: %s\n", SDL_GetError());
+    g_image_textures.emplace(src, nullptr);
+    return nullptr;
+  }
+
+  uint32_t bytes = (uint32_t)(image->pixels.size());
+  SDL_GPUTransferBufferCreateInfo transfer_info;
+  memset(&transfer_info, 0, sizeof(transfer_info));
+  transfer_info.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
+  transfer_info.size = bytes;
+  SDL_GPUTransferBuffer *transfer = SDL_CreateGPUTransferBuffer(device, &transfer_info);
+  if (transfer == nullptr) {
+    SDL_ReleaseGPUTexture(device, texture);
+    g_image_textures.emplace(src, nullptr);
+    return nullptr;
+  }
+  void *mapped = SDL_MapGPUTransferBuffer(device, transfer, false);
+  std::memcpy(mapped, image->pixels.data(), bytes);
+  SDL_UnmapGPUTransferBuffer(device, transfer);
+
+  SDL_GPUCommandBuffer *cmd = SDL_AcquireGPUCommandBuffer(device);
+  if (cmd == nullptr) {
+    SDL_ReleaseGPUTransferBuffer(device, transfer);
+    SDL_ReleaseGPUTexture(device, texture);
+    g_image_textures.emplace(src, nullptr);
+    return nullptr;
+  }
+  SDL_GPUTextureTransferInfo source;
+  memset(&source, 0, sizeof(source));
+  source.transfer_buffer = transfer;
+  source.offset = 0;
+  source.pixels_per_row = (Uint32)image->width;
+  source.rows_per_layer = (Uint32)image->height;
+  SDL_GPUTextureRegion destination;
+  memset(&destination, 0, sizeof(destination));
+  destination.texture = texture;
+  destination.mip_level = 0;
+  destination.layer = 0;
+  destination.x = 0;
+  destination.y = 0;
+  destination.z = 0;
+  destination.w = (Uint32)image->width;
+  destination.h = (Uint32)image->height;
+  destination.d = 1;
+  SDL_GPUCopyPass *copy = SDL_BeginGPUCopyPass(cmd);
+  SDL_UploadToGPUTexture(copy, &source, &destination, false);
+  SDL_EndGPUCopyPass(copy);
+  SDL_SubmitGPUCommandBuffer(cmd);
+  SDL_ReleaseGPUTransferBuffer(device, transfer);
+
+  g_image_textures.emplace(src, texture);
+  return texture;
+}
+
+}  // namespace renderer_detail
+}  // namespace xtgui
+
+void xt_gui_image_upload(SDL_GPUDevice *device, XtGuiGeometry *geometry,
+                         const xtgui::DisplayList &list) {
+  using namespace xtgui::renderer_detail;
+  g_image_batches.clear();
+  if (g_image_pipeline == nullptr) {
+    geometry->vertex_count = 0;
+    return;
+  }
+  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 (const xtgui::PaintImage &image : list.images) {
+    if (image.width <= 0.0f || image.height <= 0.0f) continue;
+    SDL_GPUTexture *texture = ensureImageTexture(device, image.src);
+    if (texture == nullptr) continue;
+    uint32_t first = (uint32_t)verts.size();
+    pushGlyph(verts, image.x, image.y, image.width, image.height, full, white);
+    g_image_batches.push_back(ImageBatch{texture, first, 6});
+  }
+  uploadVertices(device, geometry, verts.data(), (uint32_t)verts.size(), sizeof(TextVertex));
+}
+
+void xt_gui_image_draw(SDL_GPUCommandBuffer *cmd, SDL_GPURenderPass *pass, XtGuiGeometry *geometry,
+                       float viewport_width, float viewport_height) {
+  using namespace xtgui::renderer_detail;
+  if (g_image_pipeline == nullptr || g_sampler == nullptr) return;
+  if (geometry->buffer == nullptr || geometry->vertex_count == 0 || g_image_batches.empty()) return;
+  if (viewport_width <= 0.0f || viewport_height <= 0.0f) return;
+  SDL_BindGPUGraphicsPipeline(pass, g_image_pipeline);
+  SDL_GPUBufferBinding binding;
+  binding.buffer = geometry->buffer;
+  binding.offset = 0;
+  SDL_BindGPUVertexBuffers(pass, 0, &binding, 1);
+  float viewport[2] = {viewport_width, viewport_height};
+  SDL_PushGPUVertexUniformData(cmd, 0, viewport, sizeof(viewport));
+  for (const ImageBatch &batch : g_image_batches) {
+    if (batch.texture == nullptr) continue;
+    SDL_GPUTextureSamplerBinding texture_binding;
+    texture_binding.texture = batch.texture;
+    texture_binding.sampler = g_sampler;
+    SDL_BindGPUFragmentSamplers(pass, 0, &texture_binding, 1);
+    SDL_DrawGPUPrimitives(pass, batch.count, 1, batch.first, 0);
+  }
+}
+
+void xt_gui_image_textures_destroy(SDL_GPUDevice *device) {
+  using namespace xtgui::renderer_detail;
+  for (auto &entry : g_image_textures) {
+    if (entry.second != nullptr) SDL_ReleaseGPUTexture(device, entry.second);
+  }
+  g_image_textures.clear();
+  g_image_batches.clear();
+}

package/runtime/ext_gui/renderer_internal.h

@@ -0,0 +1,112 @@
+/*
+ * xbintsc GUI engine — shared declarations for the renderer translation units
+ * (`renderer.cpp`, `renderer_text.cpp`, `renderer_image.cpp`).
+ *
+ * The GPU state lives in `xtgui::renderer_detail` with external linkage so the
+ * three translation units can share it (it used to be an anonymous namespace).
+ */
+#ifndef XT_GUI_RENDERER_INTERNAL_H
+#define XT_GUI_RENDERER_INTERNAL_H
+
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "paint.h"
+#include "renderer.h"
+
+namespace xtgui {
+namespace renderer_detail {
+
+struct Vertex {
+  float x, y;
+  float lx, ly;
+  float hx, hy;
+  float radius;
+  float r, g, b, a;
+};
+
+struct TextVertex {
+  float x, y;
+  float u, v;
+  float r, g, b, a;
+};
+
+/* Image quads are batched by texture; textures are cached by source path. */
+struct ImageBatch {
+  SDL_GPUTexture *texture = nullptr;
+  uint32_t first = 0;
+  uint32_t count = 0;
+};
+
+extern SDL_GPUGraphicsPipeline *g_pipeline;
+extern SDL_GPUGraphicsPipeline *g_text_pipeline;
+extern SDL_GPUGraphicsPipeline *g_image_pipeline;
+extern SDL_GPUSampler *g_sampler;
+extern int g_renderer_failed;
+extern bool g_text_ok;
+extern std::vector<ImageBatch> g_image_batches;
+extern std::unordered_map<std::string, SDL_GPUTexture *> g_image_textures;
+
+/* -- glyph atlas ---------------------------------------------------------- */
+
+constexpr int kAtlasSize = 2048;
+
+struct GlyphEntry {
+  float u0 = 0, v0 = 0, u1 = 0, v1 = 0;
+  int width = 0, height = 0, left = 0, top = 0;
+};
+
+struct GlyphKey {
+  const void *font = nullptr;
+  uint32_t glyph = 0;
+  bool operator==(const GlyphKey &other) const {
+    return font == other.font && glyph == other.glyph;
+  }
+};
+
+struct GlyphKeyHash {
+  size_t operator()(const GlyphKey &key) const {
+    return std::hash<const void *>()(key.font) * 1099511628211ull ^
+           (size_t)(key.glyph * 2654435761u);
+  }
+};
+
+extern SDL_GPUTexture *g_atlas_texture;
+extern std::vector<unsigned char> g_atlas_mirror;
+extern std::unordered_map<GlyphKey, GlyphEntry, GlyphKeyHash> g_glyphs;
+extern int g_atlas_x;
+extern int g_atlas_y;
+extern int g_atlas_row_height;
+extern bool g_atlas_dirty;
+extern int g_atlas_dirty_x0, g_atlas_dirty_y0, g_atlas_dirty_x1, g_atlas_dirty_y1;
+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);
+void uploadVertices(SDL_GPUDevice *device, XtGuiGeometry *geometry, const void *data,
+                    uint32_t count, uint32_t stride);
+
+/* -- text ----------------------------------------------------------------- */
+
+bool ensureAtlasTexture(SDL_GPUDevice *device);
+void markAtlasDirty(int x, int y, int width, int height);
+bool ensureGlyph(SDL_GPUDevice *device, xtgui::Font *font, uint32_t glyph, GlyphEntry &out);
+void flushAtlas(SDL_GPUDevice *device);
+SDL_GPUGraphicsPipeline *createTextPipeline(SDL_GPUDevice *device, SDL_Window *reference);
+SDL_GPUSampler *createSampler(SDL_GPUDevice *device);
+
+/* -- images --------------------------------------------------------------- */
+
+SDL_GPUGraphicsPipeline *createImagePipeline(SDL_GPUDevice *device, SDL_Window *reference);
+SDL_GPUTexture *ensureImageTexture(SDL_GPUDevice *device, const std::string &src);
+
+}  // namespace renderer_detail
+}  // namespace xtgui
+
+#endif /* XT_GUI_RENDERER_INTERNAL_H */

package/runtime/ext_gui/renderer_shaders.h

@@ -0,0 +1,108 @@
+/*
+ * xbintsc GUI engine — SDL_GPU Metal (MSL) 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`).
+ */
+#ifndef XT_GUI_RENDERER_SHADERS_H
+#define XT_GUI_RENDERER_SHADERS_H
+
+/* Rounded-rectangle fill. Vertex attributes (matching SDL_GPUVertexAttribute):
+ *   0 -> position (pixels, viewport-relative)
+ *   1 -> local   (pixels, relative to the rectangle centre)
+ *   2 -> half    (rectangle half extents, pixels)
+ *   3 -> radius  (pixels)
+ *   4 -> colour
+ * The push constant is the viewport size in logical pixels. */
+inline constexpr const char *kFillMSL = R"MSL(
+#include <metal_stdlib>
+using namespace metal;
+
+struct FillIn {
+    float2 position [[attribute(0)]];
+    float2 local    [[attribute(1)]];
+    float2 halfsize [[attribute(2)]];
+    float  radius   [[attribute(3)]];
+    float4 color    [[attribute(4)]];
+};
+
+struct FillOut {
+    float4 position [[position]];
+    float2 local;
+    float2 halfsize;
+    float  radius;
+    float4 color;
+};
+
+vertex FillOut vs_main(FillIn in [[stage_in]],
+                       constant float2 &viewport [[buffer(0)]]) {
+    FillOut out;
+    float2 ndc = float2(in.position.x / viewport.x * 2.0 - 1.0,
+                        1.0 - in.position.y / viewport.y * 2.0);
+    out.position = float4(ndc, 0.0, 1.0);
+    out.local = in.local;
+    out.halfsize = in.halfsize;
+    out.radius = in.radius;
+    out.color = in.color;
+    return out;
+}
+
+fragment float4 fs_main(FillOut in [[stage_in]]) {
+    float2 d = abs(in.local) - in.halfsize + in.radius;
+    float dist = min(max(d.x, d.y), 0.0) + length(max(d, 0.0)) - in.radius;
+    float aa = max(fwidth(dist), 0.0001);
+    float alpha = clamp(0.5 - dist / aa, 0.0, 1.0);
+    return float4(in.color.rgb, in.color.a * alpha);
+}
+)MSL";
+
+/* Glyph quads. Attributes:
+ *   0 -> position (pixels, viewport-relative)
+ *   1 -> uv (atlas coordinates in [0,1])
+ *   2 -> colour
+ * The fragment shader samples the single-channel atlas and modulates alpha. */
+inline constexpr const char *kTextMSL = R"MSL(
+#include <metal_stdlib>
+using namespace metal;
+
+struct TextIn {
+    float2 position [[attribute(0)]];
+    float2 uv       [[attribute(1)]];
+    float4 color    [[attribute(2)]];
+};
+
+struct TextOut {
+    float4 position [[position]];
+    float2 uv;
+    float4 color;
+};
+
+vertex TextOut vs_text(TextIn in [[stage_in]],
+                       constant float2 &viewport [[buffer(0)]]) {
+    TextOut out;
+    float2 ndc = float2(in.position.x / viewport.x * 2.0 - 1.0,
+                        1.0 - in.position.y / viewport.y * 2.0);
+    out.position = float4(ndc, 0.0, 1.0);
+    out.uv = in.uv;
+    out.color = in.color;
+    return out;
+}
+
+fragment float4 fs_text(TextOut in [[stage_in]],
+                        texture2d<float> atlas [[texture(0)]],
+                        sampler samp [[sampler(0)]]) {
+    float coverage = atlas.sample(samp, in.uv).r;
+    return float4(in.color.rgb, in.color.a * coverage);
+}
+
+/* Image quads reuse the text vertex layout but sample an RGBA texture. */
+fragment float4 fs_image(TextOut in [[stage_in]],
+                         texture2d<float> tex [[texture(0)]],
+                         sampler samp [[sampler(0)]]) {
+    float4 c = tex.sample(samp, in.uv);
+    return float4(c.rgb * in.color.rgb, c.a * in.color.a);
+}
+)MSL";
+
+#endif /* XT_GUI_RENDERER_SHADERS_H */