Struct NoiseChunk 

pub struct NoiseChunk<N: DimensionNoises> {
    slices: Vec<Box<[f32; 4096]>>,
    interp_count: usize,
    corners_y: usize,
    block_ys: Vec<i32>,
    first_cell_x: i32,
    first_cell_z: i32,
    cell_min_y: i32,
    cell_count_y: usize,
    cell_count_xz: usize,
    _phantom: PhantomData<N>,
}

Stores density values at cell corners for a single chunk and provides trilinear interpolation between corners for block-level resolution.

Supports multiple interpolation channels matching vanilla’s multi-interpolator system. Distinct marker evaluations get channels filled at cell corners and interpolated independently.

Storage is per-corner SoA — slice[corner_idx * MAX_INTERP + ch] — so 4 adjacent channels’ values at a given corner sit in contiguous memory, allowing the terrain sampler to keep Vanilla’s f32 density values without widening an intermediate result.

Fields

slices: Vec<Box<[f32; 4096]>>

One slice per cell-X boundary, holding density values at the cell corners on that X-plane. Length is cell_count_xz + 1. Indexed as slices[cx][corner_idx * MAX_INTERP + ch] where corner_idx = z_corner * corners_y + y_corner (range [0, slice_len)) and ch is the interpolation channel (range [0, interp_count)).

We keep all slices materialized rather than alternating two buffers so the slice-fill phase can run in parallel: each cx boundary’s noise tree evaluation is independent. The per-block trilerp loop then indexes slices[cx] and slices[cx + 1] sequentially.

interp_count: usize

Number of active interpolation channels.

corners_y: usize

Number of Y corners per Z column (cell_count_y + 1).

block_ys: Vec<i32>

Per-corner block-Y values, precomputed once at construction. Same for every slice fill (depends only on cell_min_y, cell_height, and corners_y).

first_cell_x: i32

First cell X/Z in world coordinates (cell index, not block).

first_cell_z: i32

cell_min_y: i32

Minimum cell Y index.

cell_count_y: usize

Number of cells in Y direction.

cell_count_xz: usize

Number of cells per chunk in XZ.

_phantom: PhantomData<N>

Implementations

impl<N: DimensionNoises> NoiseChunk<N>

pub fn new(chunk_min_block_x: i32, chunk_min_block_z: i32) -> Self

Create a new NoiseChunk for the given chunk position.

chunk_min_block_x and chunk_min_block_z are the world-space block coordinates of the chunk’s northwest corner.

fn fill_slice_into( slice: &mut [f32; 4096], cell_x: i32, block_ys: &[i32], blended_column: &mut [f32], interp_count: usize, corners_y: usize, cell_count_xz: usize, first_cell_z: i32, noises: &N, cache: &mut N::ColumnCache, corner_columns: &CornerColumnStore, )

Fill the slice buffer for the given cell X. Free-standing function so each parallel slice-fill can run on its own thread with its own ColumnCache clone.

pub fn fill<F>( &mut self, noises: &N, cache: &mut N::ColumnCache, beardifier: Option<&Beardifier>, unsampled_air_min_y: i32, corner_columns: &CornerColumnStore, place_block: F, )

where F: FnMut(usize, i32, usize, f32, &[f32], &mut N::ColumnCache),

Fill the chunk with terrain blocks using multi-channel trilinear interpolation.

For each block position:

1. Trilinearly interpolate each channel independently from cell corners
2. Apply outer operations (squeeze, min, etc.) via combine_interpolated
3. Call place_block with the final density

Cells at or above unsampled_air_min_y whose proving channels (DimensionNoises::final_density_nonpositive_channels) are <= 0 at every interpolated block value, and that the beardifier cannot reach, are skipped without calling place_block: their density is non-positive, which the caller guarantees places nothing and changes no state there.

fn channels_are_nonpositive( values_by_y: &[[f32; 16]], channels: &[usize], ) -> bool

pub fn prefill_material_ore_vein_values( &self, noises: &N, cache: &mut N::ColumnCache, ) -> Box<[f32]>

Pre-fills the density/richness buffers used by material ore rules.

MaterialRuleContext.getDensitiesInChunk samples these functions over complete chunk volume before the surface scan begins. Steel keeps the dense Y prefix where a rule may accept a block. Compact f32 results avoid retaining the noise chunk across generation stages. The result has 256 * material_ore_vein_value_height() * material_ore_vein_value_count() entries, ordered by Y, Z, X, then value.