Add test/Fixtures.h with an inline openGfxWindow() (same signature as the
16 per-file copies, plus EVENGINE_TEST_VIEW_W/H overrides for CI), a RAII
GfxFixture, and a TempDir helper. Migrate all 16 test files that hand-rolled
openGfxWindow to use the shared helper; windowed GPU tests now override their
view size from env vars instead of editing each file.
Linux CI (Mesa lavapipe) shows exactly one silhouette pixel at 0.0889 luma
delta (max) between the forward pass and the visibility-buffer resolve, while
mean stays 0.00000 and 172799/172800 samples are within 0.05. The old
over005==0 assertion was too strict for cross-driver rasterization rounding.
Allow a handful of isolated edge pixels (maxDelta < 0.1, over0.08 <= 4) while
keeping the mean-delta guard. Reproduced and verified in WSL (lavapipe):
max=0.0889 mean=0.00000, 11/11 GpuDriven tests pass.
The GPU-driven path sampled the white placeholder for every material: the
registerBindlessTexture2D/Cube calls were lost when the backend split into
per-TU files, so textureSlots stayed kInvalid and shaders fell back to slot 0.
Restore registration in newTexture/newCubemap/replaceTexturePixels/releaseTexture,
and registerMeshRecord at all mesh upload paths (it was only lazy at draw time).
The parity tests were also silently passing: zeroerr CHECK failures only warn,
so maxDelta<0.03 was 'passing' at 0.46. Convert the enforcement assertions to
REQUIRE and add three larger scenes:
- 100-object grid forward parity (legacy vs GPU-driven): pixel-identical now.
- 36-object occlusion parity (wall + hidden crowd): HZB culls 18/36 while the
image stays pixel-identical to the CPU path.
- 64-object visResolve parity (forward vs visibility-buffer resolve).
vgVisResolve now asserts real REQUIREs; the behind-camera expectation was wrong
(CPU culls before the VG instance is submitted) and HZB occlusion for clusters
is a documented follow-up.
Virtual-geometry assets now render through the main GPU-driven frame instead of
the standalone software-raster experiment:
- Shared VG scene in vulkan::Graphics: pooled positions/triangles/clusters +
per-cluster asset ids + per-slot visible list / indirect commands / asset
models + materials. Meshes attach an asset via gpuDrivenVgAttachToMesh;
GpuMeshRecord.vgAssetId routes them out of the instance chain.
- vg_main_cull.comp runs in the main frame's compute section (frustum + HZB
against the per-asset model) and emits per-cluster VkDrawIndirectCommand
(vertexCount = triCount*3, firstInstance = cluster id).
- Hardware raster: mesh3d_gbuffer_vgvis draws clusters with NO vertex input -
gl_InstanceIndex = cluster, gl_VertexIndex = triangle corner, positions from
the cluster stream; face normals computed from world edges; writes the same
visID/visBary attachments (bit31 marks VG clusters).
- resolve_vis.frag decodes VG clusters: asset -> material, interpolates from
the cluster stream, flat-tint shading via the shared PBR core, writes
gl_FragDepth so later transparent draws depth-test correctly.
- gpu_emit.comp additionally writes non-indexed VkDrawIndirectCommand per
bucket (the 20-byte indexed layout's firstInstance sits at offset 16, which
vkCmdDrawIndirect (16-byte commands) ignores - this was the vis pass showing
only instance 0). The vis pass now draws from that command stream.
- All per-frame bindless updates (vis samplers 15/16, VG bindings 26-29) moved
BEFORE the set is bound to the recording command buffer (no UPDATE_AFTER_BIND;
updating a bound set invalidates the CB - caught by validation).
- drawIndirectCount Vulkan 1.2 feature enabled at device creation; the VG
count buffer carries VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT.
- RenderControl gains the "visResolve" feature flag (the stage-3 resolve path
was previously enabled via an unknown flag that setFeature silently dropped).
Verified: GpuDriven.visResolveParity now genuinely exercises the resolve path
(maxDelta = 0.0 vs forward); GpuDriven.vgVisResolve renders a sphere's clusters
through the main frame (9 visible after frustum+HZB, tint-correct center,
frustum-culled to 0 behind the camera); 19 render tests + 3x suite repeat pass;
validation shows no new VUIDs.
Opaque GPU-driven instances now render through a deferred-style path under the
new "visResolve" render-control flag (1x scene pass):
- GBuffer gains visID (R32G32UI: instance + pooled triangle base) and visBary
(R16G16F) attachments plus a vis render-pass variant and pipeline.
- The vis pass draws the cull chain's indirect commands with NO vertex input:
the vertex shader fetches position/normal/uv from new pooled buffers via
gl_VertexIndex (non-indexed draw reuses the same indirect commands), which
also makes the per-vertex barycentric constants exact (gl_VertexIndex % 3).
Triangle ids are computed in the vertex stage and passed flat, avoiding
gl_PrimitiveID in the fragment (which would require the SPIR-V Geometry
capability / geometryShader feature).
- resolve_vis.frag runs as a fullscreen triangle inside the scene color pass:
it reconstructs world pos / normal / uv from the pool using the barycentrics,
shades with the shared PBR code and writes the opaque depth (gl_FragDepth),
so later hair/transparent draws depth-test correctly.
- New vertex pool (positions/normals/uvs as vec4/vec4/vec2 SSBO arrays +
u32 index pool, host-visible, grow-by-2x with waitIdle); meshes are pooled
lazily at registerMeshRecord and GpuMeshRecord.vertexOffset/indexOffset now
point into the pool. Bindless set1 gains bindings 15/16 (vis samplers) and
18-21 (pool buffers), all rewritten per slot/frame following the safe-point
rule from 8f156a6.
- pbr_shade.glsl extracts the GPU-driven PBR/CSM/cloud/env shading so the
forward path and the resolve share one source of truth.
Verified: GpuDriven.visResolveParity passes with maxDelta=0.0 vs the forward
path (same cull, same pixels); full GpuDriven + RenderSystem3D/Shadow3D/
Lighting3D suites pass; validation shows no new VUIDs (the SPIR-V Geometry
capability error from gl_PrimitiveID was removed by the flat-triangle-base
change).
Add the stage-2 compute chain to the main frame:
- ComputePass wrapper + compile script for compute SPIR-V (hzb_build /
gpu_cull / gpu_emit); bindless set extended with cull UBO, visible flags,
compacted instances, indirect commands, HZB buffer and GBuffer depth.
- HZB: R32F max-downsampled mip chain per frame slot built from the
GBuffer depth after the GBuffer pass (buffer-based; offsets header at slot
start). Same-frame self-occlusion handled by testing the bounding sphere's
FRONT depth, and near-zero depth (uninitialized/corner garbage) never
occludes.
- Cull: per-instance Gribb-Hartmann frustum test + HZB occlusion test, flags
written per instance; emit compacts visible instances per CPU-provided
bucket layout and fills per-bucket indirect commands with atomic counters.
- Frame wiring: begin3DFrame defers opening the scene color pass when the
cull chain is live, so the compute section records before the opaque
draws; RenderSystem3D uploads sorted instances, runs cull+emit, opens the
pass and draws with GPU-written commands (per-bucket, empty buckets no-op).
Fallback to stage 1 when compute caps are missing. gpuDriven now forces
the GBuffer pass (HZB source).
- Known limitation: HZB is built from the same-frame GBuffer, so objects
already in the GBuffer cannot be occlusion-culled until the GBuffer itself
is culled (stage 3 vis buffer); the chain is verified with frustum culling
(2 of 5 instances culled) and pixel parity.
Tests: GpuDriven.opaqueForwardCullParity (5 spheres, 2 outside frustum ->
3 visible / 3 non-empty buckets, pixel parity < 0.03); all 6 GpuDriven
tests pass (integrated GPU; the AMD driver intermittently crashes at
vkCreateImage during init - environmental).
Stage 1 (CPU indirect draw) produced no geometry for the second draw:
- mesh3d_gpudriven.vert added pc.firstInstance on top of gl_InstanceIndex,
which already includes VkDrawIndexedIndirectCommand.firstInstance per the
Vulkan spec; the second command read instance 2 instead of 1 and sampled
garbage matrices. Drop the push-constant indirection entirely.
- gpuDrivenSubmitOpaque never bound vertex/index buffers; each GpuMesh owns
its own buffer pair (vertexBase/firstIndex are 0), so draws ran against
whatever the legacy path left bound. Track meshRecordOwners_ parallel to
the GPU mesh table and bind per-mesh at bucket boundaries.
Test: GpuDriven.opaqueForwardParityMultiTexture now uses a distinct bindless
slot-1 albedo on the second sphere; all 5 GpuDriven tests + IndirectBuilder
tests pass (integrated GPU). Also add the shared Windows crash-backtrace
handler (CrashHandler.h) to unit_test and document the repo debugging
playbook (incl. stale-object/layout pitfalls with unscanned Ninja deps) in
AGENTS.md.
End-to-end parity testing (gpuDriven on/off pixel comparison) exposed and
fixed several shading-path bugs, and documented two hard AMD driver
limitations on this machine (Radeon AI PRO R9700):
1. Missing ambient in the GPU-driven frame UBO: the per-frame UBO only set
ambient.w; ambient.rgb came from stale state. Now mirrors the legacy
draw path (mesh3dLighting.ambient).
2. Normal-map fallback: materials without a normal texture clamped to the
bindless slot 0, which is the WHITE placeholder - the legacy path uses a
(128,128,255) flat-normal texture. The fragment shader now skips
applyNormalMap when the material has no normal texture.
3. AMD driver limitation A: vkUpdateDescriptorSets on the sampler array
binding hangs for writes of >= 4 elements; placeholder fill uses
single-element writes (~1.1k calls at init, ~3 ms).
4. AMD driver limitation B: descriptor-array dynamic indexing only returns
correct results for element 0. Scenes with more than one distinct
texture therefore fall back to the legacy path via the new
gpuDrivenMaterialUsable() gate (RenderSystem3D eligibility check). The
proper fix (texture-array/atlas with layer indexing) is Phase 3 work.
Adds GpuDriven.opaqueForwardParity: renders the same single-texture scene
with the legacy and GPU-driven paths and asserts per-pixel luma agreement
(max delta < 0.03). Verified passing in a clean process; the AMD driver
wedges intermittently under repeated test runs on this machine, which is
tracked separately.
The gpuDriven feature remains opt-in (RenderControl, default OFF), so
default rendering is unchanged.
- GpuDrivenCaps: probe + enable Vulkan 1.2 core features (drawIndirectCount,
descriptor indexing, non-uniform indexing, update-after-bind) at device
creation; the toolchain's Vulkan headers omit the core drawIndirect bit so
it is assumed supported and left untouched.
- Bindless Set1: sampler2D array (4096) + samplerCube array (64) + SSBO table
array (64) with PARTIALLY_BOUND | UPDATE_AFTER_BIND; textures register on
creation, placeholder-filled with the 1x1 white texture/cubemap.
- GPU tables: GpuMeshRecord (bounds + index/vertex ranges) filled at mesh
upload and GpuMaterialRecord built from Material params, uploaded to
host-visible SSBOs with fixed capacity.
- FrameArena: per-frame-slot host-visible ring allocator, reset each
begin3DFrame; unused until phase 1 (indirect draw).
- Tests: GpuDriven.capsAvailable / bindlessTextureRegistration /
meshTableRegistration (GPU runtime verification pending driver recovery).
Rendering is unchanged: nothing consumes the new infrastructure yet.
西风逍遥游