[Batch 3] Integrate GPU frustum culling into WorldRenderer

[MichaelFisher1997]

Summary

Replace the CPU-side frustum culling loop in WorldRenderer.render() with the GPU compute shader from #375. The visible chunk list will be determined on GPU, and draw commands will be dispatched from the GPU-generated indirect buffer.

Depends on: #375 (GPU frustum compute shader + AABB buffer)

Current Behavior

WorldRenderer.render() (line 131):

1. Lock chunks_mutex shared
2. Iterate all chunk positions within render distance (nested x/z loop, line 159-173)
3. For each: check if chunk exists, check if renderable, call frustum.intersectsChunkRelative()
4. Append visible chunks to visible_chunks list
5. For each visible chunk: set model matrix, call drawOffset() per pass

At 128 chunks render distance, step 2 touches 65K+ positions. At 256 chunks, 260K+. This CPU loop becomes the bottleneck.

Target Behavior

1. Each frame: upload dirty chunk AABBs to GPU storage buffer
2. Dispatch compute shader with current frustum planes
3. Compute shader writes DrawIndirectCommand buffer for visible chunks
4. Read back visible count (or use vkCmdDrawIndirectCount if available)
5. Execute draw commands from GPU-generated buffer
6. No CPU iteration over chunk positions at all

Implementation Plan

Step 1: AABB buffer management

• WorldRenderer holds a CullingSystem from [Batch 2] Chunk AABB storage buffer + GPU frustum compute shader #375
• On chunk load/unload: mark AABB buffer slot as dirty
• Each frame: upload only dirty AABB entries (or full upload if many changed)
• Map chunk index → AABB buffer slot (could use chunk_storage iteration order)

Step 2: Replace render() frustum loop

pub fn render(self: *WorldRenderer, view_proj: Mat4, camera_pos: Vec3, ...) void {
    // Old: iterate chunks, CPU cull, append to visible_chunks
    // New: upload frustum planes, dispatch compute, sync barrier
    self.culling_system.dispatch(view_proj, chunk_count);
    
    // Execute draw commands from GPU buffer
    // Need per-chunk model matrix somehow — either:
    //   a) Instance data buffer (from MDI #371)
    //   b) Push model matrix per draw in indirect loop
}

Step 3: Model matrix handling

• With MDI ([Batch 1] Wire up Multi-Draw Indirect in WorldRenderer #371), model matrices are in the instance buffer already
• GPU culling shader can write the correct firstInstance index to map each visible chunk to its instance data
• Or: compute shader writes model-relative offsets directly into per-draw push constants

Step 4: Shadow pass

• Same GPU culling applied to shadow pass
• Different frustum (light-space), different render distance
• May need separate dispatch or shader parameterization

Step 5: Fallback path

• Keep CPU culling as fallback for devices without compute shaders
• Runtime detection: if (culling_system.available) gpu_cull else cpu_cull

Files to Modify

• src/world/world_renderer.zig — main render loop, integrate CullingSystem
• src/engine/graphics/vulkan/culling_system.zig — wire into frame lifecycle
• src/world/chunk_storage.zig — expose iteration for AABB updates

Testing

• Visual parity: same chunks rendered as CPU culling
• Shadow pass produces same results
• Draw call count unchanged (should match CPU approach)
• No validation errors
• Performance improvement measurable in timing overlay
• Fallback works on devices without compute

Roadmap: docs/PERFORMANCE_ROADMAP.md — Batch 3, Issue 2A-2

[opencode-agent]

Based on my analysis of the codebase, I can provide a comprehensive assessment of this issue:

Classification

Feature Request - Performance enhancement to replace CPU frustum culling with GPU compute shader.

Validation

✅ Technical accuracy confirmed. I've verified the current implementation in src/world/world_renderer.zig:

• Lines 159-173: CPU frustum culling loop exactly as described
• Lines 131-204: render() method with O(n²) iteration over render distance
• Lines 208-260: renderShadowPass() with identical CPU culling pattern
• Line 194: ChunkStorage.iteratorUnsafe() already exists for AABB buffer updates

✅ Bottleneck claim valid. At 128 chunks render distance, the nested loops iterate 65,536 positions; at 256 chunks, 262,144 positions.

Dependency Status

⚠️ Blocking Issue: This depends on #375 (GPU frustum compute shader + AABB buffer), which does not appear to exist yet. The proposed src/engine/graphics/vulkan/culling_system.zig file is not present in the codebase.

Architectural Assessment

Proposed approach is sound:

1. AABB buffer management: Leverage existing ChunkStorage iteration
2. MDI integration: Uses existing DrawIndirectCommand and InstanceData structures (defined in rhi_types.zig:117-129)
3. Fallback path: Keeping CPU culling for devices without compute is prudent
4. Shadow pass: Will need separate dispatch with light-space frustum

Scope Evaluation

This is appropriately scoped for a single issue:

• Single subsystem (world rendering)
• Clear deliverable (GPU culling integration)
• Well-defined testing criteria

Recommendation

This issue should be:

1. Marked as blocked until [Batch 2] Chunk AABB storage buffer + GPU frustum compute shader #375 is implemented
2. Kept open as it documents the integration requirements clearly
3. Considered ready for implementation once CullingSystem from [Batch 2] Chunk AABB storage buffer + GPU frustum compute shader #375 is available

The implementation plan is thorough and the code pointers are accurate. The performance improvement should be measurable, especially at high render distances (>128 chunks).

opencode session  |  github run