feat(vulkan): run the compute/UI path without VK_EXT_descriptor_heap
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:
parent
6aa0338c0f
commit
48aa9be5ce
22 changed files with 912 additions and 110 deletions
|
|
@ -9,17 +9,29 @@ export module Crafter.Graphics:ComputeShader;
|
|||
#ifndef CRAFTER_GRAPHICS_WINDOW_DOM
|
||||
import std;
|
||||
import :Device;
|
||||
import :DescriptorHeapVulkan;
|
||||
|
||||
export namespace Crafter {
|
||||
// Tier 1: thin compute-pipeline wrapper. Owns one VkPipeline created with
|
||||
// VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT (no pipeline layout — the
|
||||
// bindless heap supplies all bindings, push constants travel via
|
||||
// vkCmdPushDataEXT). Use this to dispatch the four standard UI shaders
|
||||
// and any user-authored compute shader that follows the ui-shared.glsl
|
||||
// contract.
|
||||
// Tier 1: thin compute-pipeline wrapper. Owns one VkPipeline. Use this to
|
||||
// dispatch the four standard UI shaders and any user-authored compute
|
||||
// shader that follows the ui-shared.glsl contract.
|
||||
//
|
||||
// The pipeline follows the device's binding model
|
||||
// (Device::descriptorHeapSupported):
|
||||
// heap -> created with VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT and
|
||||
// no pipeline layout; the bindless heap supplies all bindings
|
||||
// and push constants travel via vkCmdPushDataEXT.
|
||||
// sets -> created from the shader's <name>.sets.spv build against the
|
||||
// heap object's shared pipeline layout; the bindless descriptor
|
||||
// set supplies the bindings and push constants travel via
|
||||
// vkCmdPushConstants.
|
||||
class ComputeShader {
|
||||
public:
|
||||
VkPipeline pipeline = VK_NULL_HANDLE;
|
||||
// Sets mode only: the pipeline layout of the heap this shader was
|
||||
// loaded against, needed again by vkCmdPushConstants. Not owned — it
|
||||
// belongs to that DescriptorHeapVulkan. VK_NULL_HANDLE in heap mode.
|
||||
VkPipelineLayout layout = VK_NULL_HANDLE;
|
||||
|
||||
// NVIDIA descriptor-heap AS-read workaround (issue #15 / #7): set by
|
||||
// Load when this shader ray-queries the TLAS through the descriptor
|
||||
|
|
@ -38,14 +50,30 @@ export namespace Crafter {
|
|||
ComputeShader& operator=(ComputeShader&& other) noexcept;
|
||||
~ComputeShader();
|
||||
|
||||
// Loads a SPIR-V compute shader from disk and creates a pipeline that
|
||||
// uses the bindless descriptor-heap binding model.
|
||||
void Load(const std::filesystem::path& spvPath);
|
||||
// Loads a SPIR-V compute shader from disk and creates its pipeline.
|
||||
//
|
||||
// `spvPath` always names the descriptor-heap build (<name>.spv). On a
|
||||
// device without the heap, the <name>.sets.spv build next to it is
|
||||
// loaded instead, so the caller never branches on the binding model;
|
||||
// a missing .sets.spv throws, naming the file.
|
||||
//
|
||||
// `heap` must already be Initialize()d and must be the heap assigned
|
||||
// to Window::descriptorHeap for every frame this shader is dispatched
|
||||
// in: in sets mode the pipeline is built against that heap's layout,
|
||||
// and Window::Render binds that heap's descriptor set.
|
||||
void Load(const std::filesystem::path& spvPath, DescriptorHeapVulkan& heap);
|
||||
|
||||
// Bind, push constants (if any), dispatch. Caller computes group counts
|
||||
// and is responsible for any inter-dispatch barriers (UIRenderer::Dispatch
|
||||
// wraps this with the standard write-after-write barrier).
|
||||
//
|
||||
// pushBytes should be a multiple of 4 (Vulkan requires it for both
|
||||
// push mechanisms). On a device without the descriptor heap the
|
||||
// payload travels as ordinary push constants, so it must also fit
|
||||
// the device's maxPushConstantsSize (256 bytes on common drivers); a
|
||||
// larger one throws std::length_error. Keep push blocks within that
|
||||
// if the shader is meant to run on both binding models.
|
||||
//
|
||||
// tlasAddress is the NVIDIA descriptor-heap AS-read workaround hook
|
||||
// (issue #15 / #7): a shader that ray-queries the TLAS through the
|
||||
// descriptor heap is rewritten to read its device address from a push
|
||||
|
|
|
|||
|
|
@ -39,7 +39,95 @@ export namespace Crafter {
|
|||
std::vector<std::uint16_t> bufferFreelist;
|
||||
std::vector<std::uint16_t> samplerFreelist;
|
||||
|
||||
// ─── Sets mode ──────────────────────────────────────────────────
|
||||
// Used instead of the heap buffers above when the driver has no
|
||||
// VK_EXT_descriptor_heap (Device::descriptorHeapSupported == false).
|
||||
// The same slots then live in one bindless descriptor set per frame,
|
||||
// mirroring the per-frame heap copies, so slot allocation, the slot
|
||||
// handles and every shader-side index keep their meaning:
|
||||
// binding 0 STORAGE_IMAGE[] image slots written as storage images
|
||||
// binding 1 SAMPLED_IMAGE[] image slots written as sampled images
|
||||
// binding 2 SAMPLER[] sampler slots
|
||||
// binding 3 STORAGE_BUFFER[] buffer slots (bufferStartElement is 0)
|
||||
// These numbers are the UI_HEAP_* macros in shaders/ui-shared.glsl.
|
||||
// Bindings 0 and 1 share the image slot space the way the two typed
|
||||
// views of the resource heap do; a slot is valid in whichever of the
|
||||
// two it was written to.
|
||||
//
|
||||
// All bindings are PARTIALLY_BOUND | UPDATE_AFTER_BIND |
|
||||
// UPDATE_UNUSED_WHILE_PENDING: most slots are never written, and a
|
||||
// slot is written into every frame's set at once while earlier frames
|
||||
// may still be executing with their set bound.
|
||||
static constexpr std::uint32_t storageImageBinding = 0;
|
||||
static constexpr std::uint32_t sampledImageBinding = 1;
|
||||
static constexpr std::uint32_t samplerBinding = 2;
|
||||
static constexpr std::uint32_t storageBufferBinding = 3;
|
||||
|
||||
VkDescriptorPool setPool = VK_NULL_HANDLE;
|
||||
VkDescriptorSetLayout setLayout = VK_NULL_HANDLE;
|
||||
// Shared by every compute pipeline created against this heap
|
||||
// (ComputeShader::Load), so the set Window::Render binds once per
|
||||
// frame stays bound across all of them. Carries one compute
|
||||
// push-constant range covering the device's whole push-constant space.
|
||||
VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
|
||||
VkDescriptorSet sets[Window::numFrames] {};
|
||||
// Descriptor sets reference VkImageView / VkSampler objects, where the
|
||||
// heap takes create-infos, so in sets mode this struct creates and
|
||||
// owns them. setImageViews[frame][slot] is the view frame's set uses
|
||||
// at that image slot; a view shared by all frames is stored under
|
||||
// frame 0 only. setSamplers[slot] likewise.
|
||||
std::vector<VkImageView> setImageViews[Window::numFrames];
|
||||
std::vector<VkSampler> setSamplers;
|
||||
|
||||
DescriptorHeapVulkan() = default;
|
||||
DescriptorHeapVulkan(const DescriptorHeapVulkan&) = delete;
|
||||
DescriptorHeapVulkan& operator=(const DescriptorHeapVulkan&) = delete;
|
||||
|
||||
// Heap mode owns nothing beyond its VulkanBuffers, which release
|
||||
// themselves. Sets mode owns the objects above. The frame loop keeps
|
||||
// frames in flight and nothing waits for them at shutdown, so wait
|
||||
// here: destroying a view or the pool under a still-executing command
|
||||
// buffer is a use-after-free on the GPU.
|
||||
~DescriptorHeapVulkan() {
|
||||
if (setLayout == VK_NULL_HANDLE) {
|
||||
return;
|
||||
}
|
||||
vkQueueWaitIdle(Device::queue);
|
||||
DestroySets();
|
||||
}
|
||||
|
||||
// Destroys every sets-mode object and returns to the un-initialized
|
||||
// state. The caller guarantees nothing on the GPU still uses them.
|
||||
// Safe on a partly built heap: destroying VK_NULL_HANDLE is a no-op.
|
||||
void DestroySets() noexcept {
|
||||
vkDestroyDescriptorPool(Device::device, setPool, nullptr);
|
||||
for (std::vector<VkImageView>& views : setImageViews) {
|
||||
for (VkImageView view : views) {
|
||||
vkDestroyImageView(Device::device, view, nullptr);
|
||||
}
|
||||
views.clear();
|
||||
}
|
||||
for (VkSampler sampler : setSamplers) {
|
||||
vkDestroySampler(Device::device, sampler, nullptr);
|
||||
}
|
||||
setSamplers.clear();
|
||||
vkDestroyDescriptorSetLayout(Device::device, setLayout, nullptr);
|
||||
vkDestroyPipelineLayout(Device::device, pipelineLayout, nullptr);
|
||||
setPool = VK_NULL_HANDLE;
|
||||
setLayout = VK_NULL_HANDLE;
|
||||
pipelineLayout = VK_NULL_HANDLE;
|
||||
std::ranges::fill(sets, VkDescriptorSet{VK_NULL_HANDLE});
|
||||
}
|
||||
|
||||
// Call once, before any shader is loaded against this heap. In heap
|
||||
// mode a second call simply re-sizes the heap buffers; in sets mode it
|
||||
// throws, because the pipelines already built against the old layout
|
||||
// could not be used with a new one.
|
||||
void Initialize(std::uint16_t images, std::uint16_t buffers, std::uint16_t samplers) {
|
||||
if (!Device::descriptorHeapSupported) {
|
||||
InitializeSets(images, buffers, samplers);
|
||||
return;
|
||||
}
|
||||
std::uint32_t descriptorRegion = images * Device::descriptorHeapProperties.imageDescriptorSize + buffers * Device::descriptorHeapProperties.bufferDescriptorSize;
|
||||
std::uint32_t alignedDescriptorRegion = (descriptorRegion + Device::descriptorHeapProperties.imageDescriptorAlignment - 1) & ~(Device::descriptorHeapProperties.imageDescriptorAlignment - 1);
|
||||
std::uint32_t resourceSize = alignedDescriptorRegion + Device::descriptorHeapProperties.minResourceHeapReservedRange;
|
||||
|
|
@ -78,6 +166,231 @@ export namespace Crafter {
|
|||
}
|
||||
}
|
||||
|
||||
// Sets-mode half of Initialize. Kept apart so the heap sizing above,
|
||||
// which divides by descriptor sizes that are zero without the
|
||||
// extension, never runs here.
|
||||
void InitializeSets(std::uint16_t images, std::uint16_t buffers, std::uint16_t samplers) {
|
||||
// A second Initialize would leak the first pool and layouts and
|
||||
// leave every pipeline created against the old layout
|
||||
// incompatible with the new sets.
|
||||
if (setLayout != VK_NULL_HANDLE) {
|
||||
throw std::runtime_error("DescriptorHeapVulkan: Initialize called twice (descriptor-set mode cannot be re-initialized)");
|
||||
}
|
||||
// If a step below throws, undo the ones that succeeded. A
|
||||
// half-built heap would otherwise keep setLayout set, so a retry
|
||||
// would report "Initialize called twice" instead of the real
|
||||
// error, and nothing would release what was created.
|
||||
struct Rollback {
|
||||
DescriptorHeapVulkan* heap;
|
||||
~Rollback() { if (heap != nullptr) heap->DestroySets(); }
|
||||
} rollback{this};
|
||||
|
||||
// Buffer slots are plain array indices into binding 3, so
|
||||
// BufferSlot's conversion adds nothing.
|
||||
bufferStartElement = 0;
|
||||
bufferStartOffset = 0;
|
||||
|
||||
imageCapacity = images;
|
||||
bufferCapacity = buffers;
|
||||
samplerCapacity = samplers;
|
||||
imageNext = 0;
|
||||
bufferNext = 0;
|
||||
samplerNext = 0;
|
||||
imageFreelist.clear();
|
||||
imageFreelist.reserve(images);
|
||||
bufferFreelist.clear();
|
||||
bufferFreelist.reserve(buffers);
|
||||
samplerFreelist.clear();
|
||||
samplerFreelist.reserve(samplers);
|
||||
|
||||
// At least one descriptor per binding even when a pool was sized
|
||||
// zero (Initialize(1, 1, 0) is common): a zero-count pool size is
|
||||
// invalid, and the UI shaders statically reference all four arrays.
|
||||
const std::uint32_t imageCount = std::max<std::uint32_t>(images, 1);
|
||||
const std::uint32_t bufferCount = std::max<std::uint32_t>(buffers, 1);
|
||||
const std::uint32_t samplerCount = std::max<std::uint32_t>(samplers, 1);
|
||||
|
||||
const VkDescriptorSetLayoutBinding bindings[] = {
|
||||
{ storageImageBinding, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, imageCount, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
|
||||
{ sampledImageBinding, VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, imageCount, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
|
||||
{ samplerBinding, VK_DESCRIPTOR_TYPE_SAMPLER, samplerCount, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
|
||||
{ storageBufferBinding, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, bufferCount, VK_SHADER_STAGE_COMPUTE_BIT, nullptr },
|
||||
};
|
||||
constexpr VkDescriptorBindingFlags slotFlags =
|
||||
VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT
|
||||
| VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT
|
||||
| VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT;
|
||||
const VkDescriptorBindingFlags bindingFlags[] = { slotFlags, slotFlags, slotFlags, slotFlags };
|
||||
const VkDescriptorSetLayoutBindingFlagsCreateInfo bindingFlagsInfo {
|
||||
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
|
||||
.bindingCount = static_cast<std::uint32_t>(std::size(bindingFlags)),
|
||||
.pBindingFlags = bindingFlags,
|
||||
};
|
||||
const VkDescriptorSetLayoutCreateInfo layoutInfo {
|
||||
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
|
||||
.pNext = &bindingFlagsInfo,
|
||||
.flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
|
||||
.bindingCount = static_cast<std::uint32_t>(std::size(bindings)),
|
||||
.pBindings = bindings,
|
||||
};
|
||||
Device::CheckVkResult(vkCreateDescriptorSetLayout(Device::device, &layoutInfo, nullptr, &setLayout));
|
||||
|
||||
// One range over the whole push-constant space rather than a
|
||||
// per-shader size: the layout is shared, and each Dispatch pushes
|
||||
// only the bytes its shader declares.
|
||||
const VkPushConstantRange pushRange {
|
||||
.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT,
|
||||
.offset = 0,
|
||||
.size = Device::deviceProperties.limits.maxPushConstantsSize & ~3u,
|
||||
};
|
||||
const VkPipelineLayoutCreateInfo pipelineLayoutInfo {
|
||||
.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
|
||||
.setLayoutCount = 1,
|
||||
.pSetLayouts = &setLayout,
|
||||
.pushConstantRangeCount = 1,
|
||||
.pPushConstantRanges = &pushRange,
|
||||
};
|
||||
Device::CheckVkResult(vkCreatePipelineLayout(Device::device, &pipelineLayoutInfo, nullptr, &pipelineLayout));
|
||||
|
||||
const VkDescriptorPoolSize poolSizes[] = {
|
||||
{ VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, imageCount * Window::numFrames },
|
||||
{ VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE, imageCount * Window::numFrames },
|
||||
{ VK_DESCRIPTOR_TYPE_SAMPLER, samplerCount * Window::numFrames },
|
||||
{ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, bufferCount * Window::numFrames },
|
||||
};
|
||||
const VkDescriptorPoolCreateInfo poolInfo {
|
||||
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
|
||||
.flags = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
|
||||
.maxSets = Window::numFrames,
|
||||
.poolSizeCount = static_cast<std::uint32_t>(std::size(poolSizes)),
|
||||
.pPoolSizes = poolSizes,
|
||||
};
|
||||
Device::CheckVkResult(vkCreateDescriptorPool(Device::device, &poolInfo, nullptr, &setPool));
|
||||
|
||||
VkDescriptorSetLayout setLayouts[Window::numFrames];
|
||||
std::ranges::fill(setLayouts, setLayout);
|
||||
const VkDescriptorSetAllocateInfo allocInfo {
|
||||
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
|
||||
.descriptorPool = setPool,
|
||||
.descriptorSetCount = Window::numFrames,
|
||||
.pSetLayouts = setLayouts,
|
||||
};
|
||||
Device::CheckVkResult(vkAllocateDescriptorSets(Device::device, &allocInfo, sets));
|
||||
|
||||
for (std::vector<VkImageView>& views : setImageViews) {
|
||||
views.assign(imageCount, VK_NULL_HANDLE);
|
||||
}
|
||||
setSamplers.assign(samplerCount, VK_NULL_HANDLE);
|
||||
rollback.heap = nullptr;
|
||||
}
|
||||
|
||||
// ─── Sets-mode descriptor writes ────────────────────────────────
|
||||
// The counterparts of vkWriteResourceDescriptorsEXT /
|
||||
// vkWriteSamplerDescriptorsEXT into the heap buffers. Call only when
|
||||
// !Device::descriptorHeapSupported. `slot` is the raw index the
|
||||
// Allocate*Slots call returned.
|
||||
//
|
||||
// Each write replaces whatever view or sampler the slot held and
|
||||
// destroys it immediately. That relies on the same contract as slot
|
||||
// reuse in heap mode: no frame in flight may still reference the slot
|
||||
// (true after the queue drain that precedes Window::onResize, and for
|
||||
// a slot that was freed at a scene-switch barrier).
|
||||
|
||||
// Writes `type` (STORAGE_IMAGE or SAMPLED_IMAGE) at an image slot of
|
||||
// one frame's set, for images that differ per frame: the swapchain.
|
||||
// A slot written this way must be written for every frame.
|
||||
void WriteImageSet(std::uint8_t frame, std::uint16_t slot, VkDescriptorType type,
|
||||
const VkImageViewCreateInfo& viewInfo, VkImageLayout layout) {
|
||||
VkImageView view = VK_NULL_HANDLE;
|
||||
Device::CheckVkResult(vkCreateImageView(Device::device, &viewInfo, nullptr, &view));
|
||||
vkDestroyImageView(Device::device, setImageViews[frame][slot], nullptr);
|
||||
setImageViews[frame][slot] = view;
|
||||
|
||||
const VkDescriptorImageInfo imageInfo { .imageView = view, .imageLayout = layout };
|
||||
const VkWriteDescriptorSet write {
|
||||
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
|
||||
.dstSet = sets[frame],
|
||||
.dstBinding = type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE ? storageImageBinding : sampledImageBinding,
|
||||
.dstArrayElement = slot,
|
||||
.descriptorCount = 1,
|
||||
.descriptorType = type,
|
||||
.pImageInfo = &imageInfo,
|
||||
};
|
||||
vkUpdateDescriptorSets(Device::device, 1, &write, 0, nullptr);
|
||||
}
|
||||
|
||||
// Writes the same image at an image slot of every frame's set, through
|
||||
// one shared view.
|
||||
void WriteImageSets(std::uint16_t slot, VkDescriptorType type,
|
||||
const VkImageViewCreateInfo& viewInfo, VkImageLayout layout) {
|
||||
VkImageView view = VK_NULL_HANDLE;
|
||||
Device::CheckVkResult(vkCreateImageView(Device::device, &viewInfo, nullptr, &view));
|
||||
for (std::vector<VkImageView>& views : setImageViews) {
|
||||
vkDestroyImageView(Device::device, views[slot], nullptr);
|
||||
views[slot] = VK_NULL_HANDLE;
|
||||
}
|
||||
setImageViews[0][slot] = view;
|
||||
|
||||
const VkDescriptorImageInfo imageInfo { .imageView = view, .imageLayout = layout };
|
||||
VkWriteDescriptorSet writes[Window::numFrames];
|
||||
for (std::uint8_t f = 0; f < Window::numFrames; ++f) {
|
||||
writes[f] = {
|
||||
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
|
||||
.dstSet = sets[f],
|
||||
.dstBinding = type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE ? storageImageBinding : sampledImageBinding,
|
||||
.dstArrayElement = slot,
|
||||
.descriptorCount = 1,
|
||||
.descriptorType = type,
|
||||
.pImageInfo = &imageInfo,
|
||||
};
|
||||
}
|
||||
vkUpdateDescriptorSets(Device::device, Window::numFrames, writes, 0, nullptr);
|
||||
}
|
||||
|
||||
// Writes a storage buffer at a buffer slot of every frame's set. The
|
||||
// whole buffer is bound; the shader's runtime array is bounded by the
|
||||
// item count the dispatch passes, as in heap mode.
|
||||
void WriteBufferSets(std::uint16_t slot, VkBuffer buffer) {
|
||||
const VkDescriptorBufferInfo bufferInfo { .buffer = buffer, .offset = 0, .range = VK_WHOLE_SIZE };
|
||||
VkWriteDescriptorSet writes[Window::numFrames];
|
||||
for (std::uint8_t f = 0; f < Window::numFrames; ++f) {
|
||||
writes[f] = {
|
||||
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
|
||||
.dstSet = sets[f],
|
||||
.dstBinding = storageBufferBinding,
|
||||
.dstArrayElement = slot,
|
||||
.descriptorCount = 1,
|
||||
.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
|
||||
.pBufferInfo = &bufferInfo,
|
||||
};
|
||||
}
|
||||
vkUpdateDescriptorSets(Device::device, Window::numFrames, writes, 0, nullptr);
|
||||
}
|
||||
|
||||
// Creates the sampler and writes it at a sampler slot of every
|
||||
// frame's set.
|
||||
void WriteSamplerSets(std::uint16_t slot, const VkSamplerCreateInfo& info) {
|
||||
VkSampler sampler = VK_NULL_HANDLE;
|
||||
Device::CheckVkResult(vkCreateSampler(Device::device, &info, nullptr, &sampler));
|
||||
vkDestroySampler(Device::device, setSamplers[slot], nullptr);
|
||||
setSamplers[slot] = sampler;
|
||||
|
||||
const VkDescriptorImageInfo samplerInfo { .sampler = sampler };
|
||||
VkWriteDescriptorSet writes[Window::numFrames];
|
||||
for (std::uint8_t f = 0; f < Window::numFrames; ++f) {
|
||||
writes[f] = {
|
||||
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
|
||||
.dstSet = sets[f],
|
||||
.dstBinding = samplerBinding,
|
||||
.dstArrayElement = slot,
|
||||
.descriptorCount = 1,
|
||||
.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER,
|
||||
.pImageInfo = &samplerInfo,
|
||||
};
|
||||
}
|
||||
vkUpdateDescriptorSets(Device::device, Window::numFrames, writes, 0, nullptr);
|
||||
}
|
||||
|
||||
ImageSlotRange AllocateImageSlots(std::uint16_t count) {
|
||||
if (count == 1 && !imageFreelist.empty()) {
|
||||
std::uint16_t s = imageFreelist.back();
|
||||
|
|
@ -158,7 +471,12 @@ export namespace Crafter {
|
|||
return firstElement * Device::descriptorHeapProperties.samplerDescriptorSize;
|
||||
}
|
||||
|
||||
// Both are 0 in sets mode: buffer slots are plain indices into their
|
||||
// own binding, and the heap descriptor sizes divided by below are zero.
|
||||
inline static std::uint32_t GetBufferOffset(std::uint16_t images, std::uint16_t buffers) {
|
||||
if (!Device::descriptorHeapSupported) {
|
||||
return 0;
|
||||
}
|
||||
std::uint32_t bufferStartElement = images * Device::descriptorHeapProperties.imageDescriptorSize / Device::descriptorHeapProperties.bufferDescriptorSize;
|
||||
|
||||
if(images > 0 && bufferStartElement == 0) {
|
||||
|
|
@ -167,6 +485,9 @@ export namespace Crafter {
|
|||
return bufferStartElement * Device::descriptorHeapProperties.bufferDescriptorSize;
|
||||
}
|
||||
inline static std::uint16_t GetBufferOffsetElement(std::uint16_t images, std::uint16_t buffers) {
|
||||
if (!Device::descriptorHeapSupported) {
|
||||
return 0;
|
||||
}
|
||||
std::uint16_t bufferStartElement = images * Device::descriptorHeapProperties.imageDescriptorSize / Device::descriptorHeapProperties.bufferDescriptorSize;
|
||||
|
||||
if(images > 0 && bufferStartElement == 0) {
|
||||
|
|
|
|||
|
|
@ -174,12 +174,39 @@ export namespace Crafter {
|
|||
// relocate it.
|
||||
inline static std::filesystem::path pipelineCachePath = "pipeline_cache.bin";
|
||||
|
||||
// ─── Optional capability groups ────────────────────────────────
|
||||
// Decided once by Initialize from the extensions the driver
|
||||
// advertises; false until then. Not every driver has the descriptor
|
||||
// heap (Mesa Turnip on Adreno has neither it nor ray tracing), so the
|
||||
// compute/UI path runs in one of two binding models:
|
||||
// descriptorHeapSupported -> VK_EXT_descriptor_heap, the *.spv shaders
|
||||
// !descriptorHeapSupported -> one bindless descriptor set per frame
|
||||
// (DescriptorHeapVulkan sets mode), the
|
||||
// *.sets.spv shaders, vkCmdPushConstants
|
||||
// Setting the environment variable CRAFTER_GRAPHICS_NO_DESCRIPTOR_HEAP
|
||||
// forces the second model on any driver, for testing.
|
||||
inline static bool descriptorHeapSupported = false;
|
||||
// Ray tracing also needs the descriptor heap (RT pipelines and RT
|
||||
// shaders are heap-only), so this is never true without it.
|
||||
inline static bool rayTracingSupported = false;
|
||||
// VK_EXT_device_fault: the VK_ERROR_DEVICE_LOST report in CheckVkResult.
|
||||
inline static bool deviceFaultSupported = false;
|
||||
// Pipeline stages that are valid on this device: everything, minus
|
||||
// RAY_TRACING_SHADER when ray tracing is unsupported. AND it into any
|
||||
// stage mask built from a constant that names the RT stage.
|
||||
inline static VkPipelineStageFlags stageMask = ~VkPipelineStageFlags{0};
|
||||
// Throws std::runtime_error naming the missing capability when ray
|
||||
// tracing is unsupported. Called at every ray tracing entry point.
|
||||
static void RequireRayTracing();
|
||||
|
||||
// The two property structs below are only filled in (and only chained
|
||||
// into the properties query) when their capability group is supported;
|
||||
// otherwise they stay zero.
|
||||
inline static VkPhysicalDeviceDescriptorHeapPropertiesEXT descriptorHeapProperties = {
|
||||
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT
|
||||
};
|
||||
inline static VkPhysicalDeviceRayTracingPipelinePropertiesKHR rayTracingProperties = {
|
||||
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR,
|
||||
.pNext = &descriptorHeapProperties
|
||||
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR
|
||||
};
|
||||
inline static VkPhysicalDeviceMemoryDecompressionPropertiesEXT memoryDecompressionProperties = {
|
||||
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT
|
||||
|
|
|
|||
|
|
@ -90,6 +90,15 @@ export namespace Crafter {
|
|||
this->width = width;
|
||||
this->height = height;
|
||||
this->mipLevels = mipLevels;
|
||||
// The RT default is not a valid pipeline stage on a device without
|
||||
// ray tracing, where the only shader that can sample an image is a
|
||||
// compute shader. Resolved here rather than in the member
|
||||
// initializer, which can run before Device::Initialize. The
|
||||
// parameter is corrected, not only the member: the transition at
|
||||
// the end of this function is recorded with it.
|
||||
if (!Device::rayTracingSupported && consumerStage == VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR) {
|
||||
consumerStage = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
|
||||
}
|
||||
this->consumerStage = consumerStage;
|
||||
this->streamed = streamed;
|
||||
buffer.Create(
|
||||
|
|
|
|||
|
|
@ -39,6 +39,7 @@ export namespace Crafter {
|
|||
// matching the simple examples) and is clamped to the device's
|
||||
// maxRayRecursionDepth.
|
||||
void Init(VkCommandBuffer cmd, std::span<VkRayTracingShaderGroupCreateInfoKHR> raygenGroups, std::span<VkRayTracingShaderGroupCreateInfoKHR> missGroups, std::span<VkRayTracingShaderGroupCreateInfoKHR> hitGroups, ShaderBindingTableVulkan& shaderTable, std::uint32_t maxRecursionDepth = 1) {
|
||||
Device::RequireRayTracing();
|
||||
workaroundNeedsTlas = shaderTable.workaroundNeedsTlas;
|
||||
workaroundTlasPushOffset = shaderTable.workaroundTlasPushOffset;
|
||||
|
||||
|
|
|
|||
|
|
@ -26,6 +26,7 @@ export namespace Crafter {
|
|||
bool workaroundNeedsTlas = false;
|
||||
std::uint32_t workaroundTlasPushOffset = 0;
|
||||
void Init(const std::span<const VulkanShader> shaders) {
|
||||
Device::RequireRayTracing();
|
||||
shaderStages.reserve(shaders.size());
|
||||
for(const VulkanShader& shader: shaders) {
|
||||
shaderStages.emplace_back(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0, shader.stage, shader.shader, shader.entrypoint.c_str(), shader.specilizationInfo);
|
||||
|
|
|
|||
|
|
@ -351,6 +351,17 @@ export namespace Crafter {
|
|||
bool patchedAS = false;
|
||||
std::uint32_t tlasPushOffset = 0;
|
||||
VulkanShader(const std::filesystem::path& path, std::string entrypoint, VkShaderStageFlagBits stage, VkSpecializationInfo* specilizationInfo) : stage(stage), entrypoint(entrypoint), specilizationInfo(specilizationInfo) {
|
||||
// A ray tracing stage is the first thing every RT setup creates.
|
||||
// Stop here on a device without ray tracing: its shaders are
|
||||
// descriptor-heap SPIR-V, which must not reach a driver that never
|
||||
// enabled the heap or untyped pointers.
|
||||
constexpr VkShaderStageFlags rayTracingStages =
|
||||
VK_SHADER_STAGE_RAYGEN_BIT_KHR | VK_SHADER_STAGE_ANY_HIT_BIT_KHR
|
||||
| VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR | VK_SHADER_STAGE_MISS_BIT_KHR
|
||||
| VK_SHADER_STAGE_INTERSECTION_BIT_KHR | VK_SHADER_STAGE_CALLABLE_BIT_KHR;
|
||||
if ((stage & rayTracingStages) != 0) {
|
||||
Device::RequireRayTracing();
|
||||
}
|
||||
std::ifstream file(path, std::ios::binary);
|
||||
if (!file) {
|
||||
std::cerr << "Error: Could not open file " << path << std::endl;
|
||||
|
|
|
|||
|
|
@ -260,9 +260,10 @@ export namespace Crafter {
|
|||
const FusedBatch& text);
|
||||
|
||||
// Generic dispatch for user-authored shaders. On Vulkan, `shader` is
|
||||
// a SPIR-V compute pipeline (bindless via VK_EXT_descriptor_heap, so
|
||||
// any resource indices baked into push data resolve through the
|
||||
// global heap). On DOM, `shader` carries a UICustomBinding list
|
||||
// a SPIR-V compute pipeline (bindless, via VK_EXT_descriptor_heap or
|
||||
// the descriptor-set fallback, so any resource indices baked into
|
||||
// push data resolve through the global heap either way). On DOM,
|
||||
// `shader` carries a UICustomBinding list
|
||||
// declared at Load time; the renderer reads the listed slot uints
|
||||
// out of `push`, resolves them against heap.bufferTable /
|
||||
// imageTable / samplerTable, and builds the bind groups before
|
||||
|
|
@ -430,7 +431,7 @@ export namespace Crafter {
|
|||
#ifndef CRAFTER_GRAPHICS_WINDOW_DOM
|
||||
void WriteSwapchainDescriptors();
|
||||
void WriteFontAtlasDescriptor();
|
||||
void WriteBufferDescriptor(std::uint16_t slot, VkDeviceAddress address, std::uint32_t size);
|
||||
void WriteBufferDescriptor(std::uint16_t slot, VkBuffer buffer, VkDeviceAddress address, std::uint32_t size);
|
||||
void WriteSampledImageDescriptor(std::uint16_t slot,
|
||||
const VkImageViewCreateInfo& viewInfo,
|
||||
VkImageLayout layout);
|
||||
|
|
@ -442,7 +443,7 @@ export namespace Crafter {
|
|||
BufferSlot UIRenderer::RegisterBuffer(GraphicsBuffer<T, Mapped>& buffer) {
|
||||
auto range = heap_->AllocateBufferSlots(1);
|
||||
#ifndef CRAFTER_GRAPHICS_WINDOW_DOM
|
||||
WriteBufferDescriptor(range.firstElement, buffer.address, buffer.size);
|
||||
WriteBufferDescriptor(range.firstElement, buffer.buffer, buffer.address, buffer.size);
|
||||
#else
|
||||
heap_->bufferTable[range.firstElement] = buffer.handle;
|
||||
#endif
|
||||
|
|
@ -454,6 +455,10 @@ export namespace Crafter {
|
|||
ImageSlot UIRenderer::RegisterImage(ImageVulkan<Pixel>& image, VkFormat format,
|
||||
VkImageLayout layout) {
|
||||
auto range = heap_->AllocateImageSlots(1);
|
||||
// The handle owns the slot from here on: in descriptor-set mode the
|
||||
// write creates an image view, and if that throws the slot returns
|
||||
// to the freelist instead of leaking.
|
||||
ImageSlot slot{heap_, range.firstElement};
|
||||
VkImageViewCreateInfo info {
|
||||
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
|
||||
.image = image.image,
|
||||
|
|
@ -472,7 +477,7 @@ export namespace Crafter {
|
|||
},
|
||||
};
|
||||
WriteSampledImageDescriptor(range.firstElement, info, layout);
|
||||
return ImageSlot{heap_, range.firstElement};
|
||||
return slot;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,6 +9,7 @@ module;
|
|||
export module Crafter.Graphics:VulkanTransition;
|
||||
#ifndef CRAFTER_GRAPHICS_WINDOW_DOM
|
||||
import std;
|
||||
import :Device;
|
||||
|
||||
export namespace Crafter {
|
||||
#include "vulkan/vulkan.h"
|
||||
|
|
@ -68,7 +69,10 @@ export namespace Crafter {
|
|||
return VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
|
||||
case VK_IMAGE_LAYOUT_GENERAL:
|
||||
//assert(false && "Don't know how to get a meaningful VkPipelineStageFlags for VK_IMAGE_LAYOUT_GENERAL! Don't use it!");
|
||||
return VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
|
||||
// GENERAL images are written by RT or compute shaders; on a
|
||||
// device without ray tracing the RT stage is not a valid stage.
|
||||
return Device::rayTracingSupported ? VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR
|
||||
: VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
|
||||
default:
|
||||
assert(false);
|
||||
return 0;
|
||||
|
|
|
|||
Loading…
Reference in a new issue