Struct BspWorld 

pub struct BspWorld<'a> {
    pub planes: &'a [Plane],
    pub nodes: &'a [Node],
    pub leaves: &'a [Leaf],
    pub faces: &'a [Face],
    pub marksurfaces: &'a [u16],
    pub vertices: &'a [[f32; 3]],
    pub uvs: &'a [[f32; 2]],
    pub lm_uvs: &'a [[f32; 2]],
    pub vis: &'a [u8],
    pub vis_offsets: &'a [u32],
    pub num_clusters: u16,
}

The complete borrowed BSP world.

Construct with BspWorld::new from your static lumps, then pass a &BspWorld into K3dengine::record_bsp every frame. No allocator needed.

Fields

planes: &'a [Plane]

nodes: &'a [Node]

leaves: &'a [Leaf]

faces: &'a [Face]

marksurfaces: &'a [u16]

Indirection table: leaves[i].first_marksurface indexes into this.

vertices: &'a [[f32; 3]]

uvs: &'a [[f32; 2]]

Per-vertex surface UV coordinates (parallel to vertices).

lm_uvs: &'a [[f32; 2]]

Per-vertex lightmap UV coordinates (parallel to vertices). May be empty when lightmaps are unused.

vis: &'a [u8]

Quake-style RLE-compressed PVS blob. Empty = always visible.

vis_offsets: &'a [u32]

vis_offsets[cluster_id] = byte offset into vis for that cluster.

num_clusters: u16

Implementations

impl<'a> BspWorld<'a>

pub fn new( planes: &'a [Plane], nodes: &'a [Node], leaves: &'a [Leaf], faces: &'a [Face], marksurfaces: &'a [u16], vertices: &'a [[f32; 3]], uvs: &'a [[f32; 2]], lm_uvs: &'a [[f32; 2]], vis: &'a [u8], vis_offsets: &'a [u32], num_clusters: u16, ) -> Self

impl<'a> BspWorld<'a>

pub fn leaf_for_point(&self, p: [f32; 3]) -> usize

Walk the BSP tree to find which leaf contains world-space point p.

Iterative — zero stack usage beyond the function call frame. Handles degenerate trees (0 nodes) by returning leaf 0.

pub fn cluster_visible(&self, from_cluster: i16, test_cluster: i16) -> bool

Test whether test_cluster is potentially visible from from_cluster.

Returns true unconditionally when:

• from_cluster < 0 (leaf with no PVS — Quake convention: always visible), or
• The PVS blob is empty (no vis data compiled — developer/test use), or
• test_cluster == from_cluster (every cluster sees itself).

Otherwise decodes Quake-style RLE: the vis row for from_cluster is a stream of non-zero bytes (each byte is 8 cluster bits) and zero runs encoded as [0x00, count] (skips count * 8 clusters).