Struct OverworldColumnCache 

pub struct OverworldColumnCache {

    pub x: i32,
    pub z: i32,
    qx: i32,
    qz: i32,
    valid: bool,
    grid_first_quart_x: i32,
    grid_first_quart_z: i32,
    has_grid: bool,
    pub df_shift_x: f64,
    pub df_shift_z: f64,
    pub df_overworld__continents: f64,
    pub df_overworld__erosion: f64,
    pub df_overworld__ridges: f64,
    pub df_overworld__ridges_folded: f64,
    pub df_overworld__offset: f64,
    pub df_overworld__factor: f64,
    pub df_overworld__jaggedness: f64,
    pub router_continentalness: f64,
    pub router_erosion: f64,
    pub router_preliminary_surface_level: f64,
    pub router_ridges: f64,
    pub router_temperature: f64,
    pub router_vegetation: f64,
    pub inline_noise_0: f64,
    pub inline_noise_1: f64,
    grid_df_shift_x: [f64; 25],
    grid_df_shift_z: [f64; 25],
    grid_df_overworld__continents: [f64; 25],
    grid_df_overworld__erosion: [f64; 25],
    grid_df_overworld__ridges: [f64; 25],
    grid_df_overworld__ridges_folded: [f64; 25],
    grid_df_overworld__offset: [f64; 25],
    grid_df_overworld__factor: [f64; 25],
    grid_df_overworld__jaggedness: [f64; 25],
    grid_router_continentalness: [f64; 25],
    grid_router_erosion: [f64; 25],
    grid_router_preliminary_surface_level: [f64; 25],
    grid_router_ridges: [f64; 25],
    grid_router_temperature: [f64; 25],
    grid_router_vegetation: [f64; 25],
    grid_inline_noise_0: [f64; 25],
    grid_inline_noise_1: [f64; 25],
}

Column-level cache for flat-cached (xz-only) density function results.

Supports two modes matching vanilla’s NoiseChunk.FlatCache:

• Grid mode (init_grid() called): Pre-computes a 2D grid of all in-chunk quart positions. ensure() does O(1) grid lookups for in-bounds positions, falls back to on-the-fly for out-of-bounds.
• No-grid mode (default): Single-entry lazy cache that recomputes when quart-quantized coordinates change. Used by climate samplers.

Fields

x: i32

Raw x block coordinate (for non-flat router functions).

z: i32

Raw z block coordinate (for non-flat router functions).

qx: i32

Effective x used to evaluate flat-cached values.

qz: i32

Effective z used to evaluate flat-cached values.

valid: bool

grid_first_quart_x: i32

grid_first_quart_z: i32

has_grid: bool

df_shift_x: f64

df_shift_z: f64

df_overworld__continents: f64

df_overworld__erosion: f64

df_overworld__ridges: f64

df_overworld__ridges_folded: f64

df_overworld__offset: f64

df_overworld__factor: f64

df_overworld__jaggedness: f64

router_continentalness: f64

router_erosion: f64

router_preliminary_surface_level: f64

router_ridges: f64

router_temperature: f64

router_vegetation: f64

inline_noise_0: f64

inline_noise_1: f64

grid_df_shift_x: [f64; 25]

grid_df_shift_z: [f64; 25]

grid_df_overworld__continents: [f64; 25]

grid_df_overworld__erosion: [f64; 25]

grid_df_overworld__ridges: [f64; 25]

grid_df_overworld__ridges_folded: [f64; 25]

grid_df_overworld__offset: [f64; 25]

grid_df_overworld__factor: [f64; 25]

grid_df_overworld__jaggedness: [f64; 25]

grid_router_continentalness: [f64; 25]

grid_router_erosion: [f64; 25]

grid_router_preliminary_surface_level: [f64; 25]

grid_router_ridges: [f64; 25]

grid_router_temperature: [f64; 25]

grid_router_vegetation: [f64; 25]

grid_inline_noise_0: [f64; 25]

grid_inline_noise_1: [f64; 25]

Implementations

impl OverworldColumnCache

const GRID_SIDE: i32 = 5

Grid side length (quart positions per axis).

pub fn new() -> Self

Create a new column cache without a pre-computed grid.

pub fn init_grid( &mut self, chunk_block_x: i32, chunk_block_z: i32, noises: &OverworldNoises, )

Pre-compute flat-cached values for all quart positions in a chunk.

After this call, ensure() for in-bounds positions copies from the grid (O(1)). Out-of-bounds positions fall back to on-the-fly evaluation at raw (non-quantized) coordinates.

pub fn ensure(&mut self, x: i32, z: i32, noises: &OverworldNoises)

Ensure the cache is populated for the given (x, z) block coordinates.

With a grid: in-bounds positions load from the pre-computed grid, out-of-bounds positions compute at raw (non-quantized) coordinates. Without a grid: always quantizes and lazy-computes (single-entry cache).

Trait Implementations

impl Clone for OverworldColumnCache

fn clone(&self) -> OverworldColumnCache

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ColumnCache for OverworldColumnCache

type Noises = OverworldNoises

The associated noises type for this cache.

fn ensure(&mut self, x: i32, z: i32, noises: &Self::Noises)

Ensure the cache is populated for the given block coordinates.

fn init_grid( &mut self, chunk_block_x: i32, chunk_block_z: i32, noises: &Self::Noises, )

Pre-compute flat-cached values for all quart positions in a chunk.

impl Default for OverworldColumnCache

fn default() -> Self

Returns the “default value” for a type.