b645746c8c
Adds an 8^3 = 512-instance TLAS pick test that shoots one analytically determined ray through a rayQuery=true PlainComputeShader and checks the read-back committed hit (customIndex 484, t 40.75). 512 instances sit in the < 8193 regime that the hardcoded 16384-leaf start used to miss, so the example fails fast if the shim regresses. Verified in Firefox/WebGPU: "[RayQueryPick] PASS". Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
226 lines
10 KiB
C++
226 lines
10 KiB
C++
// RayQueryPick — regression test for the WebGPU software ray-query shim.
|
|
//
|
|
// Builds an 8³ = 512-instance TLAS (well below the 8193 threshold where a
|
|
// hardcoded 16384-leaf TLAS start used to make every rayQuery pick miss —
|
|
// issue #25) and shoots ONE fully-determined ray through a `rayQuery=true`
|
|
// compute shader. The committed hit is read back to the host and checked
|
|
// against the analytically-known answer.
|
|
//
|
|
// The scene also renders through the wavefront RT pipeline (same as
|
|
// RTStress) so the run produces a visible frame, but the pass/fail signal
|
|
// is the console line printed from the read-back pick result.
|
|
//
|
|
// WebGPU/DOM only — the rayQuery shim is the WebGPU software RT path.
|
|
|
|
#ifndef CRAFTER_GRAPHICS_WINDOW_DOM
|
|
int main() { return 0; } // native path uses hardware ray queries
|
|
#else
|
|
|
|
#include <cstdio> // std::fflush / stdout — flush the verdict past _Exit
|
|
|
|
import Crafter.Graphics;
|
|
import Crafter.Math;
|
|
import Crafter.Event;
|
|
import std;
|
|
|
|
using namespace Crafter;
|
|
namespace fs = std::filesystem;
|
|
|
|
namespace {
|
|
constexpr int kGrid = 8; // 8³ = 512 instances (< 8193 ⇒ bug regime)
|
|
constexpr float kSpacing = 2.5f;
|
|
constexpr float kHalf = 0.5f;
|
|
|
|
// Analytically-known target: a -X ray down the (iy=4, iz=4) row hits the
|
|
// cube with the largest X centre (ix=7) first.
|
|
constexpr int kHitX = 7, kHitY = 4, kHitZ = 4;
|
|
constexpr std::uint32_t kExpectedCustomIndex =
|
|
static_cast<std::uint32_t>(((kHitX * kGrid) + kHitY) * kGrid + kHitZ); // 484
|
|
|
|
struct CameraGPU {
|
|
float origin[3]; float pad0;
|
|
float right[3]; float tanHalf;
|
|
float up[3]; float aspect;
|
|
float forward[3]; float pad1;
|
|
};
|
|
static_assert(sizeof(CameraGPU) == 64);
|
|
|
|
// @group(0) push for the pick shader: ray origin + direction.
|
|
struct PickPush {
|
|
float origin[3]; float pad0;
|
|
float dir[3]; float pad1;
|
|
};
|
|
static_assert(sizeof(PickPush) == 32);
|
|
|
|
struct PickResult {
|
|
std::uint32_t hit;
|
|
std::uint32_t instanceCustomIndex;
|
|
std::uint32_t primitiveIndex;
|
|
float tHit;
|
|
};
|
|
static_assert(sizeof(PickResult) == 16);
|
|
}
|
|
|
|
int main() {
|
|
const int instanceCount = kGrid * kGrid * kGrid;
|
|
std::println("[RayQueryPick] grid {}^3 = {} instances (expected hit customIndex {})",
|
|
kGrid, instanceCount, kExpectedCustomIndex);
|
|
|
|
Device::Initialize();
|
|
static Window window(1280, 720, "RayQueryPick");
|
|
auto cmd = window.StartInit();
|
|
|
|
DescriptorHeapWebGPU heap;
|
|
heap.Initialize(/*images*/ 1, /*buffers*/ 2, /*samplers*/ 1);
|
|
|
|
std::array<WebGPUShader, 4> shaders {{
|
|
WebGPUShader(fs::path("raygen.wgsl"), "raygen_main", WebGPURTStage::Raygen),
|
|
WebGPUShader(fs::path("miss.wgsl"), "miss_main", WebGPURTStage::Miss),
|
|
WebGPUShader(fs::path("closesthit.wgsl"), "closesthit_main", WebGPURTStage::ClosestHit),
|
|
WebGPUShader(fs::path("resolve.wgsl"), "resolve_main", WebGPURTStage::Resolve),
|
|
}};
|
|
ShaderBindingTableWebGPU sbt;
|
|
sbt.Init(shaders);
|
|
|
|
std::array<RTShaderGroup, 1> raygenGroups {{ { .type = RTShaderGroupType::General, .generalShader = 0 } }};
|
|
std::array<RTShaderGroup, 1> missGroups {{ { .type = RTShaderGroupType::General, .generalShader = 1 } }};
|
|
std::array<RTShaderGroup, 1> hitGroups {{ { .type = RTShaderGroupType::TrianglesHitGroup, .closestHitShader = 2 } }};
|
|
|
|
std::array<UICustomBinding, 1> bindings {{
|
|
{ .group = 3, .binding = 0, .kind = UICustomBindingKind::Buffer, ._pad = 0, .pushOffset = 0 },
|
|
}};
|
|
|
|
PipelineRTWebGPU pipeline;
|
|
pipeline.Init(cmd, raygenGroups, missGroups, hitGroups, sbt, bindings);
|
|
|
|
// ── Unit cube mesh (8 verts, 12 tris). ────────────────────────────
|
|
static std::array<Vector<float, 3, 3>, 8> verts {{
|
|
{-kHalf, -kHalf, -kHalf}, { kHalf, -kHalf, -kHalf},
|
|
{ kHalf, kHalf, -kHalf}, {-kHalf, kHalf, -kHalf},
|
|
{-kHalf, -kHalf, kHalf}, { kHalf, -kHalf, kHalf},
|
|
{ kHalf, kHalf, kHalf}, {-kHalf, kHalf, kHalf},
|
|
}};
|
|
static std::array<std::uint32_t, 36> indices {{
|
|
0,1,2, 0,2,3, 5,4,7, 5,7,6, 4,0,3, 4,3,7,
|
|
1,5,6, 1,6,2, 4,5,1, 4,1,0, 3,2,6, 3,6,7,
|
|
}};
|
|
static Mesh cube;
|
|
cube.Build(verts, indices, cmd);
|
|
|
|
WebGPUBuffer<CameraGPU, true> cameraBuf;
|
|
cameraBuf.Create(1);
|
|
static std::array<std::uint32_t, 1> userHandles { cameraBuf.handle };
|
|
|
|
// ── Instance grid. ─────────────────────────────────────────────────
|
|
static std::vector<RenderingElement3D> renderers;
|
|
renderers.reserve(static_cast<std::size_t>(instanceCount));
|
|
const float origin0 = -0.5f * static_cast<float>(kGrid - 1) * kSpacing;
|
|
for (int x = 0; x < kGrid; ++x)
|
|
for (int y = 0; y < kGrid; ++y)
|
|
for (int z = 0; z < kGrid; ++z) {
|
|
renderers.emplace_back();
|
|
RenderingElement3D& r = renderers.back();
|
|
auto& tx = r.instance.transform.matrix;
|
|
tx[0][0] = 1; tx[0][1] = 0; tx[0][2] = 0; tx[0][3] = origin0 + float(x) * kSpacing;
|
|
tx[1][0] = 0; tx[1][1] = 1; tx[1][2] = 0; tx[1][3] = origin0 + float(y) * kSpacing;
|
|
tx[2][0] = 0; tx[2][1] = 0; tx[2][2] = 1; tx[2][3] = origin0 + float(z) * kSpacing;
|
|
r.instance.instanceCustomIndex = static_cast<std::uint32_t>(renderers.size() - 1);
|
|
r.instance.mask = 0xFF;
|
|
r.instance.instanceShaderBindingTableRecordOffset = 0;
|
|
r.instance.flags = kRTGeometryInstanceForceOpaque;
|
|
r.instance.accelerationStructureReference = cube.blasAddr;
|
|
RenderingElement3D::Add(&r);
|
|
}
|
|
RenderingElement3D::BuildTLAS(cmd, 0);
|
|
|
|
window.descriptorHeap = &heap;
|
|
window.FinishInit();
|
|
|
|
RTPass rtPass(&pipeline);
|
|
rtPass.handlesPtr = userHandles.data();
|
|
rtPass.handlesCount = static_cast<std::uint32_t>(userHandles.size());
|
|
rtPass.maxDepth = 1;
|
|
window.passes.push_back(&rtPass);
|
|
|
|
// Fixed camera framing the grid from a corner, aimed at the centre.
|
|
{
|
|
const float ext = float(kGrid - 1) * kSpacing;
|
|
Vector<float, 3, 4> pos { ext * 1.4f, ext * 1.0f, ext * 1.4f };
|
|
Vector<float, 3, 4> d { -pos.x, -pos.y, -pos.z };
|
|
const float len = std::sqrt(d.x*d.x + d.y*d.y + d.z*d.z);
|
|
Vector<float, 3, 4> forward { d.x/len, d.y/len, d.z/len };
|
|
Vector<float, 3, 4> worldUp { 0.0f, 1.0f, 0.0f };
|
|
Vector<float, 3, 4> right { forward.y*worldUp.z - forward.z*worldUp.y,
|
|
forward.z*worldUp.x - forward.x*worldUp.z,
|
|
forward.x*worldUp.y - forward.y*worldUp.x };
|
|
const float rLen = std::sqrt(right.x*right.x + right.y*right.y + right.z*right.z);
|
|
right.x /= rLen; right.y /= rLen; right.z /= rLen;
|
|
Vector<float, 3, 4> up { right.y*forward.z - right.z*forward.y,
|
|
right.z*forward.x - right.x*forward.z,
|
|
right.x*forward.y - right.y*forward.x };
|
|
CameraGPU& g = cameraBuf.value[0];
|
|
g.origin[0]=pos.x; g.origin[1]=pos.y; g.origin[2]=pos.z; g.pad0=0;
|
|
g.right[0]=right.x; g.right[1]=right.y; g.right[2]=right.z;
|
|
g.up[0]=up.x; g.up[1]=up.y; g.up[2]=up.z;
|
|
g.forward[0]=forward.x; g.forward[1]=forward.y; g.forward[2]=forward.z;
|
|
g.aspect = float(window.width) / float(window.height);
|
|
g.tanHalf = std::tan(70.0f * 3.14159265f / 360.0f);
|
|
g.pad1 = 0;
|
|
cameraBuf.FlushDevice();
|
|
}
|
|
|
|
// ── rayQuery pick shader + output buffer. ──────────────────────────
|
|
static PlainComputeShader pickShader;
|
|
std::array<UICustomBinding, 1> pickBindings {{
|
|
{ .group = 2, .binding = 0, .kind = UICustomBindingKind::BufferReadWrite, ._pad = 0, .pushOffset = 0 },
|
|
}};
|
|
pickShader.Load(fs::path("rayquery_pick.wgsl"),
|
|
static_cast<std::uint32_t>(sizeof(PickPush)),
|
|
pickBindings, /*rayQuery*/ true);
|
|
|
|
static WebGPUBuffer<PickResult, true> pickBuf;
|
|
pickBuf.Create(1);
|
|
static std::array<std::uint32_t, 1> pickHandles { pickBuf.handle };
|
|
|
|
// The known ray: -X down the (iy,iz) row, far enough out to clear the grid.
|
|
static PickPush push {};
|
|
push.origin[0] = 50.0f;
|
|
push.origin[1] = origin0 + float(kHitY) * kSpacing;
|
|
push.origin[2] = origin0 + float(kHitZ) * kSpacing;
|
|
push.dir[0] = -1.0f; push.dir[1] = 0.0f; push.dir[2] = 0.0f;
|
|
|
|
static int frame = 0;
|
|
static bool dispatched = false;
|
|
static bool reported = false;
|
|
EventListener<void> tick(&window.onBeforeUpdate, [&]() {
|
|
if (reported) return;
|
|
// Let a couple of frames go by so the TLAS build has certainly run.
|
|
if (frame == 2 && !dispatched) {
|
|
pickShader.Dispatch(&push, sizeof(push), pickHandles, 1, 1, 1);
|
|
pickBuf.EnqueueReadback();
|
|
dispatched = true;
|
|
} else if (dispatched && pickBuf.PollReadback()) {
|
|
const PickResult& r = pickBuf.value[0];
|
|
const bool ok = (r.hit == 1u) && (r.instanceCustomIndex == kExpectedCustomIndex);
|
|
std::println("[RayQueryPick] result: hit={} customIndex={} prim={} t={}",
|
|
r.hit, r.instanceCustomIndex, r.primitiveIndex, r.tHit);
|
|
if (ok) {
|
|
std::println("[RayQueryPick] PASS — rayQuery TLAS traversal hit the expected instance");
|
|
} else {
|
|
std::println("[RayQueryPick] FAIL — expected hit=1 customIndex={}, got hit={} customIndex={}",
|
|
kExpectedCustomIndex, r.hit, r.instanceCustomIndex);
|
|
}
|
|
// The render loop runs after main's _Exit, where stdio is never
|
|
// flushed implicitly — push the verdict out explicitly.
|
|
std::fflush(stdout);
|
|
reported = true;
|
|
}
|
|
++frame;
|
|
});
|
|
|
|
window.Render();
|
|
window.StartUpdate();
|
|
window.StartSync();
|
|
return 0;
|
|
}
|
|
#endif
|