Struct ChunkCtx 

pub struct ChunkCtx<'a> {
    pub rd: Gd<RenderingDevice>,
    pub gpu: &'a mut ChunkGpuResources,
    pub stage: &'a mut Option<ChunkStage>,
    pub terrain: TerrainGpu,
    pub res: u32,
    pub realize_count: u32,
    pub vis_count: u32,
    pub captured: Vec<&'static str>,
    /* private fields */
}

Production recording context for the chunk pipeline: wraps the main RenderingDevice, the chunk GPU resources, and the staged upload for this execute. Mirrors Ctx<'a> from pipeline.rs.

Fields

rd: Gd<RenderingDevice>

gpu: &'a mut ChunkGpuResources

stage: &'a mut Option<ChunkStage>

terrain: TerrainGpu

res: u32

realize_count: u32

Chunks to realize this execute; set by the upload node from the stage and read by the realize node to size its dispatch (count * verts_per_chunk).

vis_count: u32

Visible instances this execute (CEL-73); set by the upload node, read by the scatter-compact node to size its dispatch (vis * capacity).

captured: Vec<&'static str>

Timestamp labels captured this execute (for GPU timing parity with Ctx).

Implementations

impl<'a> ChunkCtx<'a>

pub fn new( rd: Gd<RenderingDevice>, gpu: &'a mut ChunkGpuResources, stage: &'a mut Option<ChunkStage>, terrain: TerrainGpu, res: u32, ) -> Self

pub fn list(&mut self) -> i64

pub fn close_list(&mut self)

Timestamps must sit between compute lists, so close any open list.

pub fn finish(self) -> Vec<&'static str>

Close the list and capture the end marker; returns the captured labels.

Trait Implementations

impl<'a> GraphNode<ChunkCtx<'a>> for Box<dyn ChunkNode>

Bridge the trait objects to the celestial-graph executor.

fn params_hash(&self) -> u64

Hash of the node’s own parameters; a change marks the node dirty even if no upstream resource changed.

fn record(&mut self, ctx: &mut ChunkCtx<'a>)

Record this node’s GPU work. Only called when the node is dirty.

impl RecordCtx for ChunkCtx<'_>

fn timestamp(&mut self, label: &str)