Struct ChunkPos 

pub struct ChunkPos(pub IVec3);

The position of a chunk in chunk-space coordinates.

When added to an entity, automatically updates the entity’s Transform to match the chunk’s world position.

Example

use bevy::prelude::*;
use chunky_bevy::prelude::*;

fn spawn_chunk(mut commands: Commands) {
    // Spawns a chunk at chunk position (5, 0, 3)
    // With default 10x10x10 chunks, this will be at world position (50, 0, 30)
    commands.spawn((
        Chunk,
        ChunkPos(IVec3::new(5, 0, 3)),
    ));
}

Tuple Fields

0: IVec3

Methods from Deref<Target = IVec3>

pub const ZERO: IVec3

pub const ONE: IVec3

pub const NEG_ONE: IVec3

pub const MIN: IVec3

pub const MAX: IVec3

pub const X: IVec3

pub const Y: IVec3

pub const Z: IVec3

pub const NEG_X: IVec3

pub const NEG_Y: IVec3

pub const NEG_Z: IVec3

pub const AXES: [IVec3; 3]

pub fn to_array(&self) -> [i32; 3]

Converts self to [x, y, z]

pub fn as_vec3(&self) -> Vec3

Casts all elements of self to f32.

Examples found in repository

examples/sculpt.rs (line 276)

fn sculpt_terrain(
    time: Res<Time>,
    keyboard: Res<ButtonInput<KeyCode>>,
    mouse_buttons: Res<ButtonInput<MouseButton>>,
    window_q: Query<&Window, With<PrimaryWindow>>,
    camera_q: Query<(&Camera, &GlobalTransform), With<FlyCam>>,
    mut chunks: Query<(&ChunkPos, &mut DensityField)>,
    mesh_size: Res<DensityFieldMeshSize>,
    brush: Res<SculptBrush>,
    mut commands: Commands,
    chunk_entities: Query<Entity, With<ChunkPos>>,
) {
    let adding = mouse_buttons.pressed(MouseButton::Right);
    let removing = mouse_buttons.pressed(MouseButton::Left);

    if !adding && !removing {
        return;
    }

    let Ok(window) = window_q.single() else {
        return;
    };
    let Some(cursor_pos) = window.cursor_position() else {
        return;
    };
    let Ok((camera, cam_transform)) = camera_q.single() else {
        return;
    };
    let Ok(ray) = camera.viewport_to_world(cam_transform, cursor_pos) else {
        return;
    };

    let Some(hit_point) = raycast_terrain(&chunks, &mesh_size, ray) else {
        return;
    };

    let world_brush_radius = brush.radius;
    let chunk_world_size = mesh_size.0;
    let use_hard_brush =
        keyboard.pressed(KeyCode::ControlLeft) || keyboard.pressed(KeyCode::ControlRight);

    for (chunk_pos, mut field) in chunks.iter_mut() {
        let chunk_world_origin = chunk_pos.0.as_vec3() * chunk_world_size;
        let local_hit = hit_point - chunk_world_origin;

        let scale = Vec3::new(32.0, 32.0, 32.0) / chunk_world_size;
        let grid_center = local_hit * scale;
        let grid_radius = world_brush_radius * scale.x;

        // AABB check
        let chunk_min = Vec3::ZERO;
        let chunk_max = Vec3::splat(32.0);
        let brush_min = grid_center - Vec3::splat(grid_radius);
        let brush_max = grid_center + Vec3::splat(grid_radius);

        if brush_max.x < chunk_min.x
            || brush_min.x > chunk_max.x
            || brush_max.y < chunk_min.y
            || brush_min.y > chunk_max.y
            || brush_max.z < chunk_min.z
            || brush_min.z > chunk_max.z
        {
            continue;
        }

        if use_hard_brush {
            // Hard CSG brush (instant)
            bevy_sculpter::helpers::brush_sphere(&mut field, grid_center, grid_radius, adding);
        } else {
            match brush.mode {
                BrushMode::Smooth => {
                    // Smooth brush: rate is strength per second
                    // Negative rate = add material (decrease SDF)
                    // Positive rate = remove material (increase SDF)
                    let rate = if adding {
                        -brush.strength
                    } else {
                        brush.strength
                    };
                    bevy_sculpter::helpers::brush_smooth_timed(
                        &mut field,
                        grid_center,
                        grid_radius,
                        rate,
                        time.delta_secs(),
                        brush.falloff,
                    );
                }
                BrushMode::Blur => {
                    // Blur/smooth brush
                    bevy_sculpter::helpers::brush_blur(
                        &mut field,
                        grid_center,
                        grid_radius,
                        brush.strength * 0.1 * time.delta_secs(),
                        brush.falloff,
                    );
                }
                BrushMode::_Hard => {
                    bevy_sculpter::helpers::brush_sphere(
                        &mut field,
                        grid_center,
                        grid_radius,
                        adding,
                    );
                }
            }
        }
    }

    for entity in chunk_entities.iter() {
        commands.entity(entity).insert(DensityFieldDirty);
    }
}

fn raycast_terrain(
    chunks: &Query<(&ChunkPos, &mut DensityField)>,
    mesh_size: &DensityFieldMeshSize,
    ray: Ray3d,
) -> Option<Vec3> {
    let chunk_world_size = mesh_size.0;
    let max_dist = 200.0;
    let step = 0.1;
    let mut t = 0.0;

    while t < max_dist {
        let point = ray.origin + ray.direction * t;
        let chunk_coord = (point / chunk_world_size).floor().as_ivec3();

        for (chunk_pos, field) in chunks.iter() {
            if chunk_pos.0 != chunk_coord {
                continue;
            }

            let chunk_origin = chunk_pos.0.as_vec3() * chunk_world_size;
            let local_pos = point - chunk_origin;
            let scale = Vec3::new(32.0, 32.0, 32.0) / chunk_world_size;
            let grid_pos = local_pos * scale;

            if grid_pos.x >= 0.0
                && grid_pos.x < 32.0
                && grid_pos.y >= 0.0
                && grid_pos.y < 32.0
                && grid_pos.z >= 0.0
                && grid_pos.z < 32.0
            {
                let density = field.get(grid_pos.x as u32, grid_pos.y as u32, grid_pos.z as u32);
                if density < 0.0 {
                    return Some(point);
                }
            }
        }
        t += step;
    }
    None
}

pub fn as_vec3a(&self) -> Vec3A

Casts all elements of self to f32.

pub fn as_dvec3(&self) -> DVec3

Casts all elements of self to f64.

pub fn as_i8vec3(&self) -> I8Vec3

Casts all elements of self to i8.

pub fn as_u8vec3(&self) -> U8Vec3

Casts all elements of self to u8.

pub fn as_i16vec3(&self) -> I16Vec3

Casts all elements of self to i16.

pub fn as_u16vec3(&self) -> U16Vec3

Casts all elements of self to u16.

pub fn as_uvec3(&self) -> UVec3

Casts all elements of self to u32.

pub fn as_i64vec3(&self) -> I64Vec3

Casts all elements of self to i64.

pub fn as_u64vec3(&self) -> U64Vec3

Casts all elements of self to u64.

pub fn as_usizevec3(&self) -> USizeVec3

Casts all elements of self to usize.

Trait Implementations

impl Component for ChunkPos

where ChunkPos: Send + Sync + 'static,

Required Components: Transform.

A component’s Required Components are inserted whenever it is inserted. Note that this will also insert the required components of the required components, recursively, in depth-first order.

const STORAGE_TYPE: StorageType = ::bevy::ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

type Mutability = Immutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have Component<Mutability = Mutable>, while immutable components will instead have Component<Mutability = Immutable>.

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

fn on_replace() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_replace ComponentHook for this Component if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]

impl Default for ChunkPos

fn default() -> ChunkPos

Returns the “default value” for a type.

impl Deref for ChunkPos

type Target = IVec3

The resulting type after dereferencing.

fn deref(&self) -> &<ChunkPos as Deref>::Target

Dereferences the value.

impl DerefMut for ChunkPos

fn deref_mut(&mut self) -> &mut <ChunkPos as Deref>::Target

Mutably dereferences the value.