feat(renderer): namespace virtual visibility IDs

Author: proggeramlug

native/shared/shaders/visibility_buffer/reconstruct.wgsl

@@ -6,13 +6,16 @@
 // a per-corner barycentric vertex stream.
 
 const BLOOM_VISIBILITY_INVALID_DRAW_ID: u32 = 0xffffffffu;
+const BLOOM_VISIBILITY_VIRTUAL_DRAW_BIT: u32 = 0x80000000u;
+const BLOOM_VISIBILITY_DRAW_INDEX_MASK: u32 = 0x7fffffffu;
 const BLOOM_VISIBILITY_FRONT_FACE_BIT: u32 = 0x80000000u;
 const BLOOM_VISIBILITY_PRIMITIVE_MASK: u32 = 0x7fffffffu;
 
 struct BloomVisibilityRecord {
     draw_id: u32,
     primitive_id: u32,
     front_facing: bool,
+    virtual_geometry: bool,
 };
 
 fn bloom_visibility_valid(raw: vec2<u32>) -> bool {
@@ -21,9 +24,22 @@ fn bloom_visibility_valid(raw: vec2<u32>) -> bool {
 
 fn bloom_decode_visibility(raw: vec2<u32>) -> BloomVisibilityRecord {
     return BloomVisibilityRecord(
-        raw.x,
+        raw.x & BLOOM_VISIBILITY_DRAW_INDEX_MASK,
         raw.y & BLOOM_VISIBILITY_PRIMITIVE_MASK,
         (raw.y & BLOOM_VISIBILITY_FRONT_FACE_BIT) != 0u,
+        (raw.x & BLOOM_VISIBILITY_VIRTUAL_DRAW_BIT) != 0u,
+    );
+}
+
+fn bloom_encode_virtual_visibility(
+    draw_index: u32,
+    primitive_id: u32,
+    front_facing: bool,
+) -> vec2<u32> {
+    let face = select(0u, BLOOM_VISIBILITY_FRONT_FACE_BIT, front_facing);
+    return vec2<u32>(
+        BLOOM_VISIBILITY_VIRTUAL_DRAW_BIT | draw_index,
+        primitive_id | face,
     );
 }
 

native/shared/src/renderer/mod.rs

@@ -69,6 +69,7 @@ mod texture_store;
 mod transmitted_shadows;
 mod transparent_gi;
 pub(crate) mod visibility_buffer;
+mod visibility_ids;
 mod visibility_shading;
 mod vsm_gpu_casters;
 mod weighted_transparency;
@@ -113,6 +114,7 @@ use atmosphere_lut::{
 };
 
 mod formats;
+pub(crate) use formats::DEPTH_FORMAT;
 #[cfg(not(target_arch = "wasm32"))]
 use formats::PROBE_OCT_SIZE;
 use formats::{
@@ -124,8 +126,8 @@ use formats::{
     create_ssao_rt, create_ssgi_rt, create_ssr_history_textures, create_ssr_rt, create_sss_rt,
     create_taa_textures, create_velocity_rt, create_wsrc_atlas, halton, probe_grid_dims,
     BLOOM_MIP_COUNT, CARD_ATLAS_SIZE, CARD_AXES_PER_MESH, CARD_MAX_SLOTS, CARD_SLOTS_PER_ROW,
-    CARD_SLOT_SIZE, DEPTH_FORMAT, HDR_FORMAT, HIZ_FORMAT, HIZ_MIP_COUNT, MATERIAL_FORMAT,
-    MESH_SDF_RES, PROBE_TILE_SIZE, SCENE_SDF_CLIPMAP_BIN_CELLS, SCENE_SDF_CLIPMAP_EXTENT,
+    CARD_SLOT_SIZE, HDR_FORMAT, HIZ_FORMAT, HIZ_MIP_COUNT, MATERIAL_FORMAT, MESH_SDF_RES,
+    PROBE_TILE_SIZE, SCENE_SDF_CLIPMAP_BIN_CELLS, SCENE_SDF_CLIPMAP_EXTENT,
     SCENE_SDF_CLIPMAP_LAYERS_PER_FRAME, SCENE_SDF_CLIPMAP_REBAKE_THRESHOLD, SCENE_SDF_CLIPMAP_RES,
     SSAO_FORMAT, VELOCITY_FORMAT, WSRC_CASCADE_COUNT, WSRC_CASCADE_EXTENTS, WSRC_GRID_RES,
     WSRC_REBAKE_THRESHOLD,

native/shared/src/renderer/visibility_buffer.rs

@@ -5,52 +5,10 @@
 //! use. The existing forward MRT remains authoritative until total frame cost
 //! and image parity pass on every required capability tier.
 
-pub(crate) const VISIBILITY_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rg32Uint;
-pub(crate) const VISIBILITY_BYTES_PER_PIXEL: u64 = 8;
-pub(crate) const INVALID_DRAW_ID: u32 = u32::MAX;
-pub(crate) const FRONT_FACE_BIT: u32 = 1 << 31;
-pub(crate) const PRIMITIVE_ID_MASK: u32 = FRONT_FACE_BIT - 1;
-
-/// One visibility-buffer texel. The second word reserves its high bit for the
-/// rasterized face orientation and leaves 31 bits for the primitive index.
-#[repr(C)]
-#[derive(Copy, Clone, Debug, Eq, PartialEq, bytemuck::Pod, bytemuck::Zeroable)]
-pub(crate) struct VisibilityRecord {
-    pub draw_id: u32,
-    pub primitive_and_face: u32,
-}
-
-impl VisibilityRecord {
-    pub(crate) const BACKGROUND: Self = Self {
-        draw_id: INVALID_DRAW_ID,
-        primitive_and_face: u32::MAX,
-    };
-
-    pub(crate) const fn encode(
-        draw_id: u32,
-        primitive_id: u32,
-        front_facing: bool,
-    ) -> Option<Self> {
-        if draw_id == INVALID_DRAW_ID || primitive_id > PRIMITIVE_ID_MASK {
-            return None;
-        }
-        Some(Self {
-            draw_id,
-            primitive_and_face: primitive_id | if front_facing { FRONT_FACE_BIT } else { 0 },
-        })
-    }
-
-    pub(crate) const fn decode(self) -> Option<(u32, u32, bool)> {
-        if self.draw_id == INVALID_DRAW_ID {
-            return None;
-        }
-        Some((
-            self.draw_id,
-            self.primitive_and_face & PRIMITIVE_ID_MASK,
-            (self.primitive_and_face & FRONT_FACE_BIT) != 0,
-        ))
-    }
-}
+pub(crate) use super::visibility_ids::{
+    VisibilityDraw, VisibilityRecord, DRAW_INDEX_MASK, FRONT_FACE_BIT, INVALID_DRAW_ID,
+    PRIMITIVE_ID_MASK, VIRTUAL_DRAW_BIT, VISIBILITY_BYTES_PER_PIXEL, VISIBILITY_FORMAT,
+};
 
 /// Exact allocation size of the packed visibility target, excluding backend
 /// row/heap alignment that must be reported separately by the runtime A/B.
@@ -77,7 +35,9 @@ pub(crate) fn contract_json() -> String {
         concat!(
             "{{\"format\":\"{}\",\"bytes_per_pixel\":{},",
             "\"invalid_draw_id\":{},\"primitive_bits\":31,",
-            "\"front_face_bits\":1,\"shipping_enabled\":false,",
+            "\"front_face_bits\":1,\"draw_namespace_bits\":1,",
+            "\"virtual_draw_bit\":{},\"draw_index_mask\":{},",
+            "\"shipping_enabled\":false,",
             "\"required_feature\":\"primitive-index\",",
             "\"vertex_stride_bytes\":{},\"native_1080p_bytes\":{},",
             "\"reconstruction_wgsl_bytes\":{},\"geometry_wgsl_bytes\":{},",
@@ -86,6 +46,8 @@ pub(crate) fn contract_json() -> String {
         format_name,
         VISIBILITY_BYTES_PER_PIXEL,
         INVALID_DRAW_ID,
+        VIRTUAL_DRAW_BIT,
+        DRAW_INDEX_MASK,
         std::mem::size_of::<super::Vertex3D>(),
         target_bytes(1_920, 1_080).expect("1080p visibility allocation is bounded"),
         RECONSTRUCTION_WGSL.len(),
@@ -1202,13 +1164,14 @@ mod tests {
         for (draw, primitive, front) in [
             (0, 0, false),
             (17, 42, true),
-            (u32::MAX - 1, PRIMITIVE_ID_MASK, false),
+            (DRAW_INDEX_MASK, PRIMITIVE_ID_MASK, false),
         ] {
             let encoded = VisibilityRecord::encode(draw, primitive, front).unwrap();
             assert_eq!(encoded.decode(), Some((draw, primitive, front)));
         }
         assert_eq!(VisibilityRecord::BACKGROUND.decode(), None);
         assert_eq!(VisibilityRecord::encode(INVALID_DRAW_ID, 0, true), None);
+        assert_eq!(VisibilityRecord::encode(VIRTUAL_DRAW_BIT, 0, true), None);
         assert_eq!(VisibilityRecord::encode(0, FRONT_FACE_BIT, true), None);
     }
 

native/shared/src/renderer/visibility_ids.rs

@@ -0,0 +1,134 @@
+//! Collision-free draw namespace for the shared packed visibility target.
+
+pub(crate) const VISIBILITY_FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rg32Uint;
+pub(crate) const VISIBILITY_BYTES_PER_PIXEL: u64 = 8;
+pub(crate) const INVALID_DRAW_ID: u32 = u32::MAX;
+pub(crate) const VIRTUAL_DRAW_BIT: u32 = 1 << 31;
+pub(crate) const DRAW_INDEX_MASK: u32 = VIRTUAL_DRAW_BIT - 1;
+pub(crate) const FRONT_FACE_BIT: u32 = 1 << 31;
+pub(crate) const PRIMITIVE_ID_MASK: u32 = FRONT_FACE_BIT - 1;
+const MAX_VIRTUAL_DRAW_INDEX: u32 = DRAW_INDEX_MASK - 1;
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub(crate) enum VisibilityDraw {
+    Compatibility(u32),
+    Virtual(u32),
+}
+
+/// One `Rg32Uint` texel. Draw bit 31 selects compatibility or virtual
+/// geometry; primitive bit 31 independently carries raster face orientation.
+#[repr(C)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq, bytemuck::Pod, bytemuck::Zeroable)]
+pub(crate) struct VisibilityRecord {
+    pub draw_id: u32,
+    pub primitive_and_face: u32,
+}
+
+impl VisibilityRecord {
+    pub(crate) const BACKGROUND: Self = Self {
+        draw_id: INVALID_DRAW_ID,
+        primitive_and_face: u32::MAX,
+    };
+
+    pub(crate) const fn encode(
+        draw_id: u32,
+        primitive_id: u32,
+        front_facing: bool,
+    ) -> Option<Self> {
+        Self::encode_draw(
+            VisibilityDraw::Compatibility(draw_id),
+            primitive_id,
+            front_facing,
+        )
+    }
+
+    pub(crate) const fn encode_virtual(
+        draw_index: u32,
+        primitive_id: u32,
+        front_facing: bool,
+    ) -> Option<Self> {
+        Self::encode_draw(
+            VisibilityDraw::Virtual(draw_index),
+            primitive_id,
+            front_facing,
+        )
+    }
+
+    pub(crate) const fn encode_draw(
+        draw: VisibilityDraw,
+        primitive_id: u32,
+        front_facing: bool,
+    ) -> Option<Self> {
+        if primitive_id > PRIMITIVE_ID_MASK {
+            return None;
+        }
+        let draw_id = match draw {
+            VisibilityDraw::Compatibility(index) if index <= DRAW_INDEX_MASK => index,
+            VisibilityDraw::Virtual(index) if index <= MAX_VIRTUAL_DRAW_INDEX => {
+                VIRTUAL_DRAW_BIT | index
+            }
+            _ => return None,
+        };
+        Some(Self {
+            draw_id,
+            primitive_and_face: primitive_id | if front_facing { FRONT_FACE_BIT } else { 0 },
+        })
+    }
+
+    pub(crate) const fn decode(self) -> Option<(u32, u32, bool)> {
+        if self.draw_id == INVALID_DRAW_ID {
+            return None;
+        }
+        Some((
+            self.draw_id,
+            self.primitive_and_face & PRIMITIVE_ID_MASK,
+            (self.primitive_and_face & FRONT_FACE_BIT) != 0,
+        ))
+    }
+
+    pub(crate) const fn decode_draw(self) -> Option<(VisibilityDraw, u32, bool)> {
+        let (_, primitive, front) = match self.decode() {
+            Some(decoded) => decoded,
+            None => return None,
+        };
+        let draw = if self.draw_id & VIRTUAL_DRAW_BIT == 0 {
+            VisibilityDraw::Compatibility(self.draw_id)
+        } else {
+            VisibilityDraw::Virtual(self.draw_id & DRAW_INDEX_MASK)
+        };
+        Some((draw, primitive, front))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn compatibility_and_virtual_draws_never_alias_or_hit_background() {
+        let compatibility =
+            VisibilityRecord::encode(DRAW_INDEX_MASK, PRIMITIVE_ID_MASK, false).unwrap();
+        let virtual_draw =
+            VisibilityRecord::encode_virtual(MAX_VIRTUAL_DRAW_INDEX, 19, true).unwrap();
+        assert_eq!(
+            compatibility.decode_draw(),
+            Some((
+                VisibilityDraw::Compatibility(DRAW_INDEX_MASK),
+                PRIMITIVE_ID_MASK,
+                false,
+            ))
+        );
+        assert_eq!(
+            virtual_draw.decode_draw(),
+            Some((VisibilityDraw::Virtual(MAX_VIRTUAL_DRAW_INDEX), 19, true,))
+        );
+        assert_ne!(compatibility.draw_id, virtual_draw.draw_id);
+        assert_ne!(virtual_draw.draw_id, INVALID_DRAW_ID);
+        assert_eq!(VisibilityRecord::BACKGROUND.decode_draw(), None);
+        assert_eq!(VisibilityRecord::encode(VIRTUAL_DRAW_BIT, 0, true), None);
+        assert_eq!(
+            VisibilityRecord::encode_virtual(DRAW_INDEX_MASK, 0, true),
+            None
+        );
+    }
+}