Catcrafts/Crafter.Graphics
Watch
2
0
Fork
You've already forked Crafter.Graphics
 0
Code Issues 8 Pull requests Projects Releases Packages Wiki Activity Actions

feat(vulkan): run the compute/UI path without VK_EXT_descriptor_heap

Browse source 
Device::Initialize required twelve device extensions with no capability
check. Mesa Turnip (Adreno) lacks six of them: VK_EXT_descriptor_heap,
VK_KHR_shader_untyped_pointers, VK_EXT_device_fault and the three ray
tracing extensions. vkCreateDevice failed there, so not even a UI-only
program could start, although the UI path is compute-only and needs
nothing else that Turnip is missing.

The descriptor heap, ray tracing and device fault are now optional
groups, detected at start-up from the extension list and the feature
bits (Device::descriptorHeapSupported, rayTracingSupported,
deviceFaultSupported). Ray tracing needs the heap; on a device without
it the ray tracing entry points throw a message naming the cause.

Without the heap the same bindless slots live in one update-after-bind
descriptor set per frame, owned by DescriptorHeapVulkan: binding 0
storage images, 1 sampled images, 2 samplers, 3 storage buffers. Slot
allocation, the slot handles, UIDispatchHeader and the UIRenderer API
are unchanged; buffer slots simply stop being offset. Window::Render
binds that frame's set where it binds the heap, every compute pipeline
shares the heap object's pipeline layout, and push data travels as push
constants.

Each UI kernel is built twice from one source. ui-shared.glsl declares
its resources through UI_HEAP_* macros that expand to descriptor_heap
or, with CRAFTER_GRAPHICS_DESCRIPTOR_SETS defined, to set/binding.
<name>.comp.spv and <name>.comp.sets.spv ship side by side and
ComputeShader::Load picks one. The heap build of every shader is
byte-identical to before.

Breaking:
- ComputeShader::Load takes the heap as a second argument.
- DescriptorHeapVulkan is no longer copyable or movable.
- Custom UI shaders declare heap resources with the UI_HEAP_* macros
  and are registered twice in project.cpp (see the README).
- project.cpp uses Shader::defines and Shader::variant, so it needs a
  crafter-build that has them (Crafter.Build master, fe38cc1 or later).

Also:
- maintenance5 is enabled as a feature, not only as an extension:
  every VulkanBuffer already relied on VkBufferUsageFlags2CreateInfo.
- Barrier stage masks drop RAY_TRACING_SHADER on devices without ray
  tracing, and ImageVulkan::Create resolves its default consumer stage
  to COMPUTE_SHADER there.
- Window refuses a swapchain whose image count is not numFrames
  instead of writing past images[]. The limitation itself is #160.
- CRAFTER_GRAPHICS_NO_DESCRIPTOR_HEAP forces the fallback on a driver
  that has the heap, so it can be exercised on a desktop GPU.

Verified on an RTX 4090 in both modes under the validation layer, and
on a Fairphone 6 (Turnip, Adreno 810, postmarketOS), where the fallback
is the only path.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
Jorijn van der Graaf 2026-10-06 17:28:46 +02:00
commit 48aa9be5ce
22 changed files with 912 additions and 110 deletions
Download patch file Download diff file Expand all files Collapse all files

80
implementations/Crafter.Graphics-ComputeShader.cpp
View file

@ -7,12 +7,14 @@ module Crafter.Graphics:ComputeShader_impl;
import :ComputeShader;
import :ShaderVulkan;
import :Device;
import :DescriptorHeapVulkan;
import std;
using namespace Crafter;
ComputeShader::ComputeShader(ComputeShader&& other) noexcept
: pipeline(other.pipeline),
layout(other.layout),
workaroundNeedsTlas(other.workaroundNeedsTlas),
workaroundTlasPushOffset(other.workaroundTlasPushOffset) {
other.pipeline = VK_NULL_HANDLE;
@ -24,6 +26,7 @@ ComputeShader& ComputeShader::operator=(ComputeShader&& other) noexcept {
vkDestroyPipeline(Device::device, pipeline, nullptr);
}
pipeline = other.pipeline;
layout = other.layout;
workaroundNeedsTlas = other.workaroundNeedsTlas;
workaroundTlasPushOffset = other.workaroundTlasPushOffset;
other.pipeline = VK_NULL_HANDLE;
@ -38,7 +41,44 @@ ComputeShader::~ComputeShader() {
}
}
void ComputeShader::Load(const std::filesystem::path& spvPath) {
void ComputeShader::Load(const std::filesystem::path& spvPath, DescriptorHeapVulkan& heap) {
if (!Device::descriptorHeapSupported) {
// Sets mode. The heap build of the shader uses SPV_EXT_descriptor_heap
// and untyped pointers, which this device cannot consume, so load the
// descriptor-set build compiled from the same source instead.
std::filesystem::path setsPath = spvPath;
setsPath.replace_extension("sets.spv");
// VulkanShader only prints when a file is missing and then creates an
// empty module, which surfaces as an unrelated driver error. A missing
// variant is the likely mistake when a bundle is copied to a device
// without the heap, so name it.
if (!std::filesystem::exists(setsPath)) {
throw std::runtime_error(std::format(
"ComputeShader::Load: this device has no VK_EXT_descriptor_heap, so the descriptor-set build "
"of the shader is required, but {} does not exist. Build the shader a second time with "
"CRAFTER_GRAPHICS_DESCRIPTOR_SETS defined and ship it next to {}.",
setsPath.string(), spvPath.string()));
}
if (heap.pipelineLayout == VK_NULL_HANDLE) {
throw std::runtime_error("ComputeShader::Load: the descriptor heap must be Initialize()d before a shader is loaded against it");
}
VulkanShader shader(setsPath, "main", VK_SHADER_STAGE_COMPUTE_BIT, nullptr);
layout = heap.pipelineLayout;
VkComputePipelineCreateInfo info {
.sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
.stage = {
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
.stage = VK_SHADER_STAGE_COMPUTE_BIT,
.module = shader.shader,
.pName = "main",
},
.layout = layout,
};
Device::CheckVkResult(vkCreateComputePipelines(
Device::device, Device::pipelineCache, 1, &info, nullptr, &pipeline));
return;
}
VulkanShader shader(spvPath, "main", VK_SHADER_STAGE_COMPUTE_BIT, nullptr);
// NVIDIA descriptor-heap AS-read workaround (issue #15 / #7): remember
@ -78,12 +118,38 @@ void ComputeShader::Dispatch(VkCommandBuffer cmd,
VkDeviceAddress tlasAddress) const {
vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline);
if (push != nullptr && pushBytes > 0) {
VkPushDataInfoEXT pushInfo {
.sType = VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT,
.offset = 0,
.data = { .address = const_cast<void*>(push), .size = pushBytes },
};
Device::vkCmdPushDataEXT(cmd, &pushInfo);
if (!Device::descriptorHeapSupported) {
// Sets mode: the same bytes go through the shared layout's
// push-constant range, which DescriptorHeapVulkan sized to the
// device limit rounded down to whole words.
const std::uint32_t limit = Device::deviceProperties.limits.maxPushConstantsSize & ~3u;
const std::uint32_t wholeWords = (pushBytes + 3u) & ~3u;
if (wholeWords > limit) {
throw std::length_error(std::format(
"ComputeShader::Dispatch: {} bytes of push constants exceed this device's limit of {}",
pushBytes, limit));
}
if (wholeWords == pushBytes) {
vkCmdPushConstants(cmd, layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, pushBytes, push);
} else {
// vkCmdPushConstants only takes whole words, and the caller's
// buffer cannot be read past its end, so push a padded copy.
// vkCmdPushDataEXT has the same rule, but nothing enforces it
// on the heap path and drivers accept a ragged size there;
// padding keeps such a payload from failing only on a device
// without the heap.
std::vector<std::byte> padded(wholeWords);
std::memcpy(padded.data(), push, pushBytes);
vkCmdPushConstants(cmd, layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, wholeWords, padded.data());
}
} else {
VkPushDataInfoEXT pushInfo {
.sType = VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT,
.offset = 0,
.data = { .address = const_cast<void*>(push), .size = pushBytes },
};
Device::vkCmdPushDataEXT(cmd, &pushInfo);
}
}
// NVIDIA descriptor-heap AS-read workaround (issue #15 / #7): if this shader
// ray-queries the TLAS through the heap it was rewritten to read the TLAS