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, ) -> f64

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

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

Depth from surface (used for terrain shaping).

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

Barrier noise for aquifer boundaries.

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

Fluid level floodedness for aquifers.

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

Fluid level spread for aquifers.

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

Lava placement noise for aquifers.

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

Vein toggle (sign determines copper vs iron).

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

Vein ridged noise for ore placement.

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

Vein gap noise for ore vs filler placement.

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

Erosion value (cached in column cache).

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

Continentalness value (cached in column cache).

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

Temperature value (cached in column cache).

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

Vegetation/humidity value (cached in column cache).

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

Ridges/weirdness value (cached in column cache).

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

Preliminary surface level (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 compute_noise_column( &self, x: i32, block_ys: &[i32], z: i32, out: &mut [f64], )

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: f64, out: &mut [f64], )

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

fn fill_cell_corner_densities_4x( &self, cache: &mut Self::ColumnCache, x: i32, ys: f64x4, z: i32, blended_noise_values: f64x4, out: &mut [f64], )

SIMD form of fill_cell_corner_densities that batches 4 cell-corner Y values at fixed (x, z).

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

Combine trilinearly interpolated values for final_density.

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

Combine trilinearly interpolated values for vein_toggle.

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

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_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.