Struct avian3d::spatial_query::RayCaster

source ·

pub struct RayCaster {
    pub enabled: bool,
    pub origin: Vector,
    pub direction: Dir3,
    pub max_time_of_impact: Scalar,
    pub max_hits: u32,
    pub solid: bool,
    pub ignore_self: bool,
    pub query_filter: SpatialQueryFilter,
    /* private fields */
}

Expand description

A component used for raycasting.

Raycasting is a type of spatial query that finds one or more hits between a ray and a set of colliders.

Each ray is defined by a local origin and a direction. The RayCaster will find each hit and add them to the RayHits component. Each hit has a time_of_impact property which refers to how long the ray travelled, i.e. the distance between the origin and the point of intersection.

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

§Hit count and order

The results of a raycast are in an arbitrary order by default. You can iterate over them in the order of time of impact with the RayHits::iter_sorted method.

You can configure the maximum amount of hits for a ray using max_hits. By default this is unbounded, so you will get all hits. When the number or complexity of colliders is large, this can be very expensive computationally. Set the value to whatever works best for your case.

Note that when there are more hits than max_hits, some hits will be missed. To guarantee that the closest hit is included, you should set max_hits to one or a value that is enough to contain all hits.

§Example

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

fn setup(mut commands: Commands) {
    // Spawn a ray at the center going right
    commands.spawn(RayCaster::new(Vec3::ZERO, Dir3::X));
    // ...spawn colliders and other things
}

fn print_hits(query: Query<(&RayCaster, &RayHits)>) {
    for (ray, hits) in &query {
        // For the faster iterator that isn't sorted, use `.iter()`
        for hit in hits.iter_sorted() {
            println!(
                "Hit entity {:?} at {} with normal {}",
                hit.entity,
                ray.origin + *ray.direction * hit.time_of_impact,
                hit.normal,
            );
        }
    }
}

Fields§

§enabled: bool

Controls if the ray caster is enabled.

§origin: Vector

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

To get the global origin, use the global_origin method.

§direction: Dir3

The local direction of the ray relative to the Rotation of the ray entity or its parent.

To get the global direction, use the global_direction method.

§max_time_of_impact: Scalar

The maximum distance the ray can travel. By default this is infinite, so the ray will travel until all hits up to max_hits have been checked.

§max_hits: u32

The maximum number of hits allowed.

When there are more hits than max_hits, some hits will be missed. To guarantee that the closest hit is included, you should set max_hits to one or a value that is enough to contain all hits.

§solid: bool

Controls how the ray behaves when the ray origin is inside of a collider.

If solid is true, the point of intersection will be the ray origin itself.
If solid is false, the collider will be considered to have no interior, and the point of intersection will be at the collider shape’s boundary.

§ignore_self: bool

If true, the ray 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::RayCasterCopy item path

§Hit count and order

§Example

Fields§

Implementations§

impl RayCaster

pub fn new(origin: Vector, direction: Dir3) -> Self

pub fn from_ray(ray: Ray3d) -> Self

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

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

pub fn with_solidness(self, solid: 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_direction(&self) -> Dir3

Trait Implementations§

impl Clone for RayCaster

fn clone(&self) -> RayCaster

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

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

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

fn register_component_hooks(_hooks: &mut ComponentHooks)

impl Debug for RayCaster

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

impl Default for RayCaster

fn default() -> Self

impl From<Ray3d> for RayCaster

fn from(ray: Ray3d) -> 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)

impl PartialEq for RayCaster

fn eq(&self, other: &RayCaster) -> bool

fn ne(&self, other: &Rhs) -> bool

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 RayCasterwhere 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

impl StructuralPartialEq for RayCaster

Auto Trait Implementations§

impl Freeze for RayCaster

impl RefUnwindSafe for RayCaster

impl Send for RayCaster

impl Sync for RayCaster

Struct avian3d::spatial_query::RayCaster

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

impl TypePath for RayCaster
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,