Jorijn van der Graaf
37fe0dc49f
On NVIDIA 610.43.02, selecting a descriptor-heap descriptor with a runtime index in a hit shader lost the device, for storage buffers and sampled images alike, which is why the examples use spec constants there. HeapDynamicIndexHit renders two instances whose closest-hit picks a buffer and a texture by a runtime index: one instance uses the same set across every wave, the other a different set in every other pixel column, so neighbouring lanes select different descriptors. It passes on 615.78.08 and on llvmpipe. On NVIDIA drivers older than 615.78.08 it skips rather than abort the suite. With validation on it also renders in a child process with validation off, since GPU-assisted validation hides the fault. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
415 lines
19 KiB
C++
415 lines
19 KiB
C++
//SPDX-License-Identifier: LGPL-3.0-only
|
|
//SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
|
|
|
|
// Regression test for dynamic descriptor-heap indexing in ray-tracing hit
|
|
// shaders. On NVIDIA 610.43.02, selecting a VK_EXT_descriptor_heap descriptor
|
|
// with a runtime index inside a hit shader lost the device, for storage
|
|
// buffers and sampled images alike (README, "Native RT limitation"), so the
|
|
// examples select hit-shader descriptors through spec constants. This renders
|
|
// two instances of one triangle whose closest-hit picks a storage buffer and a
|
|
// texture by a runtime index: instance 0 the same set everywhere, instance 1 a
|
|
// different set in every other pixel column, so neighbouring lanes of a wave
|
|
// select different descriptors. It reads the frame back and checks every
|
|
// pixel got its own set's buffer red and texture green.
|
|
//
|
|
// The fault fixed in NVIDIA 615.78.08, so on older NVIDIA drivers the test
|
|
// skips instead of aborting the suite. GPU-assisted validation hides the
|
|
// fault (examples/Sponza/README.md), so with CRAFTER_GRAPHICS_VALIDATION set
|
|
// the scene is also rendered in a child process with validation off; the
|
|
// validation check only means something with it set. Needs a live Wayland
|
|
// compositor and a Vulkan RT device; without RT it skips.
|
|
|
|
#include "vulkan/vulkan.h"
|
|
#include <cstddef>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
|
|
// PNG decode for the read-back frame. The library only compiles the writer
|
|
// (Window::SaveFrame); STB_IMAGE_STATIC keeps the reader private to this file.
|
|
#define STB_IMAGE_IMPLEMENTATION
|
|
#define STB_IMAGE_STATIC
|
|
#define STBI_ONLY_PNG
|
|
#include "../../lib/stb_image.h"
|
|
|
|
import Crafter.Graphics;
|
|
import Crafter.Event;
|
|
import Crafter.Math;
|
|
import std;
|
|
|
|
using namespace Crafter;
|
|
namespace fs = std::filesystem;
|
|
|
|
namespace {
|
|
|
|
int failures = 0;
|
|
|
|
void Check(bool ok, std::string_view what) {
|
|
std::println("{} {}", ok ? "PASS" : "FAIL", what);
|
|
// Flushed per line: a driver with the fault aborts the process from
|
|
// inside Render(), and the checks before it should still show.
|
|
std::fflush(stdout);
|
|
if (!ok) ++failures;
|
|
}
|
|
|
|
// The build places the compiled shaders next to the test binary, and the
|
|
// test runner's working directory is not that directory.
|
|
fs::path ExeDir() {
|
|
return fs::read_symlink("/proc/self/exe").parent_path();
|
|
}
|
|
|
|
int RunCommand(const std::string& cmd) {
|
|
int status = std::system(cmd.c_str());
|
|
if (status == -1) return -1;
|
|
return (status & 0x7f) == 0 ? ((status >> 8) & 0xff) : 128 + (status & 0x7f);
|
|
}
|
|
|
|
struct RGBA8 { std::uint8_t r, g, b, a; };
|
|
|
|
struct Frame {
|
|
int width = 0;
|
|
int height = 0;
|
|
std::vector<std::uint8_t> rgba;
|
|
|
|
std::array<std::uint8_t, 3> At(int x, int y) const {
|
|
const std::size_t i = (static_cast<std::size_t>(y) * width + x) * 4;
|
|
return { rgba[i], rgba[i + 1], rgba[i + 2] };
|
|
}
|
|
};
|
|
|
|
Frame LoadFrame(const fs::path& path) {
|
|
Frame frame;
|
|
int channels = 0;
|
|
stbi_uc* pixels = stbi_load(path.string().c_str(), &frame.width, &frame.height, &channels, STBI_rgb_alpha);
|
|
if (pixels != nullptr) {
|
|
frame.rgba.assign(pixels, pixels + static_cast<std::size_t>(frame.width) * frame.height * 4);
|
|
stbi_image_free(pixels);
|
|
}
|
|
return frame;
|
|
}
|
|
|
|
bool Near(std::array<std::uint8_t, 3> pixel, std::array<std::uint8_t, 3> expected) {
|
|
for (std::size_t c = 0; c < 3; ++c) {
|
|
if (std::abs(static_cast<int>(pixel[c]) - static_cast<int>(expected[c])) > 8) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void CheckPixel(const Frame& frame, int x, int y, std::array<std::uint8_t, 3> expected, std::string_view what) {
|
|
const std::array<std::uint8_t, 3> pixel = frame.At(x, y);
|
|
Check(Near(pixel, expected), std::format("{} at ({}, {}) is ({}, {}, {}), expected ({}, {}, {})",
|
|
what, x, y, pixel[0], pixel[1], pixel[2], expected[0], expected[1], expected[2]));
|
|
}
|
|
|
|
// The pixel column world x on the triangles' plane (z = 100, 400 in front of
|
|
// the camera) lands in, for the raygen's 60° vertical field of view.
|
|
int FrameX(float worldX, const Frame& frame) {
|
|
const float aspect = static_cast<float>(frame.width) / static_cast<float>(frame.height);
|
|
const float ndc = worldX / (400.0f * aspect * std::tan(std::numbers::pi_v<float> / 6.0f));
|
|
return static_cast<int>((0.5f + ndc * 0.5f) * static_cast<float>(frame.width));
|
|
}
|
|
|
|
// Spec constants of the closest-hit, matching dynidx-closesthit.glsl.
|
|
struct HitConstants {
|
|
std::uint16_t bufferStart;
|
|
std::uint16_t pad;
|
|
std::uint32_t textureBase;
|
|
std::uint32_t colourBase;
|
|
};
|
|
|
|
// What each descriptor set holds: the red its buffer gives and the green its
|
|
// texture gives.
|
|
constexpr std::array<float, 2> bufferRed = {1.0f, 0.5f};
|
|
constexpr std::array<std::uint8_t, 2> textureGreen = {64, 191};
|
|
constexpr std::array<std::array<std::uint8_t, 3>, 2> setColour = {{{255, 64, 0}, {128, 191, 0}}};
|
|
|
|
// NVIDIA's proprietary driver packs its version into 10.8.8.6 bits.
|
|
std::tuple<std::uint32_t, std::uint32_t, std::uint32_t> NvidiaVersion() {
|
|
const std::uint32_t v = Device::deviceProperties.driverVersion;
|
|
return {(v >> 22) & 0x3ff, (v >> 14) & 0xff, (v >> 6) & 0xff};
|
|
}
|
|
|
|
// Renders the scene into `out` and checks the pixels. Device::Initialize has
|
|
// already run. Returns the number of failed checks.
|
|
int RenderScene(const fs::path& out) {
|
|
const int failuresBefore = failures;
|
|
Device::validationErrorCount = 0;
|
|
|
|
Window window(640, 360, "HeapDynamicIndexHit test");
|
|
VkCommandBuffer cmd = window.StartInit();
|
|
|
|
// Image slots: 0 = the frame's swapchain image, 1-2 = the textures.
|
|
// Buffer slots: 0 = the TLAS, 1-2 = the colour buffers. Sampler slot 0.
|
|
DescriptorHeapVulkan descriptorHeap;
|
|
descriptorHeap.Initialize(3, 3, 1);
|
|
|
|
VkSpecializationMapEntry raygenEntry = { .constantID = 0, .offset = 0, .size = sizeof(std::uint16_t) };
|
|
VkSpecializationInfo raygenSpec = {
|
|
.mapEntryCount = 1,
|
|
.pMapEntries = &raygenEntry,
|
|
.dataSize = sizeof(std::uint16_t),
|
|
.pData = &descriptorHeap.bufferStartElement,
|
|
};
|
|
HitConstants hitConstants = {
|
|
.bufferStart = descriptorHeap.bufferStartElement,
|
|
.pad = 0,
|
|
.textureBase = 1,
|
|
.colourBase = 1,
|
|
};
|
|
std::array<VkSpecializationMapEntry, 3> hitEntries {{
|
|
{ .constantID = 0, .offset = offsetof(HitConstants, bufferStart), .size = sizeof(std::uint16_t) },
|
|
{ .constantID = 1, .offset = offsetof(HitConstants, textureBase), .size = sizeof(std::uint32_t) },
|
|
{ .constantID = 2, .offset = offsetof(HitConstants, colourBase), .size = sizeof(std::uint32_t) },
|
|
}};
|
|
VkSpecializationInfo hitSpec = {
|
|
.mapEntryCount = static_cast<std::uint32_t>(hitEntries.size()),
|
|
.pMapEntries = hitEntries.data(),
|
|
.dataSize = sizeof(HitConstants),
|
|
.pData = &hitConstants,
|
|
};
|
|
|
|
const fs::path dir = ExeDir();
|
|
std::array<VulkanShader, 3> shaders{{
|
|
{dir / "dynidx-raygen.spv", "main", VK_SHADER_STAGE_RAYGEN_BIT_KHR, &raygenSpec},
|
|
{dir / "dynidx-miss.spv", "main", VK_SHADER_STAGE_MISS_BIT_KHR, nullptr},
|
|
{dir / "dynidx-closesthit.spv", "main", VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, &hitSpec},
|
|
}};
|
|
ShaderBindingTableVulkan shaderTable;
|
|
shaderTable.Init(shaders);
|
|
|
|
std::array<VkRayTracingShaderGroupCreateInfoKHR, 1> raygenGroups {{ {
|
|
.sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
|
|
.type = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR,
|
|
.generalShader = 0, .closestHitShader = VK_SHADER_UNUSED_KHR,
|
|
.anyHitShader = VK_SHADER_UNUSED_KHR, .intersectionShader = VK_SHADER_UNUSED_KHR,
|
|
} }};
|
|
std::array<VkRayTracingShaderGroupCreateInfoKHR, 1> missGroups {{ {
|
|
.sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
|
|
.type = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR,
|
|
.generalShader = 1, .closestHitShader = VK_SHADER_UNUSED_KHR,
|
|
.anyHitShader = VK_SHADER_UNUSED_KHR, .intersectionShader = VK_SHADER_UNUSED_KHR,
|
|
} }};
|
|
std::array<VkRayTracingShaderGroupCreateInfoKHR, 1> hitGroups {{ {
|
|
.sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
|
|
.type = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR,
|
|
.generalShader = VK_SHADER_UNUSED_KHR, .closestHitShader = 2,
|
|
.anyHitShader = VK_SHADER_UNUSED_KHR, .intersectionShader = VK_SHADER_UNUSED_KHR,
|
|
} }};
|
|
PipelineRTVulkan pipeline;
|
|
pipeline.Init(cmd, raygenGroups, missGroups, hitGroups, shaderTable);
|
|
|
|
// One triangle, two instances 100 units either side of the centre line.
|
|
Mesh triangleMesh;
|
|
std::array<Vector<float, 3, 3>, 3> verts {{{-75, -75, 100}, {0, 75, 100}, {75, -75, 100}}};
|
|
std::array<std::uint32_t, 3> index {{2, 1, 0}};
|
|
triangleMesh.Build(verts, index, cmd);
|
|
|
|
std::array<RenderingElement3D, 2> renderers{};
|
|
for (std::uint32_t i = 0; i < renderers.size(); ++i) {
|
|
renderers[i].instance = {
|
|
.instanceCustomIndex = i,
|
|
.mask = 0xFF,
|
|
.instanceShaderBindingTableRecordOffset = 0,
|
|
.flags = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR,
|
|
.accelerationStructureReference = triangleMesh.blasAddr,
|
|
};
|
|
MatrixRowMajor<float, 4, 3, 1>::Translation(i == 0 ? -100.0f : 100.0f, 0.0f, 0.0f)
|
|
.Store(reinterpret_cast<float*>(renderers[i].instance.transform.matrix));
|
|
RenderingElement3D::Add(&renderers[i]);
|
|
}
|
|
for (std::uint32_t f = 0; f < Window::numFrames; ++f) RenderingElement3D::BuildTLAS(cmd, f);
|
|
|
|
// Per descriptor set: a 2x2 texture whose green the hit shader reads, and
|
|
// a one-vec4 buffer whose red it reads.
|
|
std::array<Image2D<RGBA8>, 2> textures;
|
|
std::array<VulkanBuffer<float, true>, 2> colourBuffers;
|
|
for (std::size_t i = 0; i < textures.size(); ++i) {
|
|
textures[i].Create(2, 2, 1, cmd, VK_FORMAT_R8G8B8A8_UNORM,
|
|
VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
|
|
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
|
|
for (std::size_t p = 0; p < 4; ++p) textures[i].buffer.value[p] = {0, textureGreen[i], 0, 255};
|
|
textures[i].Update(cmd, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
|
|
|
|
colourBuffers[i].Create(VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
|
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, 4);
|
|
colourBuffers[i].value[0] = bufferRed[i];
|
|
colourBuffers[i].value[1] = 0.0f;
|
|
colourBuffers[i].value[2] = 0.0f;
|
|
colourBuffers[i].value[3] = 1.0f;
|
|
colourBuffers[i].FlushDevice();
|
|
}
|
|
|
|
window.FinishInit();
|
|
|
|
auto imgSlots = descriptorHeap.AllocateImageSlots(3);
|
|
auto bufSlots = descriptorHeap.AllocateBufferSlots(3);
|
|
auto samplerSlots = descriptorHeap.AllocateSamplerSlots(1);
|
|
|
|
std::array<VkImageViewCreateInfo, 2> textureViews{};
|
|
std::array<VkImageDescriptorInfoEXT, 2> textureInfos{};
|
|
std::array<VkDeviceAddressRangeKHR, 2> colourRanges{};
|
|
for (std::size_t i = 0; i < 2; ++i) {
|
|
textureViews[i] = {
|
|
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
|
|
.image = textures[i].image,
|
|
.viewType = VK_IMAGE_VIEW_TYPE_2D,
|
|
.format = VK_FORMAT_R8G8B8A8_UNORM,
|
|
.subresourceRange = { .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .baseMipLevel = 0,
|
|
.levelCount = 1, .baseArrayLayer = 0, .layerCount = 1 },
|
|
};
|
|
textureInfos[i] = {
|
|
.sType = VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT,
|
|
.pView = &textureViews[i],
|
|
.layout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
|
|
};
|
|
colourRanges[i] = { .address = colourBuffers[i].address, .size = 4 * sizeof(float) };
|
|
}
|
|
|
|
// Written again whenever the swapchain is recreated, since the output
|
|
// image descriptors point at its images.
|
|
auto writeDescriptors = [&] {
|
|
std::array<VkDeviceAddressRangeKHR, Window::numFrames> tlasRanges{};
|
|
std::array<VkImageDescriptorInfoEXT, Window::numFrames> outInfos{};
|
|
std::vector<VkResourceDescriptorInfoEXT> resources;
|
|
std::vector<VkHostAddressRangeEXT> destinations;
|
|
auto add = [&](std::uint32_t f, VkResourceDescriptorInfoEXT resource, std::uint32_t offset, std::uint32_t size) {
|
|
resources.push_back(resource);
|
|
destinations.push_back({ .address = descriptorHeap.resourceHeap[f].value + offset, .size = size });
|
|
};
|
|
const std::uint32_t imageSize = Device::descriptorHeapProperties.imageDescriptorSize;
|
|
const std::uint32_t bufferSize = Device::descriptorHeapProperties.bufferDescriptorSize;
|
|
for (std::uint32_t f = 0; f < Window::numFrames; ++f) {
|
|
tlasRanges[f] = { .address = RenderingElement3D::tlases[f].address };
|
|
outInfos[f] = {
|
|
.sType = VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT,
|
|
.pView = &window.imageViews[f],
|
|
.layout = VK_IMAGE_LAYOUT_GENERAL,
|
|
};
|
|
add(f, { .sType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT,
|
|
.type = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR,
|
|
.data = { .pAddressRange = &tlasRanges[f] } },
|
|
descriptorHeap.BufferByteOffset(bufSlots.firstElement), bufferSize);
|
|
add(f, { .sType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT,
|
|
.type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE,
|
|
.data = { .pImage = &outInfos[f] } },
|
|
descriptorHeap.ImageByteOffset(imgSlots.firstElement), imageSize);
|
|
for (std::uint16_t i = 0; i < 2; ++i) {
|
|
add(f, { .sType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT,
|
|
.type = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
|
|
.data = { .pImage = &textureInfos[i] } },
|
|
descriptorHeap.ImageByteOffset(imgSlots.firstElement + 1 + i), imageSize);
|
|
add(f, { .sType = VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT,
|
|
.type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
|
|
.data = { .pAddressRange = &colourRanges[i] } },
|
|
descriptorHeap.BufferByteOffset(bufSlots.firstElement + 1 + i), bufferSize);
|
|
}
|
|
}
|
|
Device::vkWriteResourceDescriptorsEXT(Device::device, static_cast<std::uint32_t>(resources.size()),
|
|
resources.data(), destinations.data());
|
|
for (auto& heap : descriptorHeap.resourceHeap) heap.FlushDevice();
|
|
};
|
|
writeDescriptors();
|
|
EventListener<void> resizeListener(&window.onResize, writeDescriptors);
|
|
|
|
VkSamplerCreateInfo samplerInfo = {
|
|
.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
|
|
.magFilter = VK_FILTER_NEAREST,
|
|
.minFilter = VK_FILTER_NEAREST,
|
|
.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST,
|
|
.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
|
|
.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
|
|
.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
|
|
.maxLod = VK_LOD_CLAMP_NONE,
|
|
};
|
|
std::array<VkSamplerCreateInfo, Window::numFrames> samplerInfos{};
|
|
std::array<VkHostAddressRangeEXT, Window::numFrames> samplerDestinations{};
|
|
for (std::uint32_t f = 0; f < Window::numFrames; ++f) {
|
|
samplerInfos[f] = samplerInfo;
|
|
samplerDestinations[f] = {
|
|
.address = descriptorHeap.samplerHeap[f].value + descriptorHeap.SamplerByteOffset(samplerSlots.firstElement),
|
|
.size = Device::descriptorHeapProperties.samplerDescriptorSize,
|
|
};
|
|
}
|
|
Device::vkWriteSamplerDescriptorsEXT(Device::device, Window::numFrames, samplerInfos.data(), samplerDestinations.data());
|
|
for (auto& heap : descriptorHeap.samplerHeap) heap.FlushDevice();
|
|
|
|
window.descriptorHeap = &descriptorHeap;
|
|
RTPass rtPass(&pipeline);
|
|
window.passes.push_back(&rtPass);
|
|
|
|
// More frames than are in flight, so every per-frame heap copy is read at
|
|
// least once. A device loss here throws out of Render().
|
|
for (int i = 0; i < Window::numFrames * 2; ++i) window.Render();
|
|
Device::CheckVkResult(vkQueueWaitIdle(Device::queue));
|
|
|
|
// Counted before the capture: SaveFrame reads back an image that has
|
|
// already been handed to the presentation engine, which the validation
|
|
// layer reports on its own.
|
|
if (std::getenv("CRAFTER_GRAPHICS_VALIDATION") != nullptr) {
|
|
Check(Device::validationErrorCount == 0,
|
|
std::format("no Vulkan validation errors while rendering ({} seen)", Device::validationErrorCount));
|
|
}
|
|
|
|
window.SaveFrame(out);
|
|
Device::CheckVkResult(vkQueueWaitIdle(Device::queue));
|
|
const Frame frame = LoadFrame(out);
|
|
Check(!frame.rgba.empty(), "the frame was read back");
|
|
if (!frame.rgba.empty()) {
|
|
const int y = frame.height / 2;
|
|
// An even column then the odd one next to it, in each triangle.
|
|
const int left = FrameX(-100.0f, frame) & ~1;
|
|
const int right = FrameX(100.0f, frame) & ~1;
|
|
CheckPixel(frame, left, y, setColour[0], "instance 0, even column (set 0)");
|
|
CheckPixel(frame, left + 1, y, setColour[0], "instance 0, odd column (set 0)");
|
|
CheckPixel(frame, right, y, setColour[1], "instance 1, even column (set 1)");
|
|
CheckPixel(frame, right + 1, y, setColour[0], "instance 1, odd column (set 0)");
|
|
CheckPixel(frame, frame.width / 2, y, {0, 0, 255}, "miss between the triangles");
|
|
CheckPixel(frame, frame.width / 20, frame.height / 10, {0, 0, 255}, "miss in the corner");
|
|
}
|
|
|
|
for (RenderingElement3D& renderer : renderers) RenderingElement3D::Remove(&renderer);
|
|
return failures - failuresBefore;
|
|
}
|
|
|
|
// A fresh directory for the read-back frames, so a frame left by an earlier
|
|
// run can't stand in for one this run failed to write.
|
|
fs::path OutputDir() {
|
|
const fs::path dir = fs::temp_directory_path() / "crafter-heap-dynamic-index-hit";
|
|
std::error_code ec;
|
|
fs::remove_all(dir, ec);
|
|
fs::create_directories(dir);
|
|
return dir;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
int main(int argc, char** argv) {
|
|
Device::Initialize();
|
|
if (!Device::rayTracingSupported) {
|
|
std::println("SKIP no Vulkan ray-tracing device");
|
|
return 77;
|
|
}
|
|
if (Device::driverProperties.driverID == VK_DRIVER_ID_NVIDIA_PROPRIETARY
|
|
&& NvidiaVersion() < std::tuple(615u, 78u, 8u)) {
|
|
const auto [major, minor, patch] = NvidiaVersion();
|
|
std::println("SKIP NVIDIA {}.{:02}.{:02} loses the device on this (fixed in 615.78.08)", major, minor, patch);
|
|
return 77;
|
|
}
|
|
|
|
// `--render <png>`: the child run, rendering as configured.
|
|
if (argc == 3 && std::string_view(argv[1]) == "--render") {
|
|
RenderScene(argv[2]);
|
|
return failures == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
|
|
}
|
|
|
|
const fs::path dir = OutputDir();
|
|
if (std::getenv("CRAFTER_GRAPHICS_VALIDATION") != nullptr) {
|
|
const fs::path exe = fs::read_symlink("/proc/self/exe");
|
|
const int exit = RunCommand(std::format("env -u CRAFTER_GRAPHICS_VALIDATION '{}' --render '{}'",
|
|
exe.string(), (dir / "unvalidated.png").string()));
|
|
Check(exit == 0, std::format("the scene renders with validation off (exit {})", exit));
|
|
}
|
|
RenderScene(dir / "frame.png");
|
|
|
|
std::println("{}", failures == 0 ? "all checks passed" : "check(s) failed");
|
|
return failures == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
|
|
}
|