Struct ChunkSection 

pub struct ChunkSection {
    pub states: BlockPalette,
    pub biomes: BiomePalette,
    non_empty_block_count: u16,
    fluid_count: u16,
    pub ticking_block_count: u16,
    ticking_fluid_count: u16,
}

A chunk section.

Contains a 16x16x16 cube of block states and biomes, along with cached counts for optimization (similar to vanilla’s LevelChunkSection).

Fields

states: BlockPalette

The block states in the section.

biomes: BiomePalette

The biomes in the section.

non_empty_block_count: u16

Number of non-air blocks in this section (0-4096). Used to quickly check if a section is empty.

fluid_count: u16

Number of fluid-containing blocks in this section (0-4096). Includes water, lava, and waterlogged blocks.

ticking_block_count: u16

Number of randomly-ticking blocks in this section (0-4096).

ticking_fluid_count: u16

Number of randomly-ticking fluids in this section (0-4096).

Implementations

impl ChunkSection

pub const fn new_with_biomes(states: BlockPalette, biomes: BiomePalette) -> Self

Creates a new chunk section with the given block states and biomes.

Note: You must call recalculate_counts() after creation to initialize the cached counters if the states palette contains non-air blocks.

pub fn new_empty() -> Self

Creates a new empty chunk section.

pub const fn is_empty(&self) -> bool

Returns true if this section contains no non-air blocks.

pub const fn is_randomly_ticking(&self) -> bool

Returns true if this section contains any randomly-ticking blocks or fluids.

pub const fn is_randomly_ticking_blocks(&self) -> bool

Returns true if this section contains any randomly-ticking blocks.

pub const fn is_randomly_ticking_fluids(&self) -> bool

Returns true if this section contains any randomly-ticking fluids.

pub fn maybe_has_block_light_sources(&self) -> bool

Returns true if this section’s palette may contain block-light sources.

pub fn append_block_light_sources( &self, chunk_min_x: i32, section_min_y: i32, chunk_min_z: i32, sources: &mut Vec<BlockPos>, )

Appends block-light source positions in ScalableLux local-index order.

pub const fn non_empty_block_count(&self) -> u16

Returns the number of non-air blocks in this section.

pub const fn fluid_count(&self) -> u16

Returns the number of fluid-containing blocks in this section.

pub const fn has_fluid(&self) -> bool

Returns if the chunk has fluid.

pub const fn ticking_block_count(&self) -> u16

Returns the number of randomly-ticking blocks in this section.

pub const fn ticking_fluid_count(&self) -> u16

Returns the number of randomly-ticking fluids in this section.

pub fn recalculate_counts(&mut self)

Recalculates cached counters from extracted per-state metadata.

Iterates the palette (O(palette_size)) rather than every cube cell (O(4096)): each block-state appears at most once in the palette and carries its own occurrence count, so we just classify each unique state and multiply by its count. Mirrors Moonrise’s BlockCountingBitStorage. For a Homogeneous section that’s a single classify; for typical Heterogeneous sections palette is well under 16 entries.

fn recalculate_counts_from_palette( &mut self, counts_for_state: impl FnMut(BlockStateId) -> BlockStateSectionCounts, )

const fn accumulate_counter_traits( non_empty: &mut u16, fluid: &mut u16, ticking_blocks: &mut u16, ticking_fluids: &mut u16, counts: BlockStateSectionCounts, block_count: u16, )

pub fn contains_poi(&self) -> bool

Whether this section’s palette contains any POI-type block state.

Lets the Full-stage POI populate skip the full 4096-block scan_and_populate for the overwhelming majority of sections (stone/dirt/air) that hold no POI blocks — a palette scan of O(≤16) instead of O(4096). Mirrors vanilla’s LevelChunkSection.maybeHas.

pub fn set_block_state( &mut self, x: usize, y: usize, z: usize, new_state: BlockStateId, ) -> BlockStateId

Sets a block state and updates the cached counters.

Returns the old block state.

pub(crate) fn set_block_state_for_generation( &mut self, x: usize, y: usize, z: usize, new_state: BlockStateId, ) -> BlockStateId

Sets a block state through the raw worldgen building path.

Returns the old block state. Cached counters are intentionally not updated; callers must recount before light, promotion, save, or packet serialization.

pub(crate) fn block_state_section_counts( state: BlockStateId, ) -> BlockStateSectionCounts

Returns the cached-counter traits for a block state.

pub(crate) fn finalize_generation_counts_if_needed(&mut self)

fn ensure_counter_ready_for_delta(&mut self)

const fn apply_count_change( &mut self, old_counts: BlockStateSectionCounts, new_counts: BlockStateSectionCounts, )

pub fn write(&self, writer: &mut Cursor<Vec<u8>>)

Writes the chunk section to a writer.

Panics

• If the writer fails to write.

Trait Implementations

impl Debug for ChunkSection

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.