Struct FeatureDecorationRunner 

pub(crate) struct FeatureDecorationRunner {
    pub(super) sorter: FeatureSorter,
    source_biome_lookup: Box<[bool]>,
}

Runs the structure-piece and placed-feature decoration pass for a generator.

Fields

sorter: FeatureSorter

source_biome_lookup: Box<[bool]>

Implementations

impl FeatureDecorationRunner

pub(super) fn place_configured_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, feature: &ConfiguredFeatureRef, origin: BlockPos, biome_zoom_seed: i64, ) -> bool

pub(super) fn place_configured_feature_kind( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, kind: &ConfiguredFeatureKind, origin: BlockPos, biome_zoom_seed: i64, ) -> bool

pub(super) fn configured_feature_kind( feature: &ConfiguredFeatureRef, ) -> &ConfiguredFeatureKind

fn configured_feature_placer( kind: &ConfiguredFeatureKind, ) -> for<'a, 'region> fn(&mut ConfiguredFeaturePlaceContext<'a, 'region>, &ConfiguredFeatureKind) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_bamboo_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, config: &BambooConfiguration, origin: BlockPos, ) -> bool

fn place_bamboo_podzol_disc( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, origin: BlockPos, )

fn bamboo_trunk_state() -> BlockStateId

fn bamboo_final_large_state() -> BlockStateId

fn bamboo_top_large_state() -> BlockStateId

fn bamboo_top_small_state() -> BlockStateId

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_basalt_columns_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, config: &BasaltColumnsConfiguration, origin: BlockPos, ) -> bool

fn place_basalt_column( region: &mut WorldGenRegion<'_>, lava_sea_level: i32, origin: BlockPos, column_height: i32, reach: i32, ) -> bool

fn find_basalt_column_surface( region: &WorldGenRegion<'_>, lava_sea_level: i32, cursor: BlockPos, limit: i32, ) -> Option<BlockPos>

fn find_basalt_column_air( region: &WorldGenRegion<'_>, cursor: BlockPos, limit: i32, ) -> Option<BlockPos>

fn can_place_basalt_column_at( region: &WorldGenRegion<'_>, lava_sea_level: i32, pos: BlockPos, ) -> bool

fn is_air_or_lava_ocean( region: &WorldGenRegion<'_>, lava_sea_level: i32, pos: BlockPos, ) -> bool

fn basalt_columns_cannot_place_on(block: BlockRef) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_basalt_pillar_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, origin: BlockPos, ) -> bool

pub(in worldgen::feature) fn place_basalt_pillar_base_hangoff( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, basalt: BlockStateId, pos: BlockPos, )

pub(in worldgen::feature) fn place_basalt_pillar_hangoff( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, basalt: BlockStateId, pos: BlockPos, ) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_block_blob_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &BlockBlobConfiguration, origin: BlockPos, ) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_block_column_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &BlockColumnConfiguration, origin: BlockPos, ) -> bool

pub(in worldgen::feature) fn truncate_block_column_layers( layer_heights: &mut [i32], total_height: i32, new_height: i32, prioritize_tip: bool, )

impl FeatureDecorationRunner

pub(in worldgen::feature) fn set_loot_table_block_entity( region: &WorldGenRegion<'_>, pos: BlockPos, block_entity_type: BlockEntityTypeRef, state: BlockStateId, loot_table: &'static str, seed: i64, )

pub(in worldgen::feature) fn set_empty_block_entity( region: &WorldGenRegion<'_>, pos: BlockPos, block_entity_type: BlockEntityTypeRef, state: BlockStateId, )

pub(in worldgen::feature) fn set_brushable_loot_table( region: &WorldGenRegion<'_>, pos: BlockPos, state: BlockStateId, loot_table: &'static str, )

pub(in worldgen::feature) fn set_spawner_entity( region: &WorldGenRegion<'_>, pos: BlockPos, state: BlockStateId, entity_id: &'static str, )

pub(in worldgen::feature) fn set_end_gateway_block_entity( region: &WorldGenRegion<'_>, pos: BlockPos, state: BlockStateId, exit: Option<BlockPos>, exact: bool, )

pub(in worldgen::feature) fn safe_set_feature_block( region: &WorldGenRegion<'_>, pos: BlockPos, state: BlockStateId, ) -> bool

pub(in worldgen::feature) fn feature_can_replace( state: BlockStateId, ) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_block_pile_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &BlockPileConfiguration, origin: BlockPos, ) -> bool

pub(in worldgen::feature) fn try_place_block_pile_block( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &BlockPileConfiguration, pos: BlockPos, )

pub(in worldgen::feature) fn block_pile_may_place_on( region: &WorldGenRegion<'_>, random: &mut WorldgenRandom, pos: BlockPos, ) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_blue_ice_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, origin: BlockPos, ) -> bool

fn is_water(state: BlockStateId) -> bool

pub(in worldgen::feature) const fn blue_ice_xz_diff( y_offset: i32, ) -> i32

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_bonus_chest_feature( region: &WorldGenRegion<'_>, random: &mut WorldgenRandom, origin: BlockPos, ) -> bool

fn shuffled_inclusive_range( start: i32, end: i32, random: &mut WorldgenRandom, ) -> Vec<i32>

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_chorus_plant_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, origin: BlockPos, ) -> bool

fn generate_chorus_plant( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, target: BlockPos, max_horizontal_spread: i32, )

fn grow_chorus_tree_recursive( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, current: BlockPos, start_pos: BlockPos, max_horizontal_spread: i32, depth: i32, )

fn chorus_all_neighbors_empty( region: &WorldGenRegion<'_>, pos: BlockPos, ignore: Option<Direction>, ) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_coral_claw_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, origin: BlockPos, ) -> bool

pub(in worldgen::feature) fn place_coral_mushroom_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, origin: BlockPos, ) -> bool

pub(in worldgen::feature) fn place_coral_tree_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, origin: BlockPos, ) -> bool

fn place_coral_block( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, pos: BlockPos, state: BlockStateId, ) -> bool

pub(super) fn random_block_from_tag( registry: &Registry, random: &mut WorldgenRandom, tag: &Identifier, ) -> Option<BlockRef>

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_delta_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &DeltaFeatureConfiguration, origin: BlockPos, ) -> bool

fn delta_is_clear( region: &WorldGenRegion<'_>, pos: BlockPos, contents: BlockStateId, ) -> bool

fn delta_cannot_replace(block: BlockRef) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_desert_well_feature( region: &WorldGenRegion<'_>, random: &mut WorldgenRandom, origin: BlockPos, ) -> bool

fn place_suspicious_sand(region: &WorldGenRegion<'_>, pos: BlockPos)

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_disk_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &DiskConfiguration, origin: BlockPos, ) -> bool

pub(in worldgen::feature) fn place_disk_column( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &DiskConfiguration, top: i32, bottom: i32, column_pos: BlockPos, ) -> bool

pub(in worldgen::feature) fn mark_above_for_postprocessing( region: &WorldGenRegion<'_>, pos: BlockPos, )

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_dripstone_cluster_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, config: &DripstoneClusterConfiguration, origin: BlockPos, ) -> bool

fn place_dripstone_cluster_column( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, pos: BlockPos, dx: i32, dz: i32, chance_of_water: f32, chance_of_stalagmite_or_stalactite: f64, cluster_height: i32, density: f32, config: &DripstoneClusterConfiguration, )

pub(in worldgen::feature) fn scan_dripstone_column<I, V>( region: &WorldGenRegion<'_>, pos: BlockPos, search_range: i32, inside_column: I, valid_edge: V, ) -> Option<DripstoneColumn>

where I: Fn(BlockStateId) -> bool, V: Fn(BlockStateId) -> bool,

fn scan_dripstone_column_direction<I, V>( region: &WorldGenRegion<'_>, pos: BlockPos, search_range: i32, inside_column: &I, valid_edge: &V, direction: Direction, ) -> Option<i32>

where I: Fn(BlockStateId) -> bool, V: Fn(BlockStateId) -> bool,

fn dripstone_cluster_height( random: &mut WorldgenRandom, dx: i32, dz: i32, density: f32, max_height: i32, config: &DripstoneClusterConfiguration, ) -> i32

fn can_place_dripstone_pool(region: &WorldGenRegion<'_>, pos: BlockPos) -> bool

fn can_be_adjacent_to_dripstone_pool_water( region: &WorldGenRegion<'_>, pos: BlockPos, ) -> bool

fn replace_blocks_with_dripstone_blocks( region: &mut WorldGenRegion<'_>, pos: BlockPos, max_count: i32, direction: Direction, )

fn chance_of_stalagmite_or_stalactite( x_radius: i32, z_radius: i32, dx: i32, dz: i32, config: &DripstoneClusterConfiguration, ) -> f64

pub(in worldgen::feature) fn is_neither_empty_nor_water( state: BlockStateId, ) -> bool

pub(in worldgen::feature) fn is_empty_or_water_or_lava( state: BlockStateId, ) -> bool

pub(in worldgen::feature) fn is_lava( region: &WorldGenRegion<'_>, pos: BlockPos, ) -> bool

pub(in worldgen::feature) fn clamped_map_f32( value: f32, old_min: f32, old_max: f32, new_min: f32, new_max: f32, ) -> f32

fn clamped_map_f64( value: f64, old_min: f64, old_max: f64, new_min: f64, new_max: f64, ) -> f64

fn random_between_biased( random: &mut WorldgenRandom, min: f32, max: f32, mean: f32, deviation: f32, ) -> f32

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_large_dripstone_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, config: &LargeDripstoneConfiguration, origin: BlockPos, ) -> bool

pub(in worldgen::feature) fn dripstone_height( xz_distance_from_center: f64, dripstone_radius: f64, scale: f64, bluntness: f64, ) -> f64

fn is_circle_mostly_embedded_in_stone( region: &WorldGenRegion<'_>, center: BlockPos, xz_radius: i32, ) -> bool

fn random_f32_between(random: &mut WorldgenRandom, min: f32, max: f32) -> f32

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_pointed_dripstone_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, config: &PointedDripstoneConfiguration, origin: BlockPos, ) -> bool

pub(in worldgen::feature) fn pointed_dripstone_tip_direction( region: &WorldGenRegion<'_>, random: &mut WorldgenRandom, pos: BlockPos, ) -> Option<Direction>

fn create_patch_of_dripstone_blocks( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, pos: BlockPos, config: &PointedDripstoneConfiguration, )

pub(in worldgen::feature) fn grow_pointed_dripstone( region: &mut WorldGenRegion<'_>, start_pos: BlockPos, tip_direction: Direction, height: i32, merged_tip: bool, )

pub(in worldgen::feature) fn build_base_to_tip_dripstone_column( direction: Direction, total_length: i32, merged_tip: bool, consumer: impl FnMut(BlockStateId), )

pub(in worldgen::feature) fn place_dripstone_block_if_possible( region: &mut WorldGenRegion<'_>, pos: BlockPos, ) -> bool

pub(in worldgen::feature) fn create_pointed_dripstone( direction: Direction, thickness: SpeleothemThickness, ) -> BlockStateId

pub(in worldgen::feature) fn is_dripstone_base( state: BlockStateId, ) -> bool

pub(in worldgen::feature) fn is_empty_or_water( state: BlockStateId, ) -> bool

fn random_vanilla_direction(random: &mut WorldgenRandom) -> Direction

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_end_gateway_feature( region: &WorldGenRegion<'_>, config: &EndGatewayConfiguration, origin: BlockPos, ) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_end_island_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, origin: BlockPos, ) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_end_platform_feature( region: &mut WorldGenRegion<'_>, origin: BlockPos, ) -> bool

pub(in worldgen::feature) fn create_end_platform( region: &mut WorldGenRegion<'_>, origin: BlockPos, )

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_end_spike_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, config: &EndSpikeConfiguration, origin: BlockPos, ) -> bool

fn end_spikes_for_level(seed: i64) -> Vec<EndSpike>

const fn end_spike_center_is_within_chunk( spike: &EndSpike, origin: BlockPos, ) -> bool

fn place_end_spike( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, config: &EndSpikeConfiguration, spike: &EndSpike, )

fn place_end_spike_body(region: &mut WorldGenRegion<'_>, spike: &EndSpike)

fn end_spike_inside_radius( spike: &EndSpike, pos: BlockPos, radius_squared_plus_one: i32, ) -> bool

fn place_end_spike_cage(region: &mut WorldGenRegion<'_>, spike: &EndSpike)

fn end_spike_iron_bars_state( x_edge: bool, z_edge: bool, dx: i32, dz: i32, ) -> BlockStateId

fn place_end_spike_crystal( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, config: &EndSpikeConfiguration, spike: &EndSpike, )

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_fossil_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &FossilConfiguration, origin: BlockPos, ) -> bool

fn load_fossil_template( registry: &Registry, key: &Identifier, ) -> StructureTemplate

fn structure_processors<'a>( registry: &'a Registry, key: &Identifier, context: &str, ) -> &'a [StructureProcessorKind]

fn lowest_fossil_surface_y( region: &WorldGenRegion<'_>, low_corner: BlockPos, size_x: i32, size_z: i32, initial_y: i32, ) -> i32

const fn fossil_bounding_box( region: &WorldGenRegion<'_>, origin: BlockPos, ) -> BoundingBox

fn count_empty_corners( region: &WorldGenRegion<'_>, bounding_box: BoundingBox, ) -> i32

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_freeze_top_layer_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, origin: BlockPos, biome_zoom_seed: i64, ) -> bool

fn set_snowy_below(region: &mut WorldGenRegion<'_>, below_pos: BlockPos)

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_geode_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &GeodeConfiguration, origin: BlockPos, ) -> bool

fn geode_noise(seed: i64) -> NormalNoise

fn geode_distribution_points( region: &WorldGenRegion<'_>, random: &mut WorldgenRandom, registry: &Registry, config: &GeodeConfiguration, origin: BlockPos, num_points: i32, ) -> Option<Vec<(BlockPos, i32)>>

fn geode_crack_points( random: &mut WorldgenRandom, origin: BlockPos, num_points: i32, should_generate_crack: bool, ) -> Vec<(BlockPos, i32)>

fn geode_distance_sum( pos: BlockPos, points: &[(BlockPos, i32)], noise_offset: f64, offset: impl Fn(i32) -> i32, ) -> f64

fn block_pos_distance_squared(left: BlockPos, right: BlockPos) -> f64

fn safe_set_geode_block( region: &mut WorldGenRegion<'_>, registry: &Registry, pos: BlockPos, state: BlockStateId, cannot_replace: &Identifier, )

fn schedule_geode_adjacent_fluid_ticks( region: &WorldGenRegion<'_>, pos: BlockPos, )

fn place_geode_crystals( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, blocks: &GeodeBlockSettings, potential_crystal_placements: &[BlockPos], )

fn can_grow_amethyst_cluster_at(state: BlockStateId) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_glowstone_blob_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, origin: BlockPos, ) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_huge_fungus_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &HugeFungusConfiguration, origin: BlockPos, ) -> bool

fn place_huge_fungus_stem( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &HugeFungusConfiguration, origin: BlockPos, stem_state: BlockStateId, total_height: i32, is_huge: bool, )

fn place_huge_fungus_hat( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &HugeFungusConfiguration, origin: BlockPos, hat_state: BlockStateId, decor_state: BlockStateId, total_height: i32, is_huge: bool, )

fn place_huge_fungus_hat_block( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, pos: BlockPos, hat_state: BlockStateId, decor_state: BlockStateId, decor_block_probability: f32, hat_block_probability: f32, vines_probability: f32, )

fn place_huge_fungus_hat_drop_block( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, pos: BlockPos, hat_state: BlockStateId, place_vines: bool, )

fn try_place_huge_fungus_weeping_vines( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, hat_pos: BlockPos, )

fn huge_fungus_is_replaceable( region: &WorldGenRegion<'_>, registry: &Registry, pos: BlockPos, config: &HugeFungusConfiguration, check_non_replaceable_plants: bool, ) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_huge_brown_mushroom_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &HugeMushroomConfiguration, origin: BlockPos, ) -> bool

pub(in worldgen::feature) fn place_huge_red_mushroom_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &HugeMushroomConfiguration, origin: BlockPos, ) -> bool

fn place_huge_mushroom_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &HugeMushroomConfiguration, origin: BlockPos, kind: HugeMushroomKind, ) -> bool

fn huge_mushroom_tree_height(random: &mut WorldgenRandom) -> i32

fn is_valid_huge_mushroom_position( region: &WorldGenRegion<'_>, registry: &Registry, config: &HugeMushroomConfiguration, origin: BlockPos, tree_height: i32, kind: HugeMushroomKind, ) -> bool

fn make_brown_mushroom_cap( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &HugeMushroomConfiguration, origin: BlockPos, tree_height: i32, )

fn make_red_mushroom_cap( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &HugeMushroomConfiguration, origin: BlockPos, tree_height: i32, )

fn place_huge_mushroom_trunk( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &HugeMushroomConfiguration, origin: BlockPos, tree_height: i32, )

fn place_huge_mushroom_block( region: &mut WorldGenRegion<'_>, pos: BlockPos, state: BlockStateId, )

fn has_mushroom_horizontal_properties(state: BlockStateId) -> bool

fn set_mushroom_horizontal_properties( state: BlockStateId, west: bool, east: bool, north: bool, south: bool, ) -> BlockStateId

const fn huge_mushroom_tree_radius_for_height( kind: HugeMushroomKind, _trunk_height: i32, tree_height: i32, leaf_radius: i32, y_offset: i32, ) -> i32

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_iceberg_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &BlockStateData, origin: BlockPos, ) -> bool

fn generate_iceberg_cut_out( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, width: i32, height: i32, global_origin: BlockPos, is_ellipse: bool, shape_ellipse_a: i32, shape_angle: f64, shape_ellipse_c: i32, )

fn carve_iceberg( region: &mut WorldGenRegion<'_>, radius: i32, y_offset: i32, global_origin: BlockPos, under_water: bool, angle: f64, local_origin: BlockPos, shape_ellipse_a: i32, shape_ellipse_c: i32, )

fn remove_floating_snow_layer(region: &mut WorldGenRegion<'_>, pos: BlockPos)

fn generate_iceberg_block( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, origin: BlockPos, height: i32, x_offset: i32, y_offset: i32, z_offset: i32, radius: i32, a: i32, is_ellipse: bool, shape_ellipse_c: i32, shape_angle: f64, snow_on_top: bool, main_block_state: BlockStateId, )

fn set_iceberg_shape_block( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, pos: BlockPos, height_difference: i32, height: i32, is_ellipse: bool, snow_on_top: bool, main_block_state: BlockStateId, )

const fn get_ellipse_c(y_offset: i32, height: i32, shape_ellipse_c: i32) -> i32

fn signed_distance_circle( x_offset: i32, z_offset: i32, origin: BlockPos, radius: i32, random: &mut WorldgenRandom, ) -> f64

fn signed_distance_ellipse( x_offset: i32, z_offset: i32, origin: BlockPos, a: i32, c: i32, angle: f64, ) -> f64

fn height_dependent_radius_round( random: &mut WorldgenRandom, y_offset: i32, height: i32, width: i32, ) -> i32

fn height_dependent_radius_ellipse( y_offset: i32, height: i32, width: i32, ) -> i32

fn height_dependent_radius_steep( random: &mut WorldgenRandom, y_offset: i32, height: i32, width: i32, ) -> i32

fn is_iceberg_state(state: BlockStateId) -> bool

fn smooth_iceberg( region: &mut WorldGenRegion<'_>, origin: BlockPos, width: i32, height: i32, is_ellipse: bool, shape_ellipse_a: i32, )

fn set_iceberg_block( region: &mut WorldGenRegion<'_>, pos: BlockPos, state: BlockStateId, )

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_kelp_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, origin: BlockPos, ) -> bool

fn aged_kelp_head( state: BlockStateId, random: &mut WorldgenRandom, ) -> BlockStateId

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_lake_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &LakeConfiguration, origin: BlockPos, biome_zoom_seed: i64, ) -> bool

fn carve_lake_ellipsoid(random: &mut WorldgenRandom, grid: &mut [bool])

fn lake_boundary_valid( region: &WorldGenRegion<'_>, registry: &Registry, config: &LakeConfiguration, grid: &[bool], origin: BlockPos, fluid: BlockStateId, ) -> bool

fn place_lake_contents( region: &mut WorldGenRegion<'_>, registry: &Registry, config: &LakeConfiguration, grid: &[bool], origin: BlockPos, fluid: BlockStateId, )

fn place_lake_barrier( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &LakeConfiguration, grid: &[bool], origin: BlockPos, )

fn freeze_lake_surface( region: &mut WorldGenRegion<'_>, registry: &Registry, config: &LakeConfiguration, biome_zoom_seed: i64, origin: BlockPos, )

const fn lake_is_boundary(grid: &[bool], x: i32, y: i32, z: i32) -> bool

const fn lake_index(x: i32, y: i32, z: i32) -> usize

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_monster_room_feature( region: &WorldGenRegion<'_>, random: &mut WorldgenRandom, origin: BlockPos, ) -> bool

fn reorient_chest( region: &WorldGenRegion<'_>, pos: BlockPos, state: BlockStateId, ) -> BlockStateId

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_multiface_growth_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &MultifaceGrowthConfiguration, origin: BlockPos, ) -> bool

fn place_multiface_growth_if_possible( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, pos: BlockPos, old_state: BlockStateId, config: &ResolvedMultifaceGrowth<'_>, placement_directions: &[Direction], ) -> bool

fn spread_multiface_from_face_toward_random_direction( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, config: &ResolvedMultifaceGrowth<'_>, state: BlockStateId, pos: BlockPos, starting_face: Direction, post_process: bool, ) -> Option<MultifaceSpreadPos>

fn spread_multiface_from_face_toward_direction( region: &mut WorldGenRegion<'_>, config: &ResolvedMultifaceGrowth<'_>, state: BlockStateId, pos: BlockPos, starting_face: Direction, spread_direction: Direction, post_process: bool, ) -> Option<MultifaceSpreadPos>

fn multiface_spread_from_face_toward_direction( region: &WorldGenRegion<'_>, config: &ResolvedMultifaceGrowth<'_>, state: BlockStateId, pos: BlockPos, starting_face: Direction, spread_direction: Direction, ) -> Option<MultifaceSpreadPos>

fn spread_multiface_to_face( region: &mut WorldGenRegion<'_>, config: &ResolvedMultifaceGrowth<'_>, spread_pos: &MultifaceSpreadPos, post_process: bool, ) -> bool

fn multiface_can_spread_into( region: &WorldGenRegion<'_>, config: &ResolvedMultifaceGrowth<'_>, source_pos: BlockPos, spread_pos: &MultifaceSpreadPos, ) -> bool

fn multiface_state_can_be_replaced( region: &WorldGenRegion<'_>, config: &ResolvedMultifaceGrowth<'_>, source_pos: BlockPos, placement_pos: BlockPos, placement_direction: Direction, existing_state: BlockStateId, ) -> bool

fn sculk_vein_state_can_be_replaced( region: &WorldGenRegion<'_>, source_pos: BlockPos, placement_pos: BlockPos, placement_direction: Direction, existing_state: BlockStateId, ) -> bool

fn default_multiface_state_can_be_replaced( config: &ResolvedMultifaceGrowth<'_>, existing_state: BlockStateId, ) -> bool

fn default_multiface_state_can_be_replaced_for_block( existing_state: BlockStateId, place_block: BlockRef, ) -> bool

fn multiface_state_for_placement( region: &WorldGenRegion<'_>, config: &ResolvedMultifaceGrowth<'_>, old_state: BlockStateId, placement_pos: BlockPos, placement_direction: Direction, ) -> Option<BlockStateId>

fn multiface_is_valid_state_for_placement( region: &WorldGenRegion<'_>, config: &ResolvedMultifaceGrowth<'_>, old_state: BlockStateId, placement_pos: BlockPos, placement_direction: Direction, ) -> bool

fn resolve_multiface_growth_config<'a>( registry: &Registry, config: &'a MultifaceGrowthConfiguration, ) -> ResolvedMultifaceGrowth<'a>

fn multiface_can_be_placed_on( config: &ResolvedMultifaceGrowth<'_>, state: BlockStateId, ) -> bool

fn multiface_is_place_block( config: &ResolvedMultifaceGrowth<'_>, state: BlockStateId, ) -> bool

fn multiface_is_other_block_valid_as_source( config: &ResolvedMultifaceGrowth<'_>, state: BlockStateId, ) -> bool

const fn multiface_spread_types( _config: &ResolvedMultifaceGrowth<'_>, ) -> [MultifaceSpreadType; 3]

fn multiface_spread_pos( pos: BlockPos, spread_direction: Direction, from_face: Direction, spread_type: MultifaceSpreadType, ) -> MultifaceSpreadPos

fn multiface_shuffled_valid_directions( random: &mut WorldgenRandom, config: &ResolvedMultifaceGrowth<'_>, ) -> SmallVec<[Direction; 6]>

fn multiface_shuffled_valid_directions_except( random: &mut WorldgenRandom, config: &ResolvedMultifaceGrowth<'_>, excluded: Direction, ) -> SmallVec<[Direction; 6]>

fn multiface_valid_directions( config: &ResolvedMultifaceGrowth<'_>, ) -> SmallVec<[Direction; 6]>

fn shuffle_multiface_directions( random: &mut WorldgenRandom, directions: &mut [Direction], )

fn multiface_has_face(state: BlockStateId, direction: Direction) -> bool

const fn multiface_face_property(direction: Direction) -> &'static BoolProperty

fn multiface_is_air_or_water(state: BlockStateId) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_nether_forest_vegetation_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &NetherForestVegetationConfiguration, origin: BlockPos, ) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_ore_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &OreConfiguration, origin: BlockPos, ) -> bool

pub(in worldgen::feature) fn do_place_ore( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &OreConfiguration, x0: f64, x1: f64, z0: f64, z1: f64, y0: f64, y1: f64, x_start: i32, y_start: i32, z_start: i32, size_xz: i32, size_y: i32, ) -> bool

fn collect_ore_candidates<const PROFILE: bool>( sections: &mut WorldGenBulkSectionAccess<'_, '_, '_>, registry: &Registry, random: &mut WorldgenRandom, config: &OreConfiguration, targets: &ResolvedOreTargets, search_volume: OreSearchVolume, vein_nodes: SmallVec<[[f64; 4]; 32]>, x_start: i32, y_start: i32, z_start: i32, min_y: i32, height: i32, batch_no_air_exposure: bool, tested: &mut OreTestedPositions, pending_no_air_sections: &mut SmallVec<[PendingOreSection; 8]>, ) -> u64

pub(in worldgen::feature) fn place_scattered_ore_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &OreConfiguration, origin: BlockPos, ) -> bool

pub(in worldgen::feature) fn random_scattered_ore_offset( random: &mut WorldgenRandom, max_distance: i32, ) -> i32

pub(in worldgen::feature) fn java_round_f32( value: f32, ) -> i32

fn try_place_resolved_ore_block( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &OreConfiguration, targets: &ResolvedOreTargets, pos: BlockPos, ) -> bool

fn try_place_ore_block_in_bulk( sections: &mut WorldGenBulkSectionAccess<'_, '_, '_>, registry: &Registry, random: &mut WorldgenRandom, config: &OreConfiguration, targets: &ResolvedOreTargets, pos: BlockPos, ) -> bool

fn can_place_resolved_ore( region: &WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &OreConfiguration, target: &ResolvedOreTarget, pos: BlockPos, block_id: usize, ) -> bool

fn can_place_resolved_ore_in_bulk( sections: &mut WorldGenBulkSectionAccess<'_, '_, '_>, registry: &Registry, random: &mut WorldgenRandom, config: &OreConfiguration, target: &ResolvedOreTarget, pos: BlockPos, block_id: usize, ) -> bool

pub(in worldgen::feature) fn should_skip_air_check( random: &mut WorldgenRandom, discard_chance_on_air_exposure: f32, ) -> bool

pub(in worldgen::feature) fn is_adjacent_to_air( region: &WorldGenRegion<'_>, registry: &Registry, pos: BlockPos, ) -> bool

pub(in worldgen::feature) fn is_adjacent_to_air_in_bulk( sections: &mut WorldGenBulkSectionAccess<'_, '_, '_>, registry: &Registry, pos: BlockPos, ) -> bool

pub(in worldgen::feature) fn is_air_block_state( registry: &Registry, state: BlockStateId, ) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_netherrack_replace_blobs_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &NetherrackReplaceBlobsConfiguration, origin: BlockPos, ) -> bool

fn find_replace_blobs_target( region: &WorldGenRegion<'_>, cursor: BlockPos, target: BlockStateId, ) -> Option<BlockPos>

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_sculk_patch_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &SculkPatchConfiguration, origin: BlockPos, ) -> bool

fn can_sculk_spread_from(region: &WorldGenRegion<'_>, origin: BlockPos) -> bool

fn sculk_update_cursors( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, origin: BlockPos, spreader: &mut SculkSpreader, spread_veins: bool, )

fn sculk_update_cursor( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, origin: BlockPos, spreader: &SculkSpreader, spread_veins: bool, cursor: &mut SculkChargeCursor, )

fn sculk_attempt_spread_vein( region: &mut WorldGenRegion<'_>, pos: BlockPos, state: BlockStateId, facings: Option<&[Direction]>, post_process: bool, behavior: SculkBehaviorKind, ) -> bool

fn sculk_attempt_use_charge( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, origin: BlockPos, spreader: &SculkSpreader, spread_veins: bool, cursor: &SculkChargeCursor, behavior: SculkBehaviorKind, ) -> i32

fn sculk_block_attempt_use_charge( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, origin: BlockPos, spreader: &SculkSpreader, cursor: &SculkChargeCursor, ) -> i32

fn sculk_vein_attempt_use_charge( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, spreader: &SculkSpreader, spread_veins: bool, cursor: &SculkChargeCursor, ) -> i32

fn sculk_vein_attempt_place_sculk( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, spreader: &SculkSpreader, pos: BlockPos, ) -> bool

fn sculk_vein_spread_all( region: &mut WorldGenRegion<'_>, state: BlockStateId, pos: BlockPos, post_process: bool, same_space_only: bool, ) -> i64

fn sculk_vein_spread_from_face_toward_direction( region: &mut WorldGenRegion<'_>, state: BlockStateId, pos: BlockPos, starting_face: Direction, spread_direction: Direction, post_process: bool, same_space_only: bool, ) -> Option<SculkSpreadPos>

fn sculk_vein_get_spread_from_face_toward_direction( region: &WorldGenRegion<'_>, state: BlockStateId, pos: BlockPos, starting_face: Direction, spread_direction: Direction, same_space_only: bool, ) -> Option<SculkSpreadPos>

fn sculk_vein_spread_to_face( region: &mut WorldGenRegion<'_>, spread_pos: &SculkSpreadPos, post_process: bool, ) -> bool

fn sculk_vein_can_spread_into( region: &WorldGenRegion<'_>, source_pos: BlockPos, spread_pos: &SculkSpreadPos, ) -> bool

fn sculk_patch_vein_state_can_be_replaced( region: &WorldGenRegion<'_>, source_pos: BlockPos, placement_pos: BlockPos, placement_direction: Direction, existing_state: BlockStateId, ) -> bool

fn sculk_default_multiface_state_can_be_replaced_for_block( existing_state: BlockStateId, ) -> bool

fn sculk_vein_state_for_placement( region: &WorldGenRegion<'_>, old_state: BlockStateId, placement_pos: BlockPos, placement_direction: Direction, ) -> Option<BlockStateId>

fn sculk_vein_is_valid_state_for_placement( region: &WorldGenRegion<'_>, old_state: BlockStateId, placement_pos: BlockPos, placement_direction: Direction, ) -> bool

fn sculk_vein_regrow( region: &mut WorldGenRegion<'_>, pos: BlockPos, existing_state: BlockStateId, faces: &[Direction], ) -> bool

fn sculk_on_discharged( region: &mut WorldGenRegion<'_>, state: BlockStateId, pos: BlockPos, )

fn sculk_get_valid_movement_pos( region: &WorldGenRegion<'_>, pos: BlockPos, random: &mut WorldgenRandom, ) -> Option<BlockPos>

fn sculk_randomized_non_corner_neighbor_offsets( random: &mut WorldgenRandom, ) -> Vec<BlockPos>

fn sculk_is_movement_unobstructed( region: &WorldGenRegion<'_>, from: BlockPos, to: BlockPos, ) -> bool

fn sculk_is_unobstructed( region: &WorldGenRegion<'_>, from: BlockPos, direction: Direction, ) -> bool

const fn sculk_direction_from_axis_delta(axis: Axis, delta: i32) -> Direction

fn sculk_vein_has_substrate_access( region: &WorldGenRegion<'_>, state: BlockStateId, pos: BlockPos, ) -> bool

fn sculk_can_place_growth(region: &WorldGenRegion<'_>, pos: BlockPos) -> bool

fn sculk_random_growth_state( region: &WorldGenRegion<'_>, random: &mut WorldgenRandom, pos: BlockPos, is_world_generation: bool, ) -> BlockStateId

fn set_sculk_growth_block_entity( region: &WorldGenRegion<'_>, pos: BlockPos, state: BlockStateId, )

fn sculk_decay_penalty( spreader: &SculkSpreader, pos: BlockPos, origin: BlockPos, charge: i32, ) -> i32

fn sculk_closer_than(pos: BlockPos, origin: BlockPos, radius: i32) -> bool

fn sculk_horizontal_close_to_origin( pos: BlockPos, origin: BlockPos, radius: f64, ) -> bool

fn sculk_distance_squared(left: BlockPos, right: BlockPos) -> i64

fn sculk_cursor_is_pos_unreasonable(pos: BlockPos, origin: BlockPos) -> bool

const fn sculk_abs_diff(left: i32, right: i32) -> i32

fn sculk_update_decay_delay(behavior: SculkBehaviorKind, age: i32) -> i32

const fn sculk_spread_delay(_behavior: SculkBehaviorKind) -> i32

const fn sculk_can_change_block_state_on_spread( behavior: SculkBehaviorKind, ) -> bool

fn sculk_behavior(state: BlockStateId) -> SculkBehaviorKind

fn sculk_available_faces(state: BlockStateId) -> Vec<Direction>

fn sculk_vein_can_spread_from(state: BlockStateId, face: Direction) -> bool

fn sculk_vein_is_other_block_valid_as_source(state: BlockStateId) -> bool

fn sculk_vein_spread_pos( pos: BlockPos, spread_direction: Direction, from_face: Direction, spread_type: SculkSpreadType, ) -> SculkSpreadPos

fn sculk_vein_has_any_face(state: BlockStateId) -> bool

fn sculk_vein_has_face(state: BlockStateId, direction: Direction) -> bool

const fn sculk_vein_face_property(direction: Direction) -> &'static BoolProperty

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_sea_pickle_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, config: &SeaPickleConfiguration, origin: BlockPos, ) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_seagrass_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, config: &SeagrassConfiguration, origin: BlockPos, ) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_simple_block_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &SimpleBlockConfiguration, origin: BlockPos, ) -> bool

pub(in worldgen::feature) fn is_double_plant_block( block: BlockRef, ) -> bool

pub(in worldgen::feature) fn place_double_plant( region: &mut WorldGenRegion<'_>, state: BlockStateId, lower_pos: BlockPos, )

pub(in worldgen::feature) fn copy_waterlogged_from( region: &WorldGenRegion<'_>, pos: BlockPos, state: BlockStateId, ) -> BlockStateId

pub(in worldgen::feature) fn place_mossy_carpet( region: &mut WorldGenRegion<'_>, pos: BlockPos, )

pub(in worldgen::feature) fn create_mossy_carpet_topper( region: &mut WorldGenRegion<'_>, pos: BlockPos, ) -> BlockStateId

pub(in worldgen::feature) fn can_attach_to_multiface( region: &WorldGenRegion<'_>, pos: BlockPos, direction_towards_neighbor: Direction, ) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_speleothem_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, config: &SpeleothemConfiguration, origin: BlockPos, ) -> bool

pub(in worldgen::feature) fn place_speleothem_cluster_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, config: &SpeleothemClusterConfiguration, origin: BlockPos, ) -> bool

fn speleothem_tip_direction( region: &WorldGenRegion<'_>, random: &mut WorldgenRandom, config: &SpeleothemConfiguration, pos: BlockPos, ) -> Option<Direction>

fn create_patch_of_speleothem_base_blocks( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, pos: BlockPos, config: &SpeleothemConfiguration, )

fn place_speleothem_cluster_column( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, pos: BlockPos, dx: i32, dz: i32, chance_of_water: f32, chance_of_stalagmite_or_stalactite: f64, cluster_height: i32, density: f32, config: &SpeleothemClusterConfiguration, )

fn grow_speleothem( region: &mut WorldGenRegion<'_>, start_pos: BlockPos, tip_direction: Direction, height: i32, merged_tip: bool, base_block: BlockRef, pointed_block: BlockRef, replaceable_blocks: &BlockHolderSet, )

fn build_base_to_tip_speleothem_column( direction: Direction, total_length: i32, merged_tip: bool, pointed_block: BlockRef, consumer: impl FnMut(BlockStateId), )

fn create_pointed_speleothem( pointed_block: BlockRef, direction: Direction, thickness: SpeleothemThickness, ) -> BlockStateId

fn place_speleothem_base_block_if_possible( region: &mut WorldGenRegion<'_>, pos: BlockPos, base_block: BlockRef, replaceable_blocks: &BlockHolderSet, ) -> bool

fn is_speleothem_base( state: BlockStateId, base_block: BlockRef, replaceable_blocks: &BlockHolderSet, ) -> bool

fn can_place_speleothem_pool( region: &WorldGenRegion<'_>, pos: BlockPos, config: &SpeleothemClusterConfiguration, ) -> bool

fn can_be_adjacent_to_speleothem_pool_water( region: &WorldGenRegion<'_>, pos: BlockPos, ) -> bool

fn replace_blocks_with_speleothem_base_blocks( region: &mut WorldGenRegion<'_>, pos: BlockPos, max_count: i32, direction: Direction, config: &SpeleothemClusterConfiguration, )

fn speleothem_cluster_height( random: &mut WorldgenRandom, dx: i32, dz: i32, density: f32, max_height: i32, config: &SpeleothemClusterConfiguration, ) -> i32

fn chance_of_speleothem( x_radius: i32, z_radius: i32, dx: i32, dz: i32, config: &SpeleothemClusterConfiguration, ) -> f64

fn speleothem_random_between_biased( random: &mut WorldgenRandom, min: f32, max: f32, mean: f32, deviation: f32, ) -> f32

fn speleothem_is_empty_or_water(state: BlockStateId) -> bool

fn random_speleothem_direction(random: &mut WorldgenRandom) -> Direction

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_spike_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &SpikeConfiguration, origin: BlockPos, ) -> bool

fn place_spike_body( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &SpikeConfiguration, origin: BlockPos, height: i32, width: i32, spike_state: BlockStateId, )

fn place_spike_base( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &SpikeConfiguration, origin: BlockPos, width: i32, spike_state: BlockStateId, )

fn place_spike_block_if_replaceable( region: &mut WorldGenRegion<'_>, registry: &Registry, config: &SpikeConfiguration, pos: BlockPos, spike_state: BlockStateId, )

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_spring_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, config: &SpringConfiguration, origin: BlockPos, ) -> bool

impl FeatureDecorationRunner

pub(super) fn place_tree_decorators( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, decorators: &[TreeDecorator], placement: &mut TreePlacement, biome_zoom_seed: i64, )

fn place_alter_ground_tree_decorator( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, provider: &BlockStateProvider, placement: &mut TreePlacement, )

fn place_alter_ground_circle( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, provider: &BlockStateProvider, pos: BlockPos, placement: &mut TreePlacement, )

fn place_alter_ground_block_at( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, provider: &BlockStateProvider, pos: BlockPos, placement: &mut TreePlacement, )

fn place_on_ground_tree_decorator( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, decorator: &PlaceOnGroundDecorator, placement: &mut TreePlacement, )

fn attempt_place_tree_ground_decorator( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, provider: &BlockStateProvider, pos: BlockPos, placement: &mut TreePlacement, )

fn place_trunk_vine_tree_decorator( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, placement: &mut TreePlacement, )

fn place_leave_vine_tree_decorator( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, probability: f32, placement: &mut TreePlacement, )

fn try_place_hanging_tree_vine( region: &mut WorldGenRegion<'_>, placement: &mut TreePlacement, pos: BlockPos, vine_face: Direction, )

fn place_cocoa_tree_decorator( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, probability: f32, placement: &mut TreePlacement, )

fn try_place_tree_vine( region: &mut WorldGenRegion<'_>, placement: &mut TreePlacement, pos: BlockPos, vine_face: Direction, ) -> bool

fn place_tree_vine( region: &mut WorldGenRegion<'_>, placement: &mut TreePlacement, pos: BlockPos, vine_face: Direction, )

fn lowest_tree_trunks_or_roots(placement: &TreePlacement) -> Vec<BlockPos>

fn place_beehive_tree_decorator( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, probability: f32, placement: &mut TreePlacement, )

fn place_attached_to_leaves_tree_decorator( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, decorator: &AttachedToLeavesDecorator, placement: &mut TreePlacement, )

fn place_attached_to_logs_tree_decorator( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, decorator: &AttachedToLogsDecorator, placement: &mut TreePlacement, )

fn place_pale_moss_tree_decorator( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, leaves_probability: f32, trunk_probability: f32, ground_probability: f32, placement: &mut TreePlacement, biome_zoom_seed: i64, )

fn place_creaking_heart_tree_decorator( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, probability: f32, placement: &mut TreePlacement, )

fn add_pale_moss_hanger( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, pos: BlockPos, placement: &mut TreePlacement, )

fn tree_decorator_has_required_empty_blocks( region: &WorldGenRegion<'_>, leaf: BlockPos, direction: Direction, required_empty_blocks: i32, ) -> bool

fn blacklist_attached_tree_decoration_area( blacklist: &mut FxHashSet<BlockPos>, center: BlockPos, radius_xz: i32, radius_y: i32, )

fn random_tree_decorator_direction( random: &mut WorldgenRandom, directions: &[Direction], ) -> Direction

fn sorted_tree_positions(positions: &JavaBlockPosSet) -> Vec<BlockPos>

fn shuffle_tree_positions( random: &mut WorldgenRandom, positions: &mut [BlockPos], )

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_fallen_tree_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &FallenTreeConfiguration, origin: BlockPos, biome_zoom_seed: i64, ) -> bool

fn set_ground_height_for_fallen_log_start_pos( region: &WorldGenRegion<'_>, log_start_pos: &mut BlockPos, )

fn place_fallen_tree_stump( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &FallenTreeConfiguration, origin: BlockPos, biome_zoom_seed: i64, )

fn place_fallen_log( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &FallenTreeConfiguration, log_length: i32, log_start_pos: BlockPos, direction: Direction, biome_zoom_seed: i64, )

fn can_place_entire_fallen_log( region: &WorldGenRegion<'_>, log_length: i32, log_start_pos: &mut BlockPos, direction: Direction, ) -> bool

fn may_place_fallen_log_on(region: &WorldGenRegion<'_>, pos: BlockPos) -> bool

fn is_over_solid_ground_for_fallen_log( region: &WorldGenRegion<'_>, pos: BlockPos, ) -> bool

fn place_fallen_log_block( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &FallenTreeConfiguration, pos: BlockPos, axis: Option<Axis>, placement: &mut TreePlacement, )

impl FeatureDecorationRunner

pub(super) fn tree_foliage_height( random: &mut WorldgenRandom, tree_height: i32, config: &TreeConfiguration, ) -> i32

pub(super) fn tree_foliage_radius( random: &mut WorldgenRandom, foliage_placer: &FoliagePlacer, trunk_height: i32, ) -> i32

pub(super) fn create_tree_foliage( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, _tree_height: i32, attachment: FoliageAttachment, foliage_height: i32, leaf_radius: i32, placement: &mut TreePlacement, )

fn create_fancy_tree_foliage( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, attachment: FoliageAttachment, foliage_height: i32, leaf_radius: i32, placement: &mut TreePlacement, )

fn create_jungle_tree_foliage( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, attachment: FoliageAttachment, foliage_height: i32, leaf_radius: i32, placement: &mut TreePlacement, )

fn create_random_spread_tree_foliage( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, placer: &RandomSpreadFoliagePlacer, attachment: FoliageAttachment, foliage_height: i32, leaf_radius: i32, placement: &mut TreePlacement, )

fn create_cherry_tree_foliage( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, placer: &CherryFoliagePlacer, attachment: FoliageAttachment, foliage_height: i32, leaf_radius: i32, placement: &mut TreePlacement, )

fn create_dark_oak_tree_foliage( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, attachment: FoliageAttachment, leaf_radius: i32, placement: &mut TreePlacement, )

fn create_mega_pine_tree_foliage( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, attachment: FoliageAttachment, foliage_height: i32, leaf_radius: i32, placement: &mut TreePlacement, )

fn create_bush_tree_foliage( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, attachment: FoliageAttachment, foliage_height: i32, leaf_radius: i32, placement: &mut TreePlacement, )

fn create_pine_tree_foliage( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, attachment: FoliageAttachment, foliage_height: i32, leaf_radius: i32, placement: &mut TreePlacement, )

fn create_spruce_tree_foliage( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, attachment: FoliageAttachment, foliage_height: i32, leaf_radius: i32, placement: &mut TreePlacement, )

fn create_blob_tree_foliage( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, _placer: &BlobFoliagePlacer, attachment: FoliageAttachment, foliage_height: i32, leaf_radius: i32, placement: &mut TreePlacement, )

fn create_acacia_tree_foliage( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, attachment: FoliageAttachment, foliage_height: i32, leaf_radius: i32, placement: &mut TreePlacement, )

fn tree_foliage_offset( random: &mut WorldgenRandom, foliage_placer: &FoliagePlacer, ) -> i32

fn place_tree_leaves_row( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, origin: BlockPos, current_radius: i32, y: i32, double_trunk: bool, placement: &mut TreePlacement, )

fn place_tree_leaves_row_with_hanging_leaves_below( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, origin: BlockPos, current_radius: i32, y: i32, double_trunk: bool, hanging_leaves_chance: f32, hanging_leaves_extension_chance: f32, placement: &mut TreePlacement, )

fn try_place_hanging_leaf_extension( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, chance: f32, log_pos: BlockPos, pos: BlockPos, placement: &mut TreePlacement, ) -> bool

const fn direction_is_positive(direction: Direction) -> bool

fn tree_foliage_should_skip_location( random: &mut WorldgenRandom, foliage_placer: &FoliagePlacer, dx: i32, y: i32, dz: i32, current_radius: i32, double_trunk: bool, ) -> bool

fn blob_foliage_should_skip_location( random: &mut WorldgenRandom, dx: i32, y: i32, dz: i32, current_radius: i32, ) -> bool

fn bush_foliage_should_skip_location( random: &mut WorldgenRandom, dx: i32, dz: i32, current_radius: i32, ) -> bool

fn fancy_foliage_should_skip_location( dx: i32, dz: i32, current_radius: i32, ) -> bool

fn dark_oak_foliage_should_skip_location( dx: i32, y: i32, dz: i32, current_radius: i32, double_trunk: bool, ) -> bool

fn cherry_foliage_should_skip_location( random: &mut WorldgenRandom, placer: &CherryFoliagePlacer, dx: i32, y: i32, dz: i32, current_radius: i32, ) -> bool

const fn conifer_foliage_should_skip_location( dx: i32, dz: i32, current_radius: i32, ) -> bool

const fn mega_pine_foliage_should_skip_location( dx: i32, dz: i32, current_radius: i32, ) -> bool

const fn acacia_foliage_should_skip_location( dx: i32, y: i32, dz: i32, current_radius: i32, ) -> bool

fn foliage_signed_distances(dx: i32, dz: i32, double_trunk: bool) -> (i32, i32)

fn try_place_tree_leaf( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, pos: BlockPos, placement: &mut TreePlacement, ) -> bool

impl FeatureDecorationRunner

pub(super) fn update_tree_leaves( region: &mut WorldGenRegion<'_>, bounds: TreeBounds, placement: &TreePlacement, )

fn update_tree_shape_at_edge( region: &WorldGenRegion<'_>, bounds: TreeBounds, shape: &FxHashSet<BlockPos>, )

fn scan_tree_shape_line( region: &WorldGenRegion<'_>, shape: &FxHashSet<BlockPos>, start: i32, end: i32, pos_at: impl FnMut(i32) -> BlockPos, negative: Direction, positive: Direction, )

fn update_tree_shape_face( region: &WorldGenRegion<'_>, pos: BlockPos, direction: Direction, )

fn update_leaf_shape_at_edge( region: &WorldGenRegion<'_>, pos: BlockPos, state: BlockStateId, neighbor_state: BlockStateId, )

fn tree_optional_leaf_distance_at(state: BlockStateId) -> Option<u8>

fn tree_leaf_distance_at(state: BlockStateId) -> u8

const fn tree_can_schedule_tick_at( region: &WorldGenRegion<'_>, pos: BlockPos, ) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_root_system_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &RootSystemConfiguration, origin: BlockPos, biome_zoom_seed: i64, ) -> bool

fn place_root_system_dirt_and_tree( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &RootSystemConfiguration, tree_pos: &mut BlockPos, origin: BlockPos, biome_zoom_seed: i64, ) -> bool

fn root_system_space_for_tree( region: &WorldGenRegion<'_>, config: &RootSystemConfiguration, pos: BlockPos, ) -> bool

fn root_system_allowed_tree_space( state: BlockStateId, blocks_above_origin: i32, allowed_vertical_water_height: i32, ) -> bool

fn place_root_system_dirt( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &RootSystemConfiguration, origin: BlockPos, target_height: i32, )

fn place_root_system_rooted_dirt( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &RootSystemConfiguration, pos: BlockPos, origin_x: i32, origin_z: i32, )

fn place_root_system_hanging_roots( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &RootSystemConfiguration, origin: BlockPos, )

impl FeatureDecorationRunner

pub(super) fn tree_root_origin( random: &mut WorldgenRandom, origin: BlockPos, root_placer: Option<&RootPlacer>, ) -> BlockPos

pub(super) fn place_tree_roots( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, origin: BlockPos, trunk_origin: BlockPos, config: &TreeConfiguration, placement: &mut TreePlacement, ) -> bool

fn place_mangrove_tree_roots( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, origin: BlockPos, trunk_origin: BlockPos, placer: &MangroveRootPlacer, placement: &mut TreePlacement, ) -> bool

fn simulate_mangrove_tree_roots( region: &WorldGenRegion<'_>, random: &mut WorldgenRandom, root_pos: BlockPos, direction: Direction, root_origin: BlockPos, root_positions: &mut Vec<BlockPos>, layer: i32, placement: &MangroveRootPlacement, ) -> bool

fn potential_mangrove_root_positions( pos: BlockPos, previous_direction: Direction, random: &mut WorldgenRandom, root_origin: BlockPos, placement: &MangroveRootPlacement, ) -> Vec<BlockPos>

fn can_place_mangrove_tree_root( region: &WorldGenRegion<'_>, pos: BlockPos, placement: &MangroveRootPlacement, ) -> bool

fn place_mangrove_tree_root( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, pos: BlockPos, placer: &MangroveRootPlacer, placement: &mut TreePlacement, )

fn block_matches_identifiers( registry: &Registry, state: BlockStateId, blocks: &[Identifier], ) -> bool

impl FeatureDecorationRunner

pub(super) fn tree_height( random: &mut WorldgenRandom, placer: &TrunkPlacer, ) -> i32

fn sample_tree_height( random: &mut WorldgenRandom, base_height: i32, height_rand_a: i32, height_rand_b: i32, ) -> i32

pub(super) fn place_tree_trunk( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, tree_height: i32, origin: BlockPos, config: &TreeConfiguration, placement: &mut TreePlacement, ) -> Vec<FoliageAttachment>

fn place_straight_tree_trunk( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, tree_height: i32, origin: BlockPos, config: &TreeConfiguration, placement: &mut TreePlacement, ) -> Vec<FoliageAttachment>

fn place_forking_tree_trunk( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, tree_height: i32, origin: BlockPos, config: &TreeConfiguration, placement: &mut TreePlacement, ) -> Vec<FoliageAttachment>

fn place_giant_tree_trunk( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, tree_height: i32, origin: BlockPos, config: &TreeConfiguration, placement: &mut TreePlacement, ) -> Vec<FoliageAttachment>

fn place_mega_jungle_tree_trunk( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, tree_height: i32, origin: BlockPos, config: &TreeConfiguration, placement: &mut TreePlacement, ) -> Vec<FoliageAttachment>

fn place_bending_tree_trunk( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, tree_height: i32, origin: BlockPos, config: &TreeConfiguration, placer: &BendingTrunkPlacer, placement: &mut TreePlacement, ) -> Vec<FoliageAttachment>

fn place_upwards_branching_tree_trunk( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, tree_height: i32, origin: BlockPos, config: &TreeConfiguration, placer: &UpwardsBranchingTrunkPlacer, placement: &mut TreePlacement, ) -> Vec<FoliageAttachment>

fn place_upwards_branching_tree_branch( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, tree_height: i32, config: &TreeConfiguration, placer: &UpwardsBranchingTrunkPlacer, attachments: &mut Vec<FoliageAttachment>, log_pos: BlockPos, current_height: i32, branch_dir: Direction, branch_pos: i32, branch_steps: i32, placement: &mut TreePlacement, )

fn place_cherry_tree_trunk( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, tree_height: i32, origin: BlockPos, config: &TreeConfiguration, placer: &CherryTrunkPlacer, placement: &mut TreePlacement, ) -> Vec<FoliageAttachment>

fn generate_cherry_tree_branch( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, tree_height: i32, origin: BlockPos, config: &TreeConfiguration, placer: &CherryTrunkPlacer, branch_direction: Direction, offset_from_origin: i32, middle_continues_upwards: bool, sideways_axis: Axis, placement: &mut TreePlacement, ) -> FoliageAttachment

fn place_dark_oak_tree_trunk( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, tree_height: i32, origin: BlockPos, config: &TreeConfiguration, placement: &mut TreePlacement, ) -> Vec<FoliageAttachment>

fn place_fancy_tree_trunk( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, tree_height: i32, origin: BlockPos, config: &TreeConfiguration, placement: &mut TreePlacement, ) -> Vec<FoliageAttachment>

fn make_fancy_tree_limb( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, start_pos: BlockPos, end_pos: BlockPos, do_place: bool, config: &TreeConfiguration, placement: &mut TreePlacement, ) -> bool

fn fancy_tree_limb_steps(pos: BlockPos) -> i32

fn fancy_tree_log_axis(start_pos: BlockPos, block_pos: BlockPos) -> Axis

fn trim_fancy_tree_branch(height: i32, local_y: i32) -> bool

fn make_fancy_tree_branches( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, height: i32, origin: BlockPos, foliage_coords: &[FancyFoliageCoords], config: &TreeConfiguration, placement: &mut TreePlacement, )

fn place_tree_log_with_axis( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, pos: BlockPos, axis: Axis, config: &TreeConfiguration, placement: &mut TreePlacement, ) -> bool

fn place_fancy_tree_log( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, pos: BlockPos, axis: Axis, config: &TreeConfiguration, placement: &mut TreePlacement, ) -> bool

fn with_axis_if_present(state: BlockStateId, axis: Axis) -> BlockStateId

fn fancy_tree_shape(height: i32, y: i32) -> f32

fn place_below_trunk_block( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, pos: BlockPos, config: &TreeConfiguration, placement: &mut TreePlacement, )

fn place_tree_log( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, pos: BlockPos, config: &TreeConfiguration, placement: &mut TreePlacement, ) -> bool

fn place_tree_log_if_free( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, pos: BlockPos, config: &TreeConfiguration, placement: &mut TreePlacement, ) -> bool

fn place_tree_log_growing_through( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, pos: BlockPos, can_grow_through: &Identifier, config: &TreeConfiguration, placement: &mut TreePlacement, ) -> bool

impl FeatureDecorationRunner

pub(crate) fn place_tree_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, origin: BlockPos, biome_zoom_seed: i64, ) -> bool

fn do_place_tree( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &TreeConfiguration, origin: BlockPos, placement: &mut TreePlacement, ) -> bool

const fn tree_min_clipped_height(feature_size: &FeatureSize) -> Option<i32>

const fn tree_size_at_height( feature_size: &FeatureSize, tree_height: i32, y: i32, ) -> i32

fn max_free_tree_height( region: &WorldGenRegion<'_>, max_tree_height: i32, tree_pos: BlockPos, config: &TreeConfiguration, ) -> i32

fn tree_valid_pos(region: &WorldGenRegion<'_>, pos: BlockPos) -> bool

fn tree_trunk_placer_is_free( region: &WorldGenRegion<'_>, pos: BlockPos, trunk_placer: &TrunkPlacer, ) -> bool

fn tree_valid_pos_for_trunk_placer( region: &WorldGenRegion<'_>, pos: BlockPos, trunk_placer: &TrunkPlacer, ) -> bool

fn tree_valid_pos_or_tag( region: &WorldGenRegion<'_>, pos: BlockPos, tag: &Identifier, ) -> bool

fn tree_is_air_or_leaves(region: &WorldGenRegion<'_>, pos: BlockPos) -> bool

fn tree_is_vine(region: &WorldGenRegion<'_>, pos: BlockPos) -> bool

fn set_tree_block( region: &mut WorldGenRegion<'_>, pos: BlockPos, state: BlockStateId, )

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_twisting_vines_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, config: &TwistingVinesConfiguration, origin: BlockPos, ) -> bool

fn find_first_air_block_above_ground( region: &WorldGenRegion<'_>, place_pos: &mut BlockPos, ) -> bool

fn place_twisting_vines_column( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, place_pos: BlockPos, total_height: i32, min_age: u8, max_age: u8, )

fn twisting_vines_invalid_placement_location( region: &WorldGenRegion<'_>, pos: BlockPos, ) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_underwater_magma_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, config: &UnderwaterMagmaConfiguration, origin: BlockPos, ) -> bool

fn underwater_magma_floor_y( region: &WorldGenRegion<'_>, origin: BlockPos, config: &UnderwaterMagmaConfiguration, ) -> Option<i32>

fn underwater_magma_valid_placement( region: &WorldGenRegion<'_>, pos: BlockPos, ) -> bool

fn underwater_magma_is_water_or_air(state: BlockStateId) -> bool

fn underwater_magma_visible_from_outside( region: &WorldGenRegion<'_>, pos: BlockPos, covered_direction: Direction, ) -> bool

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_vegetation_patch_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &VegetationPatchConfiguration, origin: BlockPos, biome_zoom_seed: i64, ) -> bool

pub(in worldgen::feature) fn place_waterlogged_vegetation_patch_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &VegetationPatchConfiguration, origin: BlockPos, biome_zoom_seed: i64, ) -> bool

fn place_vegetation_patch_ground( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &VegetationPatchConfiguration, origin: BlockPos, x_radius: i32, z_radius: i32, ) -> JavaBlockPosSet

fn place_vegetation_patch_ground_column( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &VegetationPatchConfiguration, pos: &mut BlockPos, inwards: Direction, depth: i32, ) -> bool

fn distribute_vegetation_patch( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, config: &VegetationPatchConfiguration, surface: &JavaBlockPosSet, biome_zoom_seed: i64, waterlogged: bool, )

fn waterlogged_vegetation_patch_surface( region: &WorldGenRegion<'_>, surface: &JavaBlockPosSet, ) -> JavaBlockPosSet

fn vegetation_patch_surface_exposed( region: &WorldGenRegion<'_>, pos: BlockPos, ) -> bool

const fn vegetation_patch_surface_direction( surface: VerticalSurface, ) -> Direction

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_vines_feature( region: &mut WorldGenRegion<'_>, origin: BlockPos, ) -> bool

pub(in worldgen::feature) fn vine_state_for_face( direction: Direction, ) -> BlockStateId

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_void_start_platform_feature( region: &mut WorldGenRegion<'_>, origin: BlockPos, ) -> bool

const fn checkerboard_distance(xa: i32, za: i32, xb: i32, zb: i32) -> i32

impl FeatureDecorationRunner

pub(in worldgen::feature) fn place_weeping_vines_feature( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, origin: BlockPos, ) -> bool

fn place_roof_nether_wart( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, origin: BlockPos, )

fn place_roof_weeping_vines( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, origin: BlockPos, )

pub(in worldgen::feature) fn place_weeping_vines_column( region: &mut WorldGenRegion<'_>, random: &mut WorldgenRandom, place_pos: BlockPos, total_height: i32, min_age: u8, max_age: u8, )

impl FeatureDecorationRunner

pub(super) fn place_placed_feature_entry( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, origin: BlockPos, feature: PlacedFeatureEntryRef, biome_zoom_seed: i64, ) -> bool

pub(super) fn place_placed_feature_data( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, origin: BlockPos, feature: &PlacedFeatureData, biome_filter: Option<&Identifier>, biome_zoom_seed: i64, ) -> bool

fn place_placed_feature_from_modifier( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, origin: BlockPos, feature: &PlacedFeatureData, biome_filter: BiomeFilterMode<'_>, biome_zoom_seed: i64, modifier_index: usize, ) -> bool

pub(super) fn place_placed_feature_ref( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, origin: BlockPos, feature: &PlacedFeatureRef, biome_zoom_seed: i64, ) -> bool

pub(crate) fn place_structure_pool_feature( region: &mut WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, origin: BlockPos, feature_key: &Identifier, biome_zoom_seed: i64, ) -> bool

impl FeatureDecorationRunner

pub(super) const fn feature_heightmap_type( heightmap: FeatureHeightmap, ) -> HeightmapType

pub(super) fn count_on_every_layer_positions( region: &WorldGenRegion<'_>, random: &mut WorldgenRandom, origin: BlockPos, count: &IntProvider, ) -> Vec<BlockPos>

pub(super) fn find_on_ground_y_position( region: &WorldGenRegion<'_>, x: i32, start_y: i32, z: i32, layer_to_place_on: i32, ) -> Option<i32>

pub(super) fn is_empty_layer_block(state: BlockStateId) -> bool

pub(super) fn environment_scan_position( region: &WorldGenRegion<'_>, registry: &Registry, origin: BlockPos, direction_of_search: Direction, target_condition: &BlockPredicate, allowed_search_condition: Option<&BlockPredicate>, max_steps: i32, ) -> Option<BlockPos>

impl FeatureDecorationRunner

pub(super) fn test_optional_block_predicate( region: &WorldGenRegion<'_>, registry: &Registry, predicate: Option<&BlockPredicate>, origin: BlockPos, ) -> bool

pub(super) fn biome_allows_feature( region: &WorldGenRegion<'_>, registry: &Registry, biome_zoom_seed: i64, origin: BlockPos, biome_filter_feature_key: Option<&Identifier>, ) -> bool

pub(super) fn test_block_predicate( region: &WorldGenRegion<'_>, registry: &Registry, predicate: &BlockPredicate, origin: BlockPos, ) -> bool

pub(super) fn offset(origin: BlockPos, offset: &IVec3) -> BlockPos

impl FeatureDecorationRunner

pub(super) fn sample_block_state_provider_optional( region: &WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, provider: &BlockStateProvider, pos: BlockPos, ) -> Option<BlockStateId>

pub(super) fn sample_block_state_provider( region: &WorldGenRegion<'_>, registry: &Registry, random: &mut WorldgenRandom, provider: &BlockStateProvider, pos: BlockPos, ) -> BlockStateId

pub(super) fn random_axis(random: &mut WorldgenRandom) -> Axis

pub(super) fn set_int_property_by_name( registry: &Registry, state: BlockStateId, property: &str, value: i32, ) -> BlockStateId

pub(super) fn sample_noise_provider( registry: &Registry, provider: &NoiseProvider, pos: BlockPos, ) -> BlockStateId

pub(super) fn sample_noise_threshold_provider( registry: &Registry, random: &mut WorldgenRandom, provider: &NoiseThresholdProvider, pos: BlockPos, ) -> BlockStateId

pub(super) fn sample_dual_noise_provider( registry: &Registry, provider: &DualNoiseProvider, pos: BlockPos, ) -> BlockStateId

pub(super) fn normal_noise( parameters: &FeatureNoiseParameters, seed: i64, ) -> NormalNoise

pub(super) fn noise_value(noise: &NormalNoise, pos: BlockPos, scale: f32) -> f64

pub(super) fn noise_state_by_value( registry: &Registry, states: &[BlockStateData], noise_value: f64, ) -> BlockStateId

pub(super) fn noise_state_by_resolved_value( states: &[BlockStateId], noise_value: f64, ) -> BlockStateId

pub(super) fn noise_state_index(state_count: usize, noise_value: f64) -> usize

pub(super) fn random_block_state_from_data_list( registry: &Registry, random: &mut WorldgenRandom, states: &[BlockStateData], ) -> BlockStateId

impl FeatureDecorationRunner

pub(super) const VANILLA_DIRECTION_VALUES: [Direction; 6]

pub(super) const VANILLA_HORIZONTAL_DIRECTIONS: [Direction; 4]

pub(super) fn random_horizontal_direction( random: &mut WorldgenRandom, ) -> Direction

pub(super) fn shuffled_directions<const N: usize>( random: &mut WorldgenRandom, directions: [Direction; N], ) -> [Direction; N]

pub(super) const fn manhattan_distance(left: BlockPos, right: BlockPos) -> i32

pub(super) fn for_each_vanilla_within_manhattan( origin: BlockPos, reach_x: i32, reach_y: i32, reach_z: i32, visitor: impl FnMut(BlockPos) -> bool, )

pub(super) fn for_each_vanilla_between_closed( min: BlockPos, max: BlockPos, visitor: impl FnMut(BlockPos), )

const fn abs_diff(left: i32, right: i32) -> i32

pub(crate) fn new(possible_biomes: &[BiomeRef], registry: &Registry) -> Self

pub(crate) fn decorate( &self, region: &mut WorldGenRegion<'_>, registry: &Registry, seed: i64, biome_zoom_seed: i64, )

pub(super) fn collect_possible_biome_ids( &self, region: &WorldGenRegion<'_>, ) -> Vec<usize>

pub(super) fn structures_for_decoration_step( registry: &Registry, step: usize, ) -> Vec<StructureRef>

pub(super) const fn center_chunk_writable_box( region: &WorldGenRegion<'_>, ) -> BoundingBox

pub(super) const fn chunk_writable_box( center: ChunkPos, min_y: i32, max_y_exclusive: i32, ) -> BoundingBox

fn structure_source_positions_in_region( region: &WorldGenRegion<'_>, structure_id: &Identifier, ) -> Vec<ChunkPos>

pub(super) fn place_structures_for_step( region: &mut WorldGenRegion<'_>, registry: &Registry, decoration_seed: i64, random: &mut WorldgenRandom, step: usize, biome_zoom_seed: i64, )

pub(super) fn set_structure_seed( random: &mut WorldgenRandom, decoration_seed: i64, structure_index: usize, step: usize, )

pub(super) fn place_features_for_step( region: &mut WorldGenRegion<'_>, registry: &Registry, decoration_seed: i64, random: &mut WorldgenRandom, origin: BlockPos, step: usize, step_features: &FeatureStepData, possible_biomes: &[usize], biome_zoom_seed: i64, )

impl FeatureDecorationRunner

pub(super) fn block_matches_holder_set( block: BlockRef, blocks: &BlockHolderSet, ) -> bool

pub(super) fn block_state_from_data( registry: &Registry, data: &BlockStateData, ) -> BlockStateId

pub(super) fn fluid_state_from_data(data: &FluidStateData) -> FluidState

pub(super) const fn default_fluid_amount(fluid: FluidRef) -> u8

pub(super) fn parse_fluid_bool_property( fluid_name: &Identifier, property: &str, value: &str, ) -> bool

pub(super) fn parse_flowing_fluid_level( fluid_name: &Identifier, value: &str, ) -> u8

pub(super) fn legacy_block_from_fluid_state( registry: &Registry, fluid_state: FluidState, ) -> BlockStateId

pub(super) fn legacy_fluid_block_level(fluid_state: FluidState) -> u8

impl FeatureDecorationRunner

pub(super) fn biome_info_noise_value(x: f64, z: f64) -> f64

pub(super) fn biome_at_block( region: &WorldGenRegion<'_>, registry: &Registry, biome_zoom_seed: i64, pos: BlockPos, ) -> BiomeRef

pub(super) fn should_freeze( region: &WorldGenRegion<'_>, registry: &Registry, biome_zoom_seed: i64, pos: BlockPos, check_neighbors: bool, ) -> bool

pub(super) fn should_freeze_in_biome( region: &WorldGenRegion<'_>, biome: BiomeRef, pos: BlockPos, check_neighbors: bool, ) -> bool

pub(super) fn should_snow_in_biome( region: &WorldGenRegion<'_>, biome: BiomeRef, pos: BlockPos, ) -> bool

fn is_water_at(region: &WorldGenRegion<'_>, pos: BlockPos) -> bool

fn warm_enough_to_rain( region: &WorldGenRegion<'_>, biome: BiomeRef, pos: BlockPos, ) -> bool

fn biome_temperature( region: &WorldGenRegion<'_>, biome: BiomeRef, pos: BlockPos, ) -> f32

Trait Implementations

impl Debug for FeatureDecorationRunner

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.