Struct SurfaceSystem 

pub struct SurfaceSystem {

    surface_noise: NormalNoise,
    surface_secondary_noise: NormalNoise,
    clay_bands_offset_noise: NormalNoise,
    clay_bands: [BlockStateId; 192],
    noise_random: RandomSplitter,
    condition_noises: Vec<NormalNoise>,
    vertical_gradient_randoms: Vec<RandomSplitter>,
    badlands_pillar_noise: NormalNoise,
    badlands_pillar_roof_noise: NormalNoise,
    badlands_surface_noise: NormalNoise,
    iceberg_pillar_noise: NormalNoise,
    iceberg_pillar_roof_noise: NormalNoise,
    iceberg_surface_noise: NormalNoise,
    temperature_noise: PerlinSimplexNoise,
    frozen_temperature_noise: PerlinSimplexNoise,
    biome_info_noise: PerlinSimplexNoise,
    pub default_block: BlockStateId,
    pub sea_level: i32,
}

Runtime surface system holding noises and clay band data.

Matches vanilla’s SurfaceSystem. Constructed once per generator and shared across all chunk generation calls.

Fields

surface_noise: NormalNoise

Surface depth noise (minecraft:surface).

surface_secondary_noise: NormalNoise

Surface secondary noise (minecraft:surface_secondary).

clay_bands_offset_noise: NormalNoise

Clay bands offset noise (minecraft:clay_bands_offset).

clay_bands: [BlockStateId; 192]

Pre-generated terracotta band pattern (192 entries).

noise_random: RandomSplitter

Positional random factory for surface depth jitter and frozen ocean.

condition_noises: Vec<NormalNoise>

Condition noises used by NoiseThreshold surface rules. Indexed in the same order as DimensionNoises::surface_noise_ids().

vertical_gradient_randoms: Vec<RandomSplitter>

Positional random factories used by VerticalGradient surface rules.

badlands_pillar_noise: NormalNoise

badlands_pillar_roof_noise: NormalNoise

badlands_surface_noise: NormalNoise

iceberg_pillar_noise: NormalNoise

iceberg_pillar_roof_noise: NormalNoise

iceberg_surface_noise: NormalNoise

temperature_noise: PerlinSimplexNoise

Temperature noise for height-based adjustments (seed 1234, octave 0).

frozen_temperature_noise: PerlinSimplexNoise

Frozen biome temperature noise (seed 3456, octaves [-2,-1,0]).

biome_info_noise: PerlinSimplexNoise

Biome info noise for frozen patches (seed 2345, octave 0).

default_block: BlockStateId

Default block state for this dimension.

sea_level: i32

Sea level for this dimension.

Implementations

impl SurfaceSystem

pub fn new( splitter: &RandomSplitter, noise_params: &FxHashMap<String, NoiseParameters>, condition_noise_ids: &[&str], vertical_gradient_ids: &[&str], default_block: BlockStateId, sea_level: i32, ) -> Self

Create a new surface system.

condition_noise_ids lists the noise IDs referenced by NoiseThreshold conditions in the transpiled surface rules.

pub fn get_surface_depth(&self, x: i32, z: i32) -> i32

Compute the surface depth at a column position.

Matches vanilla’s SurfaceSystem.getSurfaceDepth(): (int)(noise * 2.75 + 3.0 + random.at(x, 0, z).nextDouble() * 0.25)

pub fn get_surface_secondary(&self, x: i32, z: i32) -> f64

Sample the surface secondary noise at a column position.

fn frozen_large_x7(&self, xz: &mut TemperatureXzCache) -> f64

frozen_temperature_noise.get_value(x*0.05, z*0.05) * 7.0, lazily cached on first access. NaN sentinel = not yet computed.

fn frozen_edge(&self, xz: &mut TemperatureXzCache) -> f64

biome_info_noise.get_value(x*0.2, z*0.2), lazily cached.

fn frozen_small(&self, xz: &mut TemperatureXzCache) -> f64

biome_info_noise.get_value(x*0.09, z*0.09), lazily cached.

fn height_temp_noise_x8(&self, xz: &mut TemperatureXzCache) -> f64

temperature_noise.get_value(x/8, z/8) * 8.0, lazily cached.

fn get_temperature( &self, biome_id: u16, block_y: i32, xz: &mut TemperatureXzCache, ) -> f32

Compute the effective temperature at a position, using a column-local XZ cache.

Matches vanilla’s Biome.getTemperature() with the temperature modifier and height-based adjustment above sea_level + 17. All three contributing noise samples are 2D (XZ-only), so reusing them across every Y in a column is determinism-preserving.

Panics

Panics if biome_id does not correspond to a registered biome.

pub fn cold_enough_to_snow( &self, biome_id: u16, block_y: i32, xz: &mut TemperatureXzCache, ) -> bool

Check if a position is cold enough to snow.

Matches vanilla’s Biome.coldEnoughToSnow() → !warmEnoughToRain() → getTemperature() >= 0.15. Takes a column-local xz cache so the XZ-only noise samples are reused across every Y in the column scan.

fn should_melt_frozen_ocean_iceberg_slightly( &self, biome_id: u16, block_x: i32, block_z: i32, ) -> bool

Check if an iceberg at this position should melt slightly.

Matches vanilla’s Biome.shouldMeltFrozenOceanIcebergSlightly(). Temperature is evaluated at sea level.

fn generate_bands(random: &mut RandomSource) -> [BlockStateId; 192]

Generate the 192-element terracotta band pattern.

Matches vanilla’s SurfaceSystem.generateBands().

fn make_bands( random: &mut RandomSource, bands: &mut [BlockStateId; 192], base_width: i32, state: BlockStateId, )

Place random bands of a single color.

Matches vanilla’s SurfaceSystem.makeBands().

impl SurfaceSystem

pub fn eroded_badlands_extension( &self, chunk: GenerationChunk<'_, SurfacePhase>, local_x: usize, local_z: usize, block_x: i32, block_z: i32, height: i32, min_y: i32, ) -> i32

Eroded badlands extension — adds terracotta pillars above the surface.

Matches vanilla’s SurfaceSystem.erodedBadlandsExtension(). Returns the new start_height if blocks were added above the original surface.

pub fn collect_frozen_ocean_extension_writes( &self, biome_id: u16, block_x: i32, block_z: i32, height: i32, min_surface_level: i32, min_y: i32, column: &[BlockStateId], writes: &mut Vec<(usize, BlockStateId)>, )

Frozen ocean iceberg extension — adds packed ice and snow blocks.

Collects the same writes as vanilla’s SurfaceSystem.frozenOceanExtension(). Called after surface rules for frozen ocean / deep frozen ocean biomes.

Trait Implementations

impl SurfaceNoiseProvider for SurfaceSystem

fn condition_noise(&self, noise_index: usize, x: i32, z: i32) -> f64

Sample a surface condition noise at (x, z). The noise is identified by its index in the dimension’s surface_noise_ids() list.

fn condition_noise_3d(&self, noise_index: usize, x: i32, y: i32, z: i32) -> f64

Sample a surface condition noise at (x, y, z). The noise is identified by its index in the dimension’s surface_noise_ids() list.

fn get_band(&self, x: i32, y: i32, z: i32) -> BlockStateId

Get the badlands clay band block at position (x, y, z).

fn cold_enough_to_snow( &self, biome_id: u16, block_x: i32, block_y: i32, block_z: i32, ) -> bool

Evaluates whether the biome temperature is cold enough for snow.

fn vertical_gradient( &self, gradient_index: usize, block_x: i32, block_y: i32, block_z: i32, true_at_and_below: i32, false_at_and_above: i32, ) -> bool

Evaluate a vertical gradient condition using positional random.