Struct OverworldNoises 

pub struct OverworldNoises {

    pub n_aquifer_barrier: NormalNoise,
    pub n_aquifer_fluid_level_floodedness: NormalNoise,
    pub n_aquifer_fluid_level_spread: NormalNoise,
    pub n_aquifer_lava: NormalNoise,
    pub n_cave_cheese: NormalNoise,
    pub n_cave_entrance: NormalNoise,
    pub n_cave_layer: NormalNoise,
    pub n_continentalness: NormalNoise,
    pub n_erosion: NormalNoise,
    pub n_jagged: NormalNoise,
    pub n_noodle: NormalNoise,
    pub n_noodle_ridge_a: NormalNoise,
    pub n_noodle_ridge_b: NormalNoise,
    pub n_noodle_thickness: NormalNoise,
    pub n_offset: NormalNoise,
    pub n_ore_gap: NormalNoise,
    pub n_ore_vein_a: NormalNoise,
    pub n_ore_vein_b: NormalNoise,
    pub n_ore_veininess: NormalNoise,
    pub n_pillar: NormalNoise,
    pub n_pillar_rareness: NormalNoise,
    pub n_pillar_thickness: NormalNoise,
    pub n_ridge: NormalNoise,
    pub n_spaghetti_2d: NormalNoise,
    pub n_spaghetti_2d_elevation: NormalNoise,
    pub n_spaghetti_2d_modulator: NormalNoise,
    pub n_spaghetti_2d_thickness: NormalNoise,
    pub n_spaghetti_3d_1: NormalNoise,
    pub n_spaghetti_3d_2: NormalNoise,
    pub n_spaghetti_3d_rarity: NormalNoise,
    pub n_spaghetti_3d_thickness: NormalNoise,
    pub n_spaghetti_roughness: NormalNoise,
    pub n_spaghetti_roughness_modulator: NormalNoise,
    pub n_temperature: NormalNoise,
    pub n_vegetation: NormalNoise,
    pub blended_noise: BlendedNoise,
}

All noise generators needed by this dimension’s density functions.

Created at runtime from a seed via the create method.

Fields

n_aquifer_barrier: NormalNoise

n_aquifer_fluid_level_floodedness: NormalNoise

n_aquifer_fluid_level_spread: NormalNoise

n_aquifer_lava: NormalNoise

n_cave_cheese: NormalNoise

n_cave_entrance: NormalNoise

n_cave_layer: NormalNoise

n_continentalness: NormalNoise

n_erosion: NormalNoise

n_jagged: NormalNoise

n_noodle: NormalNoise

n_noodle_ridge_a: NormalNoise

n_noodle_ridge_b: NormalNoise

n_noodle_thickness: NormalNoise

n_offset: NormalNoise

n_ore_gap: NormalNoise

n_ore_vein_a: NormalNoise

n_ore_vein_b: NormalNoise

n_ore_veininess: NormalNoise

n_pillar: NormalNoise

n_pillar_rareness: NormalNoise

n_pillar_thickness: NormalNoise

n_ridge: NormalNoise

n_spaghetti_2d: NormalNoise

n_spaghetti_2d_elevation: NormalNoise

n_spaghetti_2d_modulator: NormalNoise

n_spaghetti_2d_thickness: NormalNoise

n_spaghetti_3d_1: NormalNoise

n_spaghetti_3d_2: NormalNoise

n_spaghetti_3d_rarity: NormalNoise

n_spaghetti_3d_thickness: NormalNoise

n_spaghetti_roughness: NormalNoise

n_spaghetti_roughness_modulator: NormalNoise

n_temperature: NormalNoise

n_vegetation: NormalNoise

blended_noise: BlendedNoise

Implementations

impl OverworldNoises

pub fn create( seed: u64, splitter: &RandomSplitter, params: &FxHashMap<String, NoiseParameters>, ) -> Self

Create all noise generators from a world seed, positional splitter, and noise parameters.

impl OverworldNoises

fn apply_surface_rule_impl( ctx: &mut SurfaceRuleContext<'_>, ) -> Option<BlockStateId>

Apply this dimension’s surface rule at the current context position.

Trait Implementations

impl DimensionNoises for OverworldNoises

type ColumnCache = OverworldColumnCache

The column cache type for this dimension.

type Settings = OverworldNoiseSettings

The noise settings type for this dimension.

fn create( seed: u64, splitter: &RandomSplitter, params: &FxHashMap<String, NoiseParameters>, ) -> Self

Create all noise generators from a world seed and its positional splitter.

fn router_final_density( &self, cache: &mut Self::ColumnCache, x: i32, y: i32, z: i32, ) -> f32

Final density for terrain generation (positive = solid, negative = air).

fn router_depth( &self, cache: &mut Self::ColumnCache, x: i32, y: i32, z: i32, ) -> f32

Depth from surface (used for terrain shaping).

fn aquifer_needs_column_cache() -> bool

Whether aquifer noise lookups require a prepared column cache.

fn router_barrier( &self, cache: &mut Self::ColumnCache, x: i32, y: i32, z: i32, ) -> f32

Barrier noise for aquifer boundaries.

fn router_fluid_level_floodedness( &self, cache: &mut Self::ColumnCache, x: i32, y: i32, z: i32, ) -> f32

Fluid level floodedness for aquifers.

fn router_fluid_level_spread( &self, cache: &mut Self::ColumnCache, x: i32, y: i32, z: i32, ) -> f32

Fluid level spread for aquifers.

fn router_lava( &self, cache: &mut Self::ColumnCache, x: i32, y: i32, z: i32, ) -> f32

Lava placement noise for aquifers.

fn router_vein_toggle( &self, cache: &mut Self::ColumnCache, x: i32, y: i32, z: i32, ) -> f32

Vein toggle (sign determines copper vs iron).

fn router_vein_ridged( &self, cache: &mut Self::ColumnCache, x: i32, y: i32, z: i32, ) -> f32

Vein ridged noise for ore placement.

fn router_vein_gap( &self, cache: &mut Self::ColumnCache, x: i32, y: i32, z: i32, ) -> f32

Vein gap noise for ore vs filler placement.

fn router_preliminary_surface_level( &self, cache: &mut Self::ColumnCache, x: i32, y: i32, z: i32, ) -> f32

Preliminary surface level (cached in column cache).

fn router_erosion( &self, cache: &mut Self::ColumnCache, x: i32, y: i32, z: i32, ) -> f32

Erosion value (cached in column cache).

fn router_continentalness( &self, cache: &mut Self::ColumnCache, x: i32, y: i32, z: i32, ) -> f32

Continentalness value (cached in column cache).

fn router_temperature( &self, cache: &mut Self::ColumnCache, x: i32, y: i32, z: i32, ) -> f32

Temperature value (cached in column cache).

fn router_vegetation( &self, cache: &mut Self::ColumnCache, x: i32, y: i32, z: i32, ) -> f32

Vegetation/humidity value (cached in column cache).

fn router_ridges( &self, cache: &mut Self::ColumnCache, x: i32, y: i32, z: i32, ) -> f32

Ridges/weirdness value (cached in column cache).

fn interpolated_count() -> usize

Total number of independently interpolated channels across all router entries (final_density + vein_toggle + vein_ridged).

fn vein_interp_enabled() -> bool

Whether vein functions have interpolation channels.

fn final_density_nonpositive_channels() -> Option<&'static [usize]>

Interpolated channels that, when <= 0 at a block, prove its combined final density is not positive. Cell corners alone are insufficient for Vanilla’s repeated-addition interpolation. Derived by the transpiler from the final-density tree; None when no such proof exists.

fn compute_noise_column( &self, x: i32, block_ys: &[i32], z: i32, out: &mut [f32], )

Compute blended noise for an entire column of Y values.

fn fill_cell_corner_densities( &self, cache: &mut Self::ColumnCache, x: i32, y: i32, z: i32, blended_noise_value: f32, out: &mut [f32], )

Evaluate the inner functions of all Interpolated markers at a cell corner.

fn fill_cell_corner_densities_y_simd<const N: usize>( &self, cache: &mut Self::ColumnCache, x: i32, ys: [i32; N], z: i32, blended_noise_values: [f32; N], out: &mut [f32], )

Evaluate a batch of Y corners at the same X/Z position.

fn combine_interpolated( &self, cache: &mut Self::ColumnCache, interpolated: &[f32], x: i32, y: i32, z: i32, ) -> f32

Combine trilinearly interpolated values for final_density.

fn combine_vein_toggle( &self, cache: &mut Self::ColumnCache, interpolated: &[f32], x: i32, y: i32, z: i32, ) -> f32

Combine trilinearly interpolated values for vein_toggle.

fn combine_vein_ridged( &self, cache: &mut Self::ColumnCache, interpolated: &[f32], x: i32, y: i32, z: i32, ) -> f32

Combine trilinearly interpolated values for vein_ridged.

fn surface_noise_ids() -> &'static [&'static str]

Noise IDs referenced by this dimension’s surface rule NoiseThreshold conditions. Used to construct the SurfaceSystem’s condition noises.

fn surface_gradient_ids() -> &'static [&'static str]

Random IDs referenced by this dimension’s surface rule VerticalGradient conditions. Used to construct reusable positional random factories.

fn surface_rule_block_states() -> &'static [BlockStateId]

Block states returned by this dimension’s generated surface rules.

fn surface_rule_uses_biome() -> bool

Whether the generated surface rule reads biome-dependent context.

fn surface_rule_biome_sets() -> &'static [Box<[u16]>]

Distinct biome_is sets the generated surface rule tests, as biome registry ids. Together with a biome’s temperature parameters these are everything the rule can observe about a biome.

fn surface_rule_below_preliminary_surface() -> &'static PartialSurfaceRule

The surface rule reduced to what is decidable from Y and biome below the preliminary surface.

fn surface_rule_uses_preliminary_surface() -> bool

Whether the generated surface rule reads preliminary surface level.

fn surface_rule_uses_surface_secondary() -> bool

Whether the generated surface rule reads surface secondary noise.

fn surface_rule_uses_steep() -> bool

Whether the generated surface rule reads steep-column context.

fn try_apply_surface_rule( ctx: &mut SurfaceRuleContext<'_>, ) -> Option<BlockStateId>

Apply the transpiled surface rule at the given context position.

fn material_ore_vein_value_count() -> usize

Number of prefilled density/richness values for this dimension’s material ore rules.

fn material_ore_vein_value_height() -> usize

Height of the prefilled Y prefix, starting at NoiseSettings::MIN_Y. Keep it within HEIGHT; every omitted ore density must be <= 0.0.

fn fill_material_ore_vein_values( &self, cache: &mut Self::ColumnCache, interpolated: &[f32], x: i32, y: i32, z: i32, out: &mut [f32], )

Fill one block’s material ore density/richness values.

fn fill_prefilled_material_ore_vein_results( &self, cache: &mut Self::ColumnCache, ore_veinifier: &OreVeinifier, values: &[f32], x: i32, y: i32, z: i32, out: &mut [Option<BlockStateId>], )

Evaluates each ore-vein node from this dimension’s material rule using density/richness values prefilled for this exact block position.