Jorijn van der Graaf
bcdc885de8
Device
- Device::Initialize(required, optional) takes DeviceFeatures, the five
core feature structs vulkan10 to vulkan14. The library enables only what
its own shaders and code use. Device::enabledFeatures says what was
enabled, supportedFeatures what the GPU has, apiVersion the version in
use.
- shaderInt16, shaderFloat16, storageBuffer16BitAccess, scalarBlockLayout
and the uniform-buffer, storage-buffer and storage-image non-uniform
indexing bits are no longer enabled for everyone. An application whose
shaders take uint16_t spec constants passes
{.vulkan10 = {.shaderInt16 = VK_TRUE}}. scalarBlockLayout stays on with
the NVIDIA workaround, whose TLAS address may sit in a struct's tail
padding.
- Every GPU is weighed before one is chosen: Vulkan 1.3, the swapchain and,
below 1.4, maintenance5 extensions, the library's needs, the required
features. One that can't run the application is skipped, saying why when
it ranks higher. A CPU device runs it only when nothing else is listed,
and CRAFTER_GRAPHICS_DEVICE never falls back. A GPU two drivers both list
is tried through each.
- When no GPU qualifies, Initialize throws naming each GPU's gaps. It
destroys the instance it made, before any Wayland connection, so it can
be called again asking for less.
- maintenance5 is vulkan14's on a 1.4 GPU and VK_KHR_maintenance5's below.
CRAFTER_GRAPHICS_NO_VULKAN_1_4 runs as a 1.3 application, to exercise
that path on a 1.4 GPU.
- VK_KHR_spirv_1_4 and VK_KHR_shader_float_controls, core since 1.2, are no
longer enabled, nor VK_EXT_shader_atomic_float, which was enabled without
its feature struct. memoryDecompression's feature bit is queried before
it is enabled.
Shaders
- VulkanShader checks a module's capabilities, declared directly or
implicitly, against the enabled core features, the GPU's subgroup
operations and the optional groups, and throws naming the field to pass,
or saying the GPU lacks it. The tables are generated from vk.xml and
SPIR-V's grammar.
- WorkaroundNvidiaAS::Patch sized a row-major matrix push member by its
columns, so the TLAS address could land inside it.
Window
- The swapchain format is one whose own feature flags allow storage reads
and writes without a format, which since Vulkan 1.3 each format says for
itself; shaderStorageImageRead/WriteWithoutFormat are no longer required.
Tests
- DeviceFeatures: ResolveFeatures, ChooseDevice and CheckShaderCapabilities,
without a GPU.
- FeatureRequests: required and optional features end to end, the 1.3
path, and a retry after a refusal.
- PushConstantRewrite: a row-major mat3x4 push member.
- HeapASRead, HeapDynamicIndexHit, RTPassPushData and the ray-tracing
examples ask for the features their shaders use.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
457 lines
24 KiB
C++
457 lines
24 KiB
C++
//SPDX-License-Identifier: LGPL-3.0-only
|
||
//SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
|
||
|
||
module;
|
||
#ifndef CRAFTER_GRAPHICS_WINDOW_DOM
|
||
#include "vulkan/vulkan.h"
|
||
#endif // !CRAFTER_GRAPHICS_WINDOW_DOM
|
||
export module Crafter.Graphics:ShaderVulkan;
|
||
#ifndef CRAFTER_GRAPHICS_WINDOW_DOM
|
||
import std;
|
||
import :Device;
|
||
import :Types;
|
||
|
||
// ─── BEGIN NVIDIA descriptor-heap AS-read workaround (issue #15 / #7) ─────
|
||
// Remove this whole block (and its call below, Device::workaroundDescriptorHeapAS,
|
||
// and the RTPass push-data) once NVIDIA ships a driver that fixes the
|
||
// VK_EXT_descriptor_heap acceleration-structure read fault.
|
||
//
|
||
// On the affected driver, reading an `accelerationStructureEXT` out of the
|
||
// descriptor heap aborts the device. The build, the heap descriptor write and
|
||
// everything else are correct (proven in #7); only the in-shader heap AS read
|
||
// is broken — buffers/images through the same heap work. Acceleration
|
||
// structures can equally be addressed by their device address, and
|
||
// OpConvertUToAccelerationStructureKHR (which reads no descriptor) sidesteps
|
||
// the faulting path entirely.
|
||
//
|
||
// glslang has no GLSL spelling for that conversion, so we rewrite the compiled
|
||
// SPIR-V at module-load time: every `OpLoad %accelStruct <heap-ptr>` becomes a
|
||
// load of the TLAS device address from a push-constant block followed by
|
||
// OpConvertUToAccelerationStructureKHR. RTPass pushes the active frame's TLAS
|
||
// address into that push constant. Shaders that never touch an acceleration
|
||
// structure (no OpTypeAccelerationStructureKHR) are left untouched.
|
||
//
|
||
// SPIR-V allows at most one push-constant variable per entry point, so we never
|
||
// add a second one: if the shader already declares a push-constant block we
|
||
// append a ulong member (the TLAS address) to the *existing* block and read
|
||
// from there; only shaders with no push constant of their own get a freshly
|
||
// synthesized single-member block. Its byte offset is the offset of that
|
||
// member, returned in PatchResult::tlasPushOffset so the caller (RTPass for the
|
||
// RT pipeline, ComputeShader::Dispatch for a compute pipeline) can feed it to
|
||
// vkCmdPushDataEXT — landing the address exactly where the rewritten load reads
|
||
// it. The offset is per-shader rather than a global: a global is clobbered by
|
||
// whichever shader was patched last and so cannot serve several shaders whose
|
||
// push-constant layouts differ.
|
||
//
|
||
// Exported so tests/PushConstantRewrite can drive Patch() over real compiled
|
||
// SPIR-V and check the result with spirv-val; nothing in the engine calls it
|
||
// from outside this file. Goes away with the rest of the workaround.
|
||
export namespace WorkaroundNvidiaAS {
|
||
// SPIR-V numeric opcodes / enums used below.
|
||
enum : std::uint32_t {
|
||
OpEntryPoint = 15, OpCapability = 17,
|
||
OpTypeInt = 21, OpTypeFloat = 22, OpTypeVector = 23, OpTypeMatrix = 24,
|
||
OpTypeArray = 28, OpTypeStruct = 30, OpTypePointer = 32,
|
||
OpConstant = 43, OpVariable = 59, OpLoad = 61, OpAccessChain = 65,
|
||
OpDecorate = 71, OpMemberDecorate = 72,
|
||
OpConvertUToAccelerationStructureKHR = 4447,
|
||
OpTypeAccelerationStructureKHR = 5341,
|
||
CapabilityInt64 = 11,
|
||
StorageClassPushConstant = 9,
|
||
DecorationBlock = 2, DecorationRowMajor = 4, DecorationMatrixStride = 7,
|
||
DecorationArrayStride = 6, DecorationOffset = 35,
|
||
};
|
||
|
||
inline bool IsAnnotation(std::uint32_t op) {
|
||
// OpDecorate/OpMemberDecorate/OpDecorationGroup/OpGroupDecorate/
|
||
// OpGroupMemberDecorate/OpDecorateId/OpDecorate(Member)String.
|
||
return op == 71 || op == 72 || op == 73 || op == 74 || op == 75
|
||
|| op == 332 || op == 5632 || op == 5633;
|
||
}
|
||
|
||
using Instr = std::vector<std::uint32_t>;
|
||
|
||
inline std::uint32_t AlignUp(std::uint32_t v, std::uint32_t a) {
|
||
return (v + a - 1u) & ~(a - 1u);
|
||
}
|
||
|
||
// Outcome of patching one shader module. `patched` is true only when the
|
||
// shader read an acceleration structure and was rewritten; `tlasPushOffset`
|
||
// is then the byte offset of the TLAS-address member in the (possibly
|
||
// pre-existing) push-constant block the caller must write.
|
||
struct PatchResult {
|
||
bool patched = false;
|
||
std::uint32_t tlasPushOffset = 0;
|
||
};
|
||
|
||
inline PatchResult Patch(std::vector<std::uint32_t>& words) {
|
||
if (words.size() < 5) return {}; // not a SPIR-V module we understand.
|
||
|
||
// Split header (5 words) from the instruction stream.
|
||
std::uint32_t bound = words[3];
|
||
std::vector<Instr> instrs;
|
||
for (std::size_t i = 5; i < words.size();) {
|
||
std::uint32_t len = words[i] >> 16;
|
||
if (len == 0 || i + len > words.size()) return {}; // malformed — bail.
|
||
instrs.emplace_back(words.begin() + i, words.begin() + i + len);
|
||
i += len;
|
||
}
|
||
|
||
// ── Scan for the AS type, reusable int/long types+constants, any
|
||
// existing push-constant block, the type/decoration/constant tables
|
||
// needed to size that block, and the section boundaries to insert into.
|
||
std::uint32_t asTypeId = 0, ulongTypeId = 0, uintTypeId = 0, uintZeroId = 0;
|
||
std::uint32_t existingPcVarId = 0, existingPcStructId = 0, existingPtrUlongId = 0;
|
||
std::size_t lastCapIdx = 0, lastAnnotIdx = 0, firstFuncIdx = instrs.size();
|
||
std::size_t entryIdx = instrs.size();
|
||
std::map<std::uint32_t, const Instr*> typeInstr; // type-result-id → defining instr
|
||
std::map<std::uint32_t, std::uint32_t> constU32; // OpConstant id → 32-bit value
|
||
std::map<std::uint32_t, std::uint32_t> uintConstByValue; // uint value → OpConstant id
|
||
std::map<std::uint32_t, std::uint32_t> arrayStride; // array type id → ArrayStride
|
||
std::map<std::uint64_t, std::uint32_t> memberOffset; // (struct<<32|idx) → Offset
|
||
std::map<std::uint64_t, std::uint32_t> memberMatStride; // (struct<<32|idx) → MatrixStride
|
||
std::set<std::uint64_t> memberRowMajor; // (struct<<32|idx) decorated RowMajor
|
||
std::map<std::uint32_t, std::uint32_t> ptrPointee; // pointer type id → pointee type id
|
||
for (std::size_t k = 0; k < instrs.size(); ++k) {
|
||
const Instr& in = instrs[k];
|
||
std::uint32_t op = in[0] & 0xFFFFu;
|
||
switch (op) {
|
||
case OpTypeAccelerationStructureKHR: asTypeId = in[1]; typeInstr[in[1]] = ∈ break;
|
||
case OpTypeInt:
|
||
if (in[2] == 64 && in[3] == 0) ulongTypeId = in[1];
|
||
else if (in[2] == 32 && in[3] == 0) uintTypeId = in[1];
|
||
typeInstr[in[1]] = ∈
|
||
break;
|
||
case OpTypeFloat: case OpTypeVector: case OpTypeMatrix:
|
||
case OpTypeArray: case OpTypeStruct:
|
||
typeInstr[in[1]] = ∈
|
||
break;
|
||
case OpTypePointer:
|
||
typeInstr[in[1]] = ∈ ptrPointee[in[1]] = in[3];
|
||
if (in[2] == StorageClassPushConstant && in[3] == ulongTypeId)
|
||
existingPtrUlongId = in[1];
|
||
break;
|
||
case OpConstant:
|
||
if (in.size() >= 4) constU32[in[2]] = in[3];
|
||
if (uintTypeId && in[1] == uintTypeId && in.size() >= 4) {
|
||
uintConstByValue.emplace(in[3], in[2]);
|
||
if (in[3] == 0) uintZeroId = in[2];
|
||
}
|
||
break;
|
||
case OpVariable:
|
||
if (in[3] == StorageClassPushConstant) {
|
||
existingPcVarId = in[2];
|
||
existingPcStructId = ptrPointee.count(in[1]) ? ptrPointee[in[1]] : 0;
|
||
}
|
||
break;
|
||
case OpDecorate:
|
||
if (in.size() >= 4 && in[2] == DecorationArrayStride) arrayStride[in[1]] = in[3];
|
||
break;
|
||
case OpMemberDecorate: {
|
||
std::uint64_t key = (static_cast<std::uint64_t>(in[1]) << 32) | in[2];
|
||
if (in.size() >= 5 && in[3] == DecorationOffset) memberOffset[key] = in[4];
|
||
if (in.size() >= 5 && in[3] == DecorationMatrixStride) memberMatStride[key] = in[4];
|
||
if (in.size() >= 4 && in[3] == DecorationRowMajor) memberRowMajor.insert(key);
|
||
break;
|
||
}
|
||
case OpCapability: lastCapIdx = k; break;
|
||
case OpEntryPoint: if (entryIdx == instrs.size()) entryIdx = k; break;
|
||
default: break;
|
||
}
|
||
if (IsAnnotation(op)) lastAnnotIdx = k;
|
||
if (op == 54 /*OpFunction*/ && firstFuncIdx == instrs.size()) firstFuncIdx = k;
|
||
}
|
||
|
||
if (asTypeId == 0) return {}; // shader never reads an acceleration structure.
|
||
|
||
// Set on whichever path runs below; returned to the caller.
|
||
std::uint32_t tlasPushOffset = 0;
|
||
|
||
auto newId = [&] { return bound++; };
|
||
auto mk = [](std::initializer_list<std::uint32_t> ops) {
|
||
Instr in(ops);
|
||
in[0] = static_cast<std::uint32_t>(in.size() << 16) | (in[0] & 0xFFFFu);
|
||
return in;
|
||
};
|
||
|
||
// Byte footprint of a type, honouring the explicit Array/Matrix strides
|
||
// glslang emits so the result is correct under both scalar and std140
|
||
// block layout. Used only to find where an existing push block ends.
|
||
std::function<std::uint32_t(std::uint32_t)> footprint =
|
||
[&](std::uint32_t tid) -> std::uint32_t {
|
||
auto it = typeInstr.find(tid);
|
||
if (it == typeInstr.end()) return 0;
|
||
const Instr& t = *it->second;
|
||
switch (t[0] & 0xFFFFu) {
|
||
case OpTypeInt: case OpTypeFloat: return t[2] / 8u;
|
||
case OpTypeVector: return t[3] * footprint(t[2]);
|
||
case OpTypeMatrix: return t[3] * footprint(t[2]); // cols × column-vec
|
||
case OpTypeArray: {
|
||
std::uint32_t len = constU32.count(t[3]) ? constU32[t[3]] : 0;
|
||
std::uint32_t stride = arrayStride.count(tid) ? arrayStride[tid]
|
||
: footprint(t[2]);
|
||
return len * stride;
|
||
}
|
||
case OpTypeStruct: {
|
||
std::uint32_t end = 0;
|
||
for (std::size_t m = 2; m < t.size(); ++m) {
|
||
std::uint32_t idx = static_cast<std::uint32_t>(m - 2);
|
||
std::uint64_t key = (static_cast<std::uint64_t>(t[1]) << 32) | idx;
|
||
std::uint32_t off = memberOffset.count(key) ? memberOffset[key] : 0;
|
||
std::uint32_t sz;
|
||
auto mt = typeInstr.find(t[m]);
|
||
if (mt != typeInstr.end() && (mt->second->at(0) & 0xFFFFu) == OpTypeMatrix
|
||
&& memberMatStride.count(key)) {
|
||
// MatrixStride separates the columns, or the rows
|
||
// of a RowMajor member: as many as the column
|
||
// type has components.
|
||
const Instr& matrix = *mt->second;
|
||
std::uint32_t vectors = matrix[3];
|
||
if (memberRowMajor.count(key)) {
|
||
auto column = typeInstr.find(matrix[2]);
|
||
if (column != typeInstr.end()) vectors = (*column->second)[3];
|
||
}
|
||
sz = memberMatStride[key] * vectors;
|
||
} else {
|
||
sz = footprint(t[m]);
|
||
}
|
||
end = std::max(end, off + sz);
|
||
}
|
||
return end;
|
||
}
|
||
case OpTypePointer: return 8;
|
||
default: return 0;
|
||
}
|
||
};
|
||
|
||
bool merge = existingPcVarId != 0 && existingPcStructId != 0
|
||
&& typeInstr.count(existingPcStructId)
|
||
&& (typeInstr[existingPcStructId]->at(0) & 0xFFFFu) == OpTypeStruct;
|
||
|
||
// ── Synthesize/ensure the int/long types and constants we need, reusing
|
||
// any the module already defines (SPIR-V forbids duplicate type defs).
|
||
std::vector<Instr> typeDefs;
|
||
if (uintTypeId == 0) { uintTypeId = newId(); typeDefs.push_back(mk({OpTypeInt, uintTypeId, 32, 0})); }
|
||
if (ulongTypeId == 0) { ulongTypeId = newId(); typeDefs.push_back(mk({OpTypeInt, ulongTypeId, 64, 0})); }
|
||
|
||
std::uint32_t pcVarId, ptrPushUlongId, memberIdxConstId, memberIdx;
|
||
std::vector<Instr> decorations;
|
||
|
||
if (merge) {
|
||
// Append a ulong member to the user's existing block; read from it.
|
||
pcVarId = existingPcVarId;
|
||
const Instr* structInstr = typeInstr[existingPcStructId];
|
||
memberIdx = static_cast<std::uint32_t>(structInstr->size() - 2);
|
||
tlasPushOffset = AlignUp(footprint(existingPcStructId), 8);
|
||
|
||
ptrPushUlongId = existingPtrUlongId;
|
||
if (ptrPushUlongId == 0) {
|
||
ptrPushUlongId = newId();
|
||
typeDefs.push_back(mk({OpTypePointer, ptrPushUlongId, StorageClassPushConstant, ulongTypeId}));
|
||
}
|
||
// Member index constant for the access chain — reuse an existing
|
||
// uint constant of the right value, else mint one (must be an
|
||
// integer constant, so only uint-typed ones qualify for reuse).
|
||
auto found = uintConstByValue.find(memberIdx);
|
||
if (found != uintConstByValue.end()) {
|
||
memberIdxConstId = found->second;
|
||
} else {
|
||
memberIdxConstId = newId();
|
||
typeDefs.push_back(mk({OpConstant, uintTypeId, memberIdxConstId, memberIdx}));
|
||
}
|
||
decorations.push_back(mk({OpMemberDecorate, existingPcStructId, memberIdx, DecorationOffset, tlasPushOffset}));
|
||
} else {
|
||
// No user push constant — synthesize a fresh single-member block.
|
||
if (uintZeroId == 0) { uintZeroId = newId(); typeDefs.push_back(mk({OpConstant, uintTypeId, uintZeroId, 0})); }
|
||
std::uint32_t pcStructId = newId();
|
||
std::uint32_t ptrPushStructId = newId();
|
||
ptrPushUlongId = newId();
|
||
pcVarId = newId();
|
||
typeDefs.push_back(mk({OpTypeStruct, pcStructId, ulongTypeId}));
|
||
typeDefs.push_back(mk({OpTypePointer, ptrPushStructId, StorageClassPushConstant, pcStructId}));
|
||
typeDefs.push_back(mk({OpTypePointer, ptrPushUlongId, StorageClassPushConstant, ulongTypeId}));
|
||
typeDefs.push_back(mk({OpVariable, ptrPushStructId, pcVarId, StorageClassPushConstant}));
|
||
decorations.push_back(mk({OpMemberDecorate, pcStructId, 0, DecorationOffset, 0}));
|
||
decorations.push_back(mk({OpDecorate, pcStructId, DecorationBlock}));
|
||
memberIdxConstId = uintZeroId;
|
||
tlasPushOffset = 0;
|
||
}
|
||
|
||
// ── Rewrite each `OpLoad %asType <ptr>` into address-load + convert, and
|
||
// (when merging) append the ulong member to the existing struct type.
|
||
std::vector<Instr> rebuilt;
|
||
rebuilt.reserve(instrs.size() + 8);
|
||
for (Instr in : instrs) {
|
||
std::uint32_t op = in[0] & 0xFFFFu;
|
||
if (op == OpLoad && in[1] == asTypeId) {
|
||
std::uint32_t resultId = in[2];
|
||
std::uint32_t chainId = newId();
|
||
std::uint32_t addrId = newId();
|
||
rebuilt.push_back(mk({OpAccessChain, ptrPushUlongId, chainId, pcVarId, memberIdxConstId}));
|
||
rebuilt.push_back(mk({OpLoad, ulongTypeId, addrId, chainId}));
|
||
rebuilt.push_back(mk({OpConvertUToAccelerationStructureKHR, asTypeId, resultId, addrId}));
|
||
} else {
|
||
if (merge && op == OpTypeStruct && in[1] == existingPcStructId) {
|
||
in.push_back(ulongTypeId);
|
||
in[0] = static_cast<std::uint32_t>(in.size() << 16) | OpTypeStruct;
|
||
}
|
||
rebuilt.push_back(std::move(in));
|
||
}
|
||
}
|
||
instrs.swap(rebuilt);
|
||
|
||
// Recompute structural anchors (the rewrite above shifted indices).
|
||
lastCapIdx = 0; lastAnnotIdx = 0; firstFuncIdx = instrs.size(); entryIdx = instrs.size();
|
||
std::size_t structIdx = instrs.size();
|
||
for (std::size_t k = 0; k < instrs.size(); ++k) {
|
||
std::uint32_t op = instrs[k][0] & 0xFFFFu;
|
||
if (op == OpCapability) lastCapIdx = k;
|
||
if (op == OpEntryPoint && entryIdx == instrs.size()) entryIdx = k;
|
||
if (IsAnnotation(op)) lastAnnotIdx = k;
|
||
if (op == 54 && firstFuncIdx == instrs.size()) firstFuncIdx = k;
|
||
if (merge && op == OpTypeStruct && instrs[k][1] == existingPcStructId) structIdx = k;
|
||
}
|
||
|
||
// The newly-defined types (notably ulong) must precede every use. When
|
||
// merging, the user's struct — now carrying the appended ulong member —
|
||
// already sits in the type section, so the defs go in just before it;
|
||
// for a fresh block the whole bundle can go at the end of the type
|
||
// section (right before the first function).
|
||
std::size_t typeDefsIdx = (merge && structIdx != instrs.size()) ? structIdx : firstFuncIdx;
|
||
|
||
// A freshly synthesized push-constant variable must join the entry
|
||
// point's interface list (required for SPIR-V ≥ 1.4 — raygen is 1.4).
|
||
// A merged-into variable is already used, so it is already listed.
|
||
if (!merge && entryIdx != instrs.size() && words[1] >= 0x00010400u) {
|
||
instrs[entryIdx].push_back(pcVarId);
|
||
instrs[entryIdx][0] = static_cast<std::uint32_t>(instrs[entryIdx].size() << 16)
|
||
| OpEntryPoint;
|
||
}
|
||
|
||
// Insert highest-index-first so earlier anchors stay valid (typeDefsIdx
|
||
// ≥ lastAnnotIdx+1 ≥ lastCapIdx+1 in both the merge and synthesize cases).
|
||
instrs.insert(instrs.begin() + typeDefsIdx, typeDefs.begin(), typeDefs.end());
|
||
instrs.insert(instrs.begin() + lastAnnotIdx + 1, decorations.begin(), decorations.end());
|
||
instrs.insert(instrs.begin() + lastCapIdx + 1, mk({OpCapability, CapabilityInt64}));
|
||
|
||
// ── Reassemble: header (with updated bound) + instruction stream.
|
||
std::vector<std::uint32_t> out(words.begin(), words.begin() + 5);
|
||
out[3] = bound;
|
||
for (const Instr& in : instrs) out.insert(out.end(), in.begin(), in.end());
|
||
words.swap(out);
|
||
|
||
return {true, tlasPushOffset};
|
||
}
|
||
}
|
||
// ─── END NVIDIA descriptor-heap AS-read workaround ────────────────────────
|
||
|
||
export namespace Crafter {
|
||
class VulkanShader {
|
||
public:
|
||
VkSpecializationInfo* specilizationInfo;
|
||
VkShaderStageFlagBits stage;
|
||
std::string entrypoint;
|
||
VkShaderModule shader = VK_NULL_HANDLE;
|
||
// NVIDIA descriptor-heap AS-read workaround (issue #15 / #7): set when
|
||
// this module read an acceleration structure and was rewritten to fetch
|
||
// the TLAS device address from a push constant. `tlasPushOffset` is the
|
||
// byte offset of that member, which whoever records the dispatch
|
||
// (RTPass / ComputeShader) must write with vkCmdPushDataEXT. Per-shader
|
||
// rather than a global because each shader's push-constant layout — and
|
||
// therefore the offset — can differ. Both false/0 on every other driver.
|
||
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();
|
||
}
|
||
// A file that can't be read throws, naming it: carrying on would
|
||
// size the code from a failed tellg() (-1) and die in the
|
||
// allocation, or hand the driver no code at all.
|
||
std::ifstream file(path, std::ios::binary);
|
||
if (!file) {
|
||
throw std::runtime_error(std::format("VulkanShader: could not open {}", path.string()));
|
||
}
|
||
|
||
// Move to the end of the file to determine its size
|
||
file.seekg(0, std::ios::end);
|
||
std::streamsize size = file.tellg();
|
||
file.seekg(0, std::ios::beg);
|
||
if (size <= 0 || size % sizeof(std::uint32_t) != 0) {
|
||
throw std::runtime_error(std::format("VulkanShader: {} is not SPIR-V ({} bytes)", path.string(), size));
|
||
}
|
||
|
||
std::vector<std::uint32_t> spirv(size / sizeof(std::uint32_t));
|
||
|
||
// Read the data into the vector
|
||
if (!file.read(reinterpret_cast<char*>(spirv.data()), size)) {
|
||
throw std::runtime_error(std::format("VulkanShader: could not read {}", path.string()));
|
||
}
|
||
|
||
file.close();
|
||
|
||
if (spirv.size() < 5 || spirv[0] != 0x07230203u) {
|
||
throw std::runtime_error(std::format("VulkanShader: {} is not SPIR-V (no SPIR-V header)", path.string()));
|
||
}
|
||
// Most drivers accept a module whose capability Initialize didn't
|
||
// enable, so a feature the application forgot to ask for would only
|
||
// show on a strict driver or under the validation layer. Checked on
|
||
// the words as compiled, before the rewrite below adds its own Int64.
|
||
Device::CheckShaderCapabilities(spirv, path);
|
||
|
||
// NVIDIA descriptor-heap AS-read workaround (issue #15 / #7).
|
||
// No-op on every other driver and on shaders that don't read an
|
||
// acceleration structure. Remove with the rest of the workaround
|
||
// once a fixed NVIDIA driver ships.
|
||
if (Device::workaroundDescriptorHeapAS) {
|
||
WorkaroundNvidiaAS::PatchResult patch = WorkaroundNvidiaAS::Patch(spirv);
|
||
patchedAS = patch.patched;
|
||
tlasPushOffset = patch.tlasPushOffset;
|
||
}
|
||
|
||
VkShaderModuleCreateInfo module_info{VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO};
|
||
module_info.codeSize = spirv.size() * sizeof(uint32_t);
|
||
module_info.pCode = spirv.data();
|
||
|
||
Device::CheckVkResult(vkCreateShaderModule(Device::device, &module_info, nullptr, &shader));
|
||
}
|
||
|
||
// The module is released through the deferred-deletion queue, so a
|
||
// static VulkanShader makes no Vulkan call at exit. Copies would both
|
||
// release it; a move hands it over.
|
||
VulkanShader(const VulkanShader&) = delete;
|
||
VulkanShader& operator=(const VulkanShader&) = delete;
|
||
VulkanShader(VulkanShader&& other) noexcept
|
||
: specilizationInfo(other.specilizationInfo)
|
||
, stage(other.stage)
|
||
, entrypoint(std::move(other.entrypoint))
|
||
, shader(std::exchange(other.shader, VK_NULL_HANDLE))
|
||
, patchedAS(other.patchedAS)
|
||
, tlasPushOffset(other.tlasPushOffset) {
|
||
}
|
||
VulkanShader& operator=(VulkanShader&& other) noexcept {
|
||
if (this != &other) {
|
||
Device::EnqueueDeletion(shader);
|
||
specilizationInfo = other.specilizationInfo;
|
||
stage = other.stage;
|
||
entrypoint = std::move(other.entrypoint);
|
||
shader = std::exchange(other.shader, VK_NULL_HANDLE);
|
||
patchedAS = other.patchedAS;
|
||
tlasPushOffset = other.tlasPushOffset;
|
||
}
|
||
return *this;
|
||
}
|
||
~VulkanShader() {
|
||
Device::EnqueueDeletion(shader);
|
||
}
|
||
};
|
||
}
|
||
#endif // !CRAFTER_GRAPHICS_WINDOW_DOM
|