//SPDX-License-Identifier: MIT //SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts® // HDRBloom — cross-backend-shaped HDR post-process on the WebGPU/DOM // backend, exercising the primitives added for issue #27: // // 1. rgba16float runtime textures (StorageImage2D) with STORAGE + SAMPLED // usage — the scene + bloom-mip targets. // 2. A write-only StorageTexture binding kind (UICustomBindingKind:: // StorageTexture) so compute passes write those float targets, plus // float-texture sampling via SampledTexture. // 3. PipelineRTWebGPU's RESOLVE writing linear radiance into a user // rgba16float texture (hdrOutputFormat) instead of the canvas. // // Pipeline shape (the same one a Vulkan bloom would use): // RT → linear rgba16float scene // threshold (compute, sample float → write float) // blur (compute, sample float → write float) // composite (UI custom shader: scene + bloom → tonemap+gamma → canvas) // // The threshold/blur passes run from onBeforeUpdate so each lands on its own // queue submit — WebGPU's per-submit ordering gives the storage-write → // sampled-read barrier the chain needs (there is no barrier between // dispatches within one compute pass). The composite runs in-frame as a UI // custom shader so it owns the canvas ping-pong. Bloom is therefore one // frame behind the sharp scene, which is imperceptible for this static view. // // WebGPU/DOM only — the wavefront tracer is the WebGPU software RT path. #ifndef CRAFTER_GRAPHICS_WINDOW_DOM int main() { return 0; } // native bloom is wireable today (see issue gap 4) #else #include // offsetof import Crafter.Graphics; import Crafter.Math; import Crafter.Event; import std; using namespace Crafter; namespace fs = std::filesystem; namespace { constexpr int kGrid = 3; constexpr float kSpacing = 2.5f; constexpr float kHalf = 0.5f; 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); struct Dim { std::uint32_t w, h, _0, _1; }; // Composite push: standard header + the three heap slots the UI custom // shader's group(2) bindings resolve through. struct CompositePush { UIDispatchHeader hdr; std::uint32_t hdrSlot; std::uint32_t bloomSlot; std::uint32_t sampSlot; std::uint32_t _pad; }; } int main() { Device::Initialize(); static Window window(1280, 720, "HDRBloom"); auto cmd = window.StartInit(); DescriptorHeapWebGPU heap; heap.Initialize(/*images*/ 4, /*buffers*/ 4, /*samplers*/ 2); window.descriptorHeap = &heap; const std::uint16_t W = static_cast(window.width); const std::uint16_t H = static_cast(window.height); // ── RT pipeline: HDR output (RESOLVE → rgba16float) ──────────────── std::array 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), }}; ShaderBindingTableWebGPU sbt; sbt.Init(shaders); std::array raygenGroups {{ { .type = RTShaderGroupType::General, .generalShader = 0 } }}; std::array missGroups {{ { .type = RTShaderGroupType::General, .generalShader = 1 } }}; std::array hitGroups {{ { .type = RTShaderGroupType::TrianglesHitGroup, .closestHitShader = 2 } }}; std::array rtBindings {{ { .group = 3, .binding = 0, .kind = UICustomBindingKind::Buffer, .pushOffset = 0 }, }}; PipelineRTWebGPU pipeline; pipeline.Init(cmd, raygenGroups, missGroups, hitGroups, sbt, rtBindings, WebGPUTexelFormat::RGBA16Float); // ← RESOLVE writes HDR // ── Unit cube mesh. ──────────────────────────────────────────────── static std::array, 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 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 cameraBuf; cameraBuf.Create(1); static std::array rtHandles { cameraBuf.handle }; static std::vector renderers; renderers.reserve(static_cast(kGrid * kGrid * kGrid)); const float origin0 = -0.5f * static_cast(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(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); // ── HDR scene + bloom mip targets (rgba16float). ─────────────────── StorageImage2D hdrScene; hdrScene.Create(W, H); StorageImage2D bloomA; bloomA.Create(W, H); StorageImage2D bloomB; bloomB.Create(W, H); // Heap slots for the composite's sampled inputs + sampler. ImageSlot hdrSlot = hdrScene.AllocateSlot(heap); ImageSlot bloomSlot = bloomB.AllocateSlot(heap); SamplerSlot sampSlot = AllocateLinearClampSampler(heap); // ── Threshold + blur compute passes. ─────────────────────────────── std::array bloomBindings {{ { .group = 1, .binding = 0, .kind = UICustomBindingKind::SampledTexture, .pushOffset = 0 }, { .group = 1, .binding = 1, .kind = UICustomBindingKind::StorageTexture, .format = static_cast(WebGPUTexelFormat::RGBA16Float), .pushOffset = 0 }, }}; PlainComputeShader threshold; threshold.Load(fs::path("threshold.comp.wgsl"), sizeof(Dim), bloomBindings); PlainComputeShader blur; blur.Load(fs::path("blur.comp.wgsl"), sizeof(Dim), bloomBindings); std::array thresholdHandles { hdrScene.handle, bloomA.handle }; std::array blurHandles { bloomA.handle, bloomB.handle }; // ── Composite UI custom shader. ──────────────────────────────────── UIRenderer ui; ui.Initialize(window, heap, cmd); UICustomBinding compBindings[] = { { .group = 2, .binding = 0, .kind = UICustomBindingKind::SampledTexture, .pushOffset = static_cast(offsetof(CompositePush, hdrSlot)) }, { .group = 2, .binding = 1, .kind = UICustomBindingKind::SampledTexture, .pushOffset = static_cast(offsetof(CompositePush, bloomSlot)) }, { .group = 2, .binding = 2, .kind = UICustomBindingKind::Sampler, .pushOffset = static_cast(offsetof(CompositePush, sampSlot)) }, }; WebGPUComputeShader composite; composite.Load(fs::path("composite.comp.wgsl"), compBindings); window.FinishInit(); // ── Passes: RT first (writes HDR scene), then UI (composite→canvas). RTPass rtPass(&pipeline); rtPass.handlesPtr = rtHandles.data(); rtPass.handlesCount = static_cast(rtHandles.size()); rtPass.maxDepth = 1; // primary rays only rtPass.outTexHandle = hdrScene.handle; // ← RESOLVE target window.passes.push_back(&rtPass); window.passes.push_back(&ui); // ── Static camera framing the grid from a front corner. ──────────── const float ext = float(kGrid - 1) * kSpacing; Vector camPos { ext * 1.1f, ext * 0.8f, ext * 1.6f + 3.0f }; Vector d { -camPos.x, -camPos.y, -camPos.z }; const float dl = std::sqrt(d.x*d.x + d.y*d.y + d.z*d.z); Vector forward { d.x/dl, d.y/dl, d.z/dl }; Vector worldUp { 0.0f, 1.0f, 0.0f }; Vector 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 rl = std::sqrt(right.x*right.x + right.y*right.y + right.z*right.z); right.x /= rl; right.y /= rl; right.z /= rl; Vector 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]=camPos.x; g.origin[1]=camPos.y; g.origin[2]=camPos.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(60.0f * 3.14159265f / 360.0f); g.pad1 = 0; cameraBuf.FlushDevice(); } // ── Bloom prepass: threshold + blur, each its own submit. ────────── EventListener bloomTick(&window.onBeforeUpdate, [&]() { Dim dim { static_cast(window.width), static_cast(window.height), 0, 0 }; const std::uint32_t gx = (window.width + 7u) / 8u; const std::uint32_t gy = (window.height + 7u) / 8u; threshold.Dispatch(&dim, sizeof(dim), thresholdHandles, gx, gy, 1); blur.Dispatch(&dim, sizeof(dim), blurHandles, gx, gy, 1); }); // ── Composite: scene + bloom → tonemap+gamma → canvas. ───────────── EventListener composeSub(&ui.onBuild, [&](UIBuildArgs a) { CompositePush pc { ui.FillHeader(0, 0), 0, 0, 0, 0 }; pc.hdrSlot = static_cast(static_cast(hdrSlot)); pc.bloomSlot = static_cast(static_cast(bloomSlot)); pc.sampSlot = static_cast(static_cast(sampSlot)); const std::uint32_t gx = (window.width + 7u) / 8u; const std::uint32_t gy = (window.height + 7u) / 8u; ui.Dispatch(a.cmd, composite, &pc, sizeof(pc), gx, gy, 1); }); std::println("[HDRBloom] RT→rgba16float→threshold→blur→composite running"); window.Render(); window.StartUpdate(); window.StartSync(); return 0; } #endif