Struct ShapeCaster

source

pub struct ShapeCaster {
    pub enabled: bool,
    pub shape: Collider,
    pub origin: Vector,
    pub shape_rotation: Quaternion,
    pub direction: Dir3,
    pub max_hits: u32,
    pub max_distance: Scalar,
    pub target_distance: Scalar,
    pub compute_contact_on_penetration: bool,
    pub ignore_origin_penetration: bool,
    pub ignore_self: bool,
    pub query_filter: SpatialQueryFilter,
    /* private fields */
}

Expand description

A component used for shapecasting.

Shapecasting is a type of spatial query where a shape travels along a straight line and computes hits with colliders. This is often used to determine how far an object can move in a direction before it hits something.

Each shapecast is defined by a shape (a Collider), its local shape_rotation, a local origin and a local direction. The ShapeCaster will find each hit and add them to the ShapeHits component in the order of distance.

Computing lots of hits can be expensive, especially against complex geometry, so the maximum number of hits is one by default. This can be configured through the max_hits property.

The ShapeCaster is the easiest way to handle simple shapecasting. If you want more control and don’t want to perform shapecasts on every frame, consider using the SpatialQuery system parameter.

§Example

use avian3d::prelude::*;
use bevy::prelude::*;

fn setup(mut commands: Commands) {
    // Spawn a shape caster with a ball shape moving right starting from the origin
    commands.spawn(ShapeCaster::new(
        Collider::sphere(0.5),
        Vec3::ZERO,
        Quat::default(),
        Dir3::X,
    ));
}

fn print_hits(query: Query<(&ShapeCaster, &ShapeHits)>) {
    for (shape_caster, hits) in &query {
        for hit in hits.iter() {
            println!("Hit entity {}", hit.entity);
        }
    }
}

Fields§

§enabled: bool

Controls if the shape caster is enabled.

§shape: Collider

The shape being cast represented as a Collider.

§origin: Vector

The local origin of the shape relative to the Position and Rotation of the shape caster entity or its parent.

To get the global origin, use the global_origin method.

§shape_rotation: Quaternion

The local rotation of the shape being cast relative to the Rotation of the shape caster entity or its parent.

To get the global shape rotation, use the global_shape_rotation method.

§direction: Dir3

The local direction of the shapecast relative to the Rotation of the shape caster entity or its parent.

To get the global direction, use the global_direction method.

§max_hits: u32

The maximum number of hits allowed. By default this is one and only the first hit is returned.

§max_distance: Scalar

The maximum distance the shape can travel.

By default, this is infinite.

§target_distance: Scalar

The separation distance at which the shapes will be considered as impacting.

If the shapes are separated by a distance smaller than target_distance at the origin of the cast, the computed contact points and normals are only reliable if ShapeCaster::compute_contact_on_penetration is set to true.

By default, this is 0.0, so the shapes will only be considered as impacting when they first touch.

§compute_contact_on_penetration: bool

If true, contact points and normals will be calculated even when the cast distance is 0.0.

The default is true.

§ignore_origin_penetration: bool

If true and the shape is travelling away from the object that was hit, the cast will ignore any impact that happens at the cast origin.

The default is false.

§ignore_self: bool

If true, the shape caster ignores hits against its own Collider. This is the default.

§query_filter: SpatialQueryFilter

Rules that determine which colliders are taken into account in the shape cast.

Struct ShapeCasterCopy item path

§Example

Fields§

Implementations§

impl ShapeCaster

pub fn new( shape: impl Into<Collider>, origin: Vector, shape_rotation: Quaternion, direction: Dir3, ) -> Self

pub fn with_origin(self, origin: Vector) -> Self

pub fn with_direction(self, direction: Dir3) -> Self

pub fn with_target_distance(self, target_distance: Scalar) -> Self

pub fn with_compute_contact_on_penetration(self, compute_contact: bool) -> Self

pub fn with_ignore_origin_penetration(self, ignore: bool) -> Self

pub fn with_ignore_self(self, ignore: bool) -> Self

pub fn with_max_distance(self, max_distance: Scalar) -> Self

pub fn with_max_time_of_impact(self, max_time_of_impact: Scalar) -> Self

pub fn with_max_hits(self, max_hits: u32) -> Self

pub fn with_query_filter(self, query_filter: SpatialQueryFilter) -> Self

pub fn enable(&mut self)

pub fn disable(&mut self)

pub fn global_origin(&self) -> Vector

pub fn global_shape_rotation(&self) -> Quaternion

pub fn global_direction(&self) -> Dir3

Trait Implementations§

impl Clone for ShapeCaster

fn clone(&self) -> ShapeCaster

fn clone_from(&mut self, source: &Self)

impl Component for ShapeCasterwhere Self: Send + Sync + 'static,

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

fn register_required_components( requiree: ComponentId, components: &mut Components, storages: &mut Storages, required_components: &mut RequiredComponents, inheritance_depth: u16, )

fn register_component_hooks(hooks: &mut ComponentHooks)

impl Debug for ShapeCaster

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

impl Default for ShapeCaster

fn default() -> Self

fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self>

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

fn get_type_registration() -> TypeRegistration

fn register_type_dependencies(registry: &mut TypeRegistry)

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

fn clone_value(&self) -> Box<dyn PartialReflect>

fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError>

fn reflect_kind(&self) -> ReflectKind

fn reflect_ref(&self) -> ReflectRef<'_>

fn reflect_mut(&mut self) -> ReflectMut<'_>

fn reflect_owned(self: Box<Self>) -> ReflectOwned

fn try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

fn try_as_reflect(&self) -> Option<&dyn Reflect>

fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>

fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

fn as_partial_reflect(&self) -> &dyn PartialReflect

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool>

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

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

fn reflect_hash(&self) -> Option<u64>

fn serializable(&self) -> Option<Serializable<'_>>

fn is_dynamic(&self) -> bool

fn into_any(self: Box<Self>) -> Box<dyn Any>

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

fn as_reflect(&self) -> &dyn Reflect

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

fn field(&self, name: &str) -> Option<&dyn PartialReflect>

fn field_mut(&mut self, name: &str) -> Option<&mut dyn PartialReflect>

fn field_at(&self, index: usize) -> Option<&dyn PartialReflect>

fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn PartialReflect>

fn name_at(&self, index: usize) -> Option<&str>

fn field_len(&self) -> usize

fn iter_fields(&self) -> FieldIter<'_>

fn clone_dynamic(&self) -> DynamicStruct

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

impl TypePath for ShapeCasterwhere ShapeCaster: Any + Send + Sync,

fn type_path() -> &'static str

fn short_type_path() -> &'static str

fn type_ident() -> Option<&'static str>

fn crate_name() -> Option<&'static str>

fn module_path() -> Option<&'static str>

fn type_info() -> &'static TypeInfo

Auto Trait Implementations§

Struct ShapeCaster

impl Component for ShapeCaster
where Self: Send + Sync + 'static,

impl TypePath for ShapeCaster
where ShapeCaster: Any + Send + Sync,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T, U> AsBindGroupShaderType<U> for T
where U: ShaderType, &'a T: for<'a> Into<U>,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<C> Bundle for C
where C: Component,

unsafe fn from_components<T, F>(ctx: &mut T, func: &mut F) -> C
where F: for<'a> FnMut(&'a mut T) -> OwningPtr<'a>,

impl<T> CloneToUninit for T
where T: Clone,

impl<T> Downcast for T
where T: Any,

impl<T> DowncastSync for T
where T: Any + Send + Sync,

impl<C> DynamicBundle for C
where C: Component,

impl<T> DynamicTypePath for T
where T: TypePath,

impl<T> DynamicTyped for T
where T: Typed,

impl<T> FromWorld for T
where T: Default,

impl<S> GetField for S
where S: Struct,

fn get_field<T>(&self, name: &str) -> Option<&T>
where T: Reflect,

fn get_field_mut<T>(&mut self, name: &str) -> Option<&mut T>
where T: Reflect,

impl<T> GetPath for T
where T: Reflect + ?Sized,

fn path<'p, T>( &self, path: impl ReflectPath<'p>, ) -> Result<&T, ReflectPathError<'p>>
where T: Reflect,

fn path_mut<'p, T>( &mut self, path: impl ReflectPath<'p>, ) -> Result<&mut T, ReflectPathError<'p>>
where T: Reflect,