UI rewrite 3rd attempt
This commit is contained in:
parent
c9fd1b1585
commit
1f5697326c
48 changed files with 2155 additions and 6190 deletions
393
implementations/Crafter.Graphics-UI.cpp
Normal file
393
implementations/Crafter.Graphics-UI.cpp
Normal file
|
|
@ -0,0 +1,393 @@
|
|||
/*
|
||||
Crafter®.Graphics
|
||||
Copyright (C) 2026 Catcrafts®
|
||||
catcrafts.net
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License version 3.0 as published by the Free Software Foundation;
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
*/
|
||||
module;
|
||||
#include "vulkan/vulkan.h"
|
||||
module Crafter.Graphics:UI_impl;
|
||||
import :UI;
|
||||
import :ComputeShader;
|
||||
import :Device;
|
||||
import :Window;
|
||||
import :DescriptorHeapVulkan;
|
||||
import :ImageVulkan;
|
||||
import :VulkanBuffer;
|
||||
import :FontAtlas;
|
||||
import :Font;
|
||||
import std;
|
||||
|
||||
using namespace Crafter;
|
||||
|
||||
// ─── Initialize ─────────────────────────────────────────────────────────
|
||||
|
||||
void UIRenderer::Initialize(Window& window, DescriptorHeapVulkan& heap, VkCommandBuffer initCmd,
|
||||
std::filesystem::path quadsSpv,
|
||||
std::filesystem::path circlesSpv,
|
||||
std::filesystem::path imagesSpv,
|
||||
std::filesystem::path textSpv) {
|
||||
window_ = &window;
|
||||
heap_ = &heap;
|
||||
|
||||
// Load the four standard pipelines.
|
||||
drawQuads.Load(quadsSpv);
|
||||
drawCircles.Load(circlesSpv);
|
||||
drawImages.Load(imagesSpv);
|
||||
drawText.Load(textSpv);
|
||||
|
||||
// Allocate one image slot for the swapchain output. Each per-frame heap
|
||||
// copy will hold ITS frame's image at this slot.
|
||||
auto outRange = heap_->AllocateImageSlots(1);
|
||||
outImageSlot_ = outRange.firstElement;
|
||||
|
||||
WriteSwapchainDescriptors();
|
||||
|
||||
// Optional font-atlas registration (user must have called atlas->Initialize
|
||||
// already before reaching here, so atlas->image is live).
|
||||
if (fontAtlas != nullptr) {
|
||||
auto atlasImg = heap_->AllocateImageSlots(1);
|
||||
fontAtlasImageSlot_ = atlasImg.firstElement;
|
||||
fontAtlasSamplerSlot_ = RegisterLinearClampSampler();
|
||||
WriteFontAtlasDescriptor();
|
||||
}
|
||||
|
||||
// Flush the host-mapped descriptor heaps so the GPU sees what we wrote.
|
||||
for (auto& h : heap_->resourceHeap) h.FlushDevice();
|
||||
for (auto& h : heap_->samplerHeap) h.FlushDevice();
|
||||
|
||||
(void)initCmd; // reserved for future image-layout tweaks
|
||||
}
|
||||
|
||||
// ─── per-frame Record ───────────────────────────────────────────────────
|
||||
|
||||
void UIRenderer::Record(VkCommandBuffer cmd, std::uint32_t frameIdx, Window& window) {
|
||||
// Reset per-frame state.
|
||||
firstDispatchThisFrame_ = true;
|
||||
|
||||
// If text is in use, flush any glyphs that user-side ShapeText calls
|
||||
// produced during a previous frame's onBuild. (Ensure() during the
|
||||
// current onBuild also marks the atlas dirty; that's flushed on the
|
||||
// NEXT Record. For v1 this is fine because the current frame's text
|
||||
// dispatch reads whatever's already been uploaded, and brand-new glyphs
|
||||
// missing from the atlas this frame will simply render blank for one
|
||||
// frame and resolve next frame. To get them this frame, the user can
|
||||
// call atlas->Update(cmd) themselves at the top of onBuild.)
|
||||
if (fontAtlas != nullptr && fontAtlas->dirty) {
|
||||
fontAtlas->Update(cmd);
|
||||
}
|
||||
|
||||
onBuild.Invoke({cmd, frameIdx});
|
||||
|
||||
(void)window;
|
||||
}
|
||||
|
||||
// ─── header builder ─────────────────────────────────────────────────────
|
||||
|
||||
UIDispatchHeader UIRenderer::FillHeader(std::uint32_t itemBufferSlot,
|
||||
std::uint32_t itemCount,
|
||||
std::array<float,4> clipRectPx,
|
||||
std::uint32_t flags) const noexcept {
|
||||
UIDispatchHeader h{};
|
||||
h.outImage = outImageSlot_;
|
||||
h.itemBuffer = itemBufferSlot;
|
||||
h.surfaceWidth = window_->width;
|
||||
h.surfaceHeight = window_->height;
|
||||
h.clipX = clipRectPx[0];
|
||||
h.clipY = clipRectPx[1];
|
||||
h.clipW = clipRectPx[2];
|
||||
h.clipH = clipRectPx[3];
|
||||
h.itemCount = itemCount;
|
||||
h.frameIdx = window_->currentBuffer;
|
||||
h.flags = flags;
|
||||
h._pad = 0;
|
||||
return h;
|
||||
}
|
||||
|
||||
// ─── group-count helper ────────────────────────────────────────────────
|
||||
|
||||
namespace {
|
||||
// Number of 8-pixel tiles needed to cover `dim` pixels (rounded up).
|
||||
inline std::uint32_t TilesFor(std::uint32_t dim) {
|
||||
return (dim + 7u) / 8u;
|
||||
}
|
||||
}
|
||||
|
||||
// ─── standard-shader convenience dispatches ─────────────────────────────
|
||||
//
|
||||
// All four standard shaders use the same pixel-tile dispatch model: one
|
||||
// workgroup per 8×8 screen tile, each thread iterates every item in order
|
||||
// inside the workgroup, accumulating into a local register. This guarantees
|
||||
// "items in the buffer render in order" (later items overdraw earlier ones)
|
||||
// without inter-workgroup races on imageLoad/imageStore — the bug that the
|
||||
// per-item dispatch model had.
|
||||
|
||||
void UIRenderer::DispatchQuads(VkCommandBuffer cmd, std::uint32_t bufferSlot,
|
||||
std::uint32_t itemCount,
|
||||
std::array<float,4> clipRectPx) {
|
||||
if (itemCount == 0) return;
|
||||
struct PC { UIDispatchHeader hdr; } pc { FillHeader(bufferSlot, itemCount, clipRectPx) };
|
||||
Dispatch(cmd, drawQuads, &pc, sizeof(pc),
|
||||
TilesFor(window_->width), TilesFor(window_->height), 1u);
|
||||
}
|
||||
|
||||
void UIRenderer::DispatchCircles(VkCommandBuffer cmd, std::uint32_t bufferSlot,
|
||||
std::uint32_t itemCount,
|
||||
std::array<float,4> clipRectPx) {
|
||||
if (itemCount == 0) return;
|
||||
struct PC { UIDispatchHeader hdr; } pc { FillHeader(bufferSlot, itemCount, clipRectPx) };
|
||||
Dispatch(cmd, drawCircles, &pc, sizeof(pc),
|
||||
TilesFor(window_->width), TilesFor(window_->height), 1u);
|
||||
}
|
||||
|
||||
void UIRenderer::DispatchImages(VkCommandBuffer cmd, std::uint32_t bufferSlot,
|
||||
std::uint32_t itemCount,
|
||||
std::array<float,4> clipRectPx) {
|
||||
if (itemCount == 0) return;
|
||||
struct PC { UIDispatchHeader hdr; } pc { FillHeader(bufferSlot, itemCount, clipRectPx) };
|
||||
Dispatch(cmd, drawImages, &pc, sizeof(pc),
|
||||
TilesFor(window_->width), TilesFor(window_->height), 1u);
|
||||
}
|
||||
|
||||
void UIRenderer::DispatchText(VkCommandBuffer cmd, std::uint32_t bufferSlot,
|
||||
std::uint32_t itemCount,
|
||||
std::array<float,4> clipRectPx) {
|
||||
if (itemCount == 0) return;
|
||||
if (fontAtlasImageSlot_ == 0xFFFF) {
|
||||
throw std::runtime_error("UIRenderer::DispatchText: no FontAtlas registered (set fontAtlas before Initialize)");
|
||||
}
|
||||
// Flush any glyphs that ShapeText calls (during this onBuild) just
|
||||
// rasterised, so the dispatch below sees them.
|
||||
if (fontAtlas != nullptr && fontAtlas->dirty) {
|
||||
fontAtlas->Update(cmd);
|
||||
}
|
||||
struct PC {
|
||||
UIDispatchHeader hdr;
|
||||
std::uint32_t fontTextureSlot;
|
||||
std::uint32_t fontSamplerSlot;
|
||||
std::uint32_t _p0;
|
||||
std::uint32_t _p1;
|
||||
} pc {
|
||||
FillHeader(bufferSlot, itemCount, clipRectPx),
|
||||
fontAtlasImageSlot_,
|
||||
fontAtlasSamplerSlot_,
|
||||
0, 0
|
||||
};
|
||||
Dispatch(cmd, drawText, &pc, sizeof(pc),
|
||||
TilesFor(window_->width), TilesFor(window_->height), 1u);
|
||||
}
|
||||
|
||||
// ─── generic Dispatch (with barrier) ────────────────────────────────────
|
||||
|
||||
void UIRenderer::Dispatch(VkCommandBuffer cmd, const ComputeShader& shader,
|
||||
const void* push, std::uint32_t pushBytes,
|
||||
std::uint32_t gx, std::uint32_t gy, std::uint32_t gz) {
|
||||
if (!firstDispatchThisFrame_) {
|
||||
VkMemoryBarrier mb {
|
||||
.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
|
||||
.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
|
||||
.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
|
||||
};
|
||||
vkCmdPipelineBarrier(cmd,
|
||||
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
|
||||
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
|
||||
0, 1, &mb, 0, nullptr, 0, nullptr);
|
||||
}
|
||||
firstDispatchThisFrame_ = false;
|
||||
shader.Dispatch(cmd, push, pushBytes, gx, gy, gz);
|
||||
}
|
||||
|
||||
// ─── descriptor writes ─────────────────────────────────────────────────
|
||||
|
||||
void UIRenderer::WriteSwapchainDescriptors() {
|
||||
// Each per-frame heap holds ITS swapchain image at outImageSlot_.
|
||||
std::array<VkImageDescriptorInfoEXT, Window::numFrames> infos{};
|
||||
std::array<VkResourceDescriptorInfoEXT, Window::numFrames> resources{};
|
||||
std::array<VkHostAddressRangeEXT, Window::numFrames> destinations{};
|
||||
|
||||
for (std::uint32_t f = 0; f < Window::numFrames; ++f) {
|
||||
infos[f] = {
|
||||
.sType = VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT,
|
||||
.pView = &window_->imageViews[f],
|
||||
.layout = VK_IMAGE_LAYOUT_GENERAL,
|
||||
};
|
||||
resources[f] = {
|
||||
.sType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT,
|
||||
.type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
|
||||
.data = { .pImage = &infos[f] },
|
||||
};
|
||||
destinations[f] = {
|
||||
.address = heap_->resourceHeap[f].value
|
||||
+ heap_->ImageByteOffset(outImageSlot_),
|
||||
.size = Device::descriptorHeapProperties.imageDescriptorSize,
|
||||
};
|
||||
}
|
||||
Device::vkWriteResourceDescriptorsEXT(
|
||||
Device::device, Window::numFrames, resources.data(), destinations.data()
|
||||
);
|
||||
}
|
||||
|
||||
void UIRenderer::WriteFontAtlasDescriptor() {
|
||||
atlasViewCreateInfo_ = {
|
||||
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
|
||||
.image = fontAtlas->image.image,
|
||||
.viewType = VK_IMAGE_VIEW_TYPE_2D,
|
||||
.format = VK_FORMAT_R8_UNORM,
|
||||
.components = {
|
||||
VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
|
||||
VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
|
||||
},
|
||||
.subresourceRange = {
|
||||
.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
|
||||
.baseMipLevel = 0,
|
||||
.levelCount = 1,
|
||||
.baseArrayLayer = 0,
|
||||
.layerCount = 1,
|
||||
},
|
||||
};
|
||||
WriteSampledImageDescriptor(fontAtlasImageSlot_,
|
||||
atlasViewCreateInfo_,
|
||||
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
|
||||
}
|
||||
|
||||
void UIRenderer::WriteSampledImageDescriptor(std::uint16_t slot,
|
||||
const VkImageViewCreateInfo& viewInfo,
|
||||
VkImageLayout layout) {
|
||||
std::array<VkImageDescriptorInfoEXT, Window::numFrames> infos{};
|
||||
std::array<VkResourceDescriptorInfoEXT, Window::numFrames> resources{};
|
||||
std::array<VkHostAddressRangeEXT, Window::numFrames> destinations{};
|
||||
|
||||
for (std::uint32_t f = 0; f < Window::numFrames; ++f) {
|
||||
infos[f] = {
|
||||
.sType = VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT,
|
||||
.pView = &viewInfo,
|
||||
.layout = layout,
|
||||
};
|
||||
resources[f] = {
|
||||
.sType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT,
|
||||
.type = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
|
||||
.data = { .pImage = &infos[f] },
|
||||
};
|
||||
destinations[f] = {
|
||||
.address = heap_->resourceHeap[f].value + heap_->ImageByteOffset(slot),
|
||||
.size = Device::descriptorHeapProperties.imageDescriptorSize,
|
||||
};
|
||||
}
|
||||
Device::vkWriteResourceDescriptorsEXT(
|
||||
Device::device, Window::numFrames, resources.data(), destinations.data()
|
||||
);
|
||||
for (auto& h : heap_->resourceHeap) h.FlushDevice();
|
||||
}
|
||||
|
||||
void UIRenderer::WriteBufferDescriptor(std::uint16_t slot, VkDeviceAddress address, std::uint32_t size) {
|
||||
std::array<VkDeviceAddressRangeEXT, Window::numFrames> ranges{};
|
||||
std::array<VkResourceDescriptorInfoEXT, Window::numFrames> resources{};
|
||||
std::array<VkHostAddressRangeEXT, Window::numFrames> destinations{};
|
||||
|
||||
for (std::uint32_t f = 0; f < Window::numFrames; ++f) {
|
||||
ranges[f] = { .address = address, .size = size };
|
||||
resources[f] = {
|
||||
.sType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT,
|
||||
.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
|
||||
.data = { .pAddressRange = &ranges[f] },
|
||||
};
|
||||
destinations[f] = {
|
||||
.address = heap_->resourceHeap[f].value + heap_->BufferByteOffset(slot),
|
||||
.size = Device::descriptorHeapProperties.bufferDescriptorSize,
|
||||
};
|
||||
}
|
||||
Device::vkWriteResourceDescriptorsEXT(
|
||||
Device::device, Window::numFrames, resources.data(), destinations.data()
|
||||
);
|
||||
for (auto& h : heap_->resourceHeap) h.FlushDevice();
|
||||
}
|
||||
|
||||
std::uint16_t UIRenderer::RegisterSampler(const VkSamplerCreateInfo& info) {
|
||||
auto range = heap_->AllocateSamplerSlots(1);
|
||||
std::array<VkSamplerCreateInfo, Window::numFrames> infos{};
|
||||
std::array<VkHostAddressRangeEXT, Window::numFrames> destinations{};
|
||||
for (std::uint32_t f = 0; f < Window::numFrames; ++f) {
|
||||
infos[f] = info;
|
||||
destinations[f] = {
|
||||
.address = heap_->samplerHeap[f].value + heap_->SamplerByteOffset(range.firstElement),
|
||||
.size = Device::descriptorHeapProperties.samplerDescriptorSize,
|
||||
};
|
||||
}
|
||||
Device::vkWriteSamplerDescriptorsEXT(
|
||||
Device::device, Window::numFrames, infos.data(), destinations.data()
|
||||
);
|
||||
for (auto& h : heap_->samplerHeap) h.FlushDevice();
|
||||
return range.firstElement;
|
||||
}
|
||||
|
||||
std::uint16_t UIRenderer::RegisterLinearClampSampler() {
|
||||
VkSamplerCreateInfo s {
|
||||
.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
|
||||
.magFilter = VK_FILTER_LINEAR,
|
||||
.minFilter = VK_FILTER_LINEAR,
|
||||
.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR,
|
||||
.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
|
||||
.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
|
||||
.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
|
||||
.maxAnisotropy = 1.0f,
|
||||
.minLod = 0.0f,
|
||||
.maxLod = VK_LOD_CLAMP_NONE,
|
||||
};
|
||||
return RegisterSampler(s);
|
||||
}
|
||||
|
||||
// ─── ShapeText ─────────────────────────────────────────────────────────
|
||||
|
||||
std::uint32_t UIRenderer::ShapeText(Font& font, float pxSize,
|
||||
float x, float baselineY,
|
||||
std::string_view utf8,
|
||||
std::array<float,4> color,
|
||||
GlyphItem* out, std::uint32_t outCapacity,
|
||||
float* outAdvance) {
|
||||
if (fontAtlas == nullptr) {
|
||||
throw std::runtime_error("UIRenderer::ShapeText: no FontAtlas (set fontAtlas before Initialize)");
|
||||
}
|
||||
|
||||
const float scale = pxSize / FontAtlas::kBaseSize;
|
||||
float cursor = x;
|
||||
std::uint32_t written = 0;
|
||||
|
||||
std::size_t i = 0;
|
||||
while (i < utf8.size() && written < outCapacity) {
|
||||
std::uint32_t cp = DecodeUtf8(utf8, i);
|
||||
if (cp == 0) break;
|
||||
if (cp == '\n') { /* single-line shaper — ignore */ continue; }
|
||||
|
||||
fontAtlas->Ensure(font, cp);
|
||||
const Glyph* g = fontAtlas->Lookup(font, cp);
|
||||
if (g == nullptr) continue;
|
||||
|
||||
// Empty glyph (whitespace) — advance only.
|
||||
if (g->w > 0 && g->h > 0) {
|
||||
GlyphItem& gi = out[written++];
|
||||
gi.x = cursor + g->xoff * scale;
|
||||
gi.y = baselineY + g->yoff * scale;
|
||||
gi.w = g->w * scale;
|
||||
gi.h = g->h * scale;
|
||||
gi.u0 = g->u0; gi.v0 = g->v0;
|
||||
gi.u1 = g->u1; gi.v1 = g->v1;
|
||||
gi.r = color[0]; gi.g = color[1]; gi.b = color[2]; gi.a = color[3];
|
||||
}
|
||||
cursor += g->advance * scale;
|
||||
}
|
||||
|
||||
if (outAdvance) *outAdvance = cursor - x;
|
||||
return written;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue