Struct Aquifer 

pub struct Aquifer<N: DimensionNoises> {

    location_cache: Vec<i64>,
    status_cache: Vec<Option<FluidStatus>>,
    splitter: RandomSplitter,
    cache: N::ColumnCache,
    min_grid_x: i32,
    min_grid_y: i32,
    min_grid_z: i32,
    grid_size_x: i32,
    grid_size_z: i32,
    skip_sampling_above_y: i32,
    sea_level: i32,
    lava_floor: i32,
    water_id: BlockStateId,
    lava_id: BlockStateId,
    default_fluid_id: BlockStateId,
    should_schedule_fluid_update: bool,
    col_cache: AquiferColumnCache,
    preliminary_surface: Arc<PreliminarySurfaceStore>,
}

Noise-based aquifer for a single chunk.

Constructed once per chunk, used throughout the fill loop.

Fields

location_cache: Vec<i64>

Packed (x, y, z) locations of aquifer cell centers. i64::MAX = not yet computed.

status_cache: Vec<Option<FluidStatus>>

Lazily computed fluid statuses per grid cell.

splitter: RandomSplitter

Positional random for grid cell jitter.

cache: N::ColumnCache

Column cache owned by the aquifer for density function evaluation.

min_grid_x: i32

Grid bounds.

min_grid_y: i32

min_grid_z: i32

grid_size_x: i32

grid_size_z: i32

skip_sampling_above_y: i32

Skip aquifer sampling above this Y (optimization).

sea_level: i32

Sea level for this dimension.

lava_floor: i32

Precomputed min(LAVA_LEVEL, sea_level). Hoisted out of global_fluid (which is on the per-block hot path) so we don’t recompute it millions of times per chunk.

water_id: BlockStateId

Block state IDs.

lava_id: BlockStateId

default_fluid_id: BlockStateId

The dimension’s default fluid (water for overworld, lava for nether).

should_schedule_fluid_update: bool

Vanilla’s shouldScheduleFluidUpdate flag from the most recent substance lookup.

col_cache: AquiferColumnCache

12-cell neighborhood snapshot for the current Y-column. Placed at the end so dimensions with disabled aquifers (nether/end) keep the hot fluid-id fields earlier in the struct’s cache lines.

preliminary_surface: Arc<PreliminarySurfaceStore>

Generator-wide memo of preliminary_surface_level, replacing vanilla’s per-aquifer Long2IntMap: compute_fluid samples 13 columns per cell and the constructor scans ~121, mostly shared with neighboring chunks.

Implementations

impl<N: DimensionNoises> Aquifer<N>

pub fn new( chunk_min_x: i32, chunk_min_z: i32, min_block_y: i32, y_block_size: i32, splitter: &RandomSplitter, noises: &N, preliminary_surface: &Arc<PreliminarySurfaceStore>, cache: N::ColumnCache, ) -> Self

Create an aquifer for a full 16×16 chunk.

chunk_min_x/z are the block coordinates of the chunk’s NW corner. min_block_y and y_block_size define the vertical range. splitter is the seed’s positional splitter. cache should be a pre-initialized column cache for this chunk (avoids a redundant init_grid call).

pub fn new_sized( chunk_min_x: i32, chunk_min_z: i32, width_x: i32, width_z: i32, min_block_y: i32, y_block_size: i32, splitter: &RandomSplitter, noises: &N, preliminary_surface: &Arc<PreliminarySurfaceStore>, cache: N::ColumnCache, ) -> Self

Create an aquifer with custom XZ extent (in blocks). Vanilla’s iterateNoiseColumn uses width=cellWidth (4) for single-column queries.

fn max_preliminary_surface_level( noises: &N, cache: &mut N::ColumnCache, preliminary_surface: &PreliminarySurfaceStore, min_x: i32, min_z: i32, max_x: i32, max_z: i32, ) -> i32

const fn get_index(&self, gx: i32, gy: i32, gz: i32) -> usize

fn uniform_cell_status(&mut self, noises: &N) -> Option<FluidStatus>

shared status if every cached neighbor agrees

fn is_water_over_global_lava( &self, fluid_at: Option<BlockStateId>, world_y: i32, ) -> bool

Whether fluid_at is water directly above the global lava sea.

fn refill_col_cache(&mut self, world_x: i32, world_y: i32, world_z: i32) -> i32

refill in x/y/z order to keep nearest-cell ties unchanged

pub fn compute_substance( &mut self, noises: &N, world_x: i32, world_y: i32, world_z: i32, density: f64, ) -> AquiferResult

Compute what block to place at this position given the interpolated density.

fn compute_substance_sampled( &mut self, noises: &N, world_x: i32, world_y: i32, world_z: i32, density: f64, ) -> AquiferResult

nearest cells and barriers; the column cache must be current

pub fn unsampled_air_min_y(&self) -> i32

first y where every non-positive density gives air without sampling safe to skip: only the fluid-update flag changes, and each call resets it

pub const fn should_schedule_fluid_update(&self) -> bool

Returns whether the most recent substance lookup needs postprocessing for placed fluids.

pub fn preliminary_surface_level(&mut self, noises: &N, x: i32, z: i32) -> i32

Returns the quart-quantized preliminary surface level, reusing this aquifer’s density-column cache and the generator-wide result store.

fn get_aquifer_status(&mut self, index: usize, noises: &N) -> FluidStatus

Get or compute the fluid status for the aquifer cell at the given cache index.

fn compute_fluid(&mut self, x: i32, y: i32, z: i32, noises: &N) -> FluidStatus

Compute the fluid status for an aquifer cell centered at (x, y, z).

fn compute_surface_level( &mut self, x: i32, y: i32, z: i32, noises: &N, gf: FluidStatus, lowest_surface: i32, surface_under_global: bool, ) -> i32

fn compute_randomized_fluid_surface_level( &mut self, x: i32, y: i32, z: i32, noises: &N, lowest_surface: i32, ) -> i32

fn compute_fluid_type( &mut self, x: i32, y: i32, z: i32, noises: &N, gf: FluidStatus, fluid_level: i32, ) -> BlockStateId

fn calculate_pressure( &mut self, noises: &N, x: i32, y: i32, z: i32, barrier_noise: &mut f64, s1: FluidStatus, s2: FluidStatus, ) -> f64

Calculate barrier pressure between two aquifer cells.

Matches vanilla’s check: if lava meets water at this Y, return max pressure.