Struct avian3d::spatial_query::ShapeCaster

source ·

pub struct ShapeCaster {
    pub enabled: bool,
    pub shape: Collider,
    pub origin: Vector,
    pub shape_rotation: Quaternion,
    pub direction: Dir3,
    pub max_time_of_impact: Scalar,
    pub max_hits: u32,
    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 the time of impact.

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_time_of_impact: Scalar

The maximum distance the shape can travel. By default this is infinite, so the shape will travel until a hit is found.

§max_hits: u32

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

§ignore_origin_penetration: bool

Controls how the shapecast behaves when the shape is already penetrating a collider at the shape origin.

If set to true and the shape is being cast in a direction where it will eventually stop penetrating, the shapecast will not stop immediately, and will instead continue until another hit.
If set to false, the shapecast will stop immediately and return the hit. This is the default.

§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 query.

Struct avian3d::spatial_query::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_ignore_origin_penetration(self, ignore: bool) -> Self

pub fn with_ignore_self(self, ignore: bool) -> 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_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 Reflect) -> Option<Self>

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

fn get_type_registration() -> TypeRegistration

fn register_type_dependencies(registry: &mut TypeRegistry)

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

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 clone_value(&self) -> Box<dyn Reflect>

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

fn try_apply(&mut self, value: &dyn Reflect) -> 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 reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool>

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

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

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

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

fn is_dynamic(&self) -> bool

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

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

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

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

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

fn field_len(&self) -> usize

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

fn clone_dynamic(&self) -> DynamicStruct

impl TypePath for ShapeCasterwhere Self: 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§

impl Freeze for ShapeCaster

impl !RefUnwindSafe for ShapeCaster

impl Send for ShapeCaster

impl Sync for ShapeCaster

impl Unpin for ShapeCaster

impl !UnwindSafe for ShapeCaster

Blanket Implementations§

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

fn type_id(&self) -> TypeId

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

fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U

Struct avian3d::spatial_query::ShapeCaster

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

impl TypePath for ShapeCaster
where Self: 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> 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> 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,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<SS, SP> SupersetOf<SS> for SP
where SS: SubsetOf<SP>,