Struct RayCaster

Source

pub struct RayCaster {
    pub enabled: bool,
    pub origin: Vector,
    pub direction: Dir2,
    pub max_hits: u32,
    pub max_distance: Scalar,
    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 distance property which refers to how far the ray travelled, along with a normal for 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 distance 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.distance,
                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: Dir2

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_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.

§max_distance: 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.

§solid: bool

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

If true, shapes will be treated as solid, and the ray cast will return with a distance of 0.0 if the ray origin is inside of the shape. Otherwise, shapes will be treated as hollow, and the ray will always return a hit at the 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 ray cast.

Struct RayCasterCopy item path

§Hit Count and Order

§Example

Fields§

Implementations§

impl RayCaster

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

pub fn from_ray(ray: Ray2d) -> Self

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

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

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

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_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 RayCaster

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

impl Default for RayCaster

fn default() -> Self

impl From<Ray2d> for RayCaster

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

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 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 RayCasterwhere RayCaster: Any + Send + Sync,

fn type_path() -> &'static str

fn short_type_path() -> &'static str

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

Struct RayCaster

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

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