Struct Body 

#[non_exhaustive]
pub struct Body {
    pub flying: bool,
    pub noclip: bool,
    pub yaw: FreeCoordinate,
    pub pitch: FreeCoordinate,
    /* private fields */
}

An object with a position, velocity, and collision volume. What it collides with is determined externally.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

flying: bool

Is this body not subject to gravity?

noclip: bool

Is this body not subject to collision?

yaw: FreeCoordinate

Yaw of the camera look direction, in degrees clockwise from looking towards -Z.

The preferred range is 0 inclusive to 360 exclusive.

This does not affect the behavior of the Body itself; it has nothing to do with the direction of the velocity.

pitch: FreeCoordinate

Pitch of the camera look direction, in degrees downward from looking horixontally.

The preferred range is -90 to 90, inclusive.

This does not affect the behavior of the Body itself; it has nothing to do with the direction of the velocity.

Implementations

impl Body

pub fn new_minimal( position: impl Into<FreePoint>, collision_box: impl Into<Aab>, ) -> Self

Constructs a Body requiring only information that can’t be reasonably defaulted.

Panics

Panics if any component of position is NaN or infinite.

pub fn position(&self) -> FreePoint

Returns the body’s current position.

If you are interested in the space it occupies, use Self::collision_box_abs() instead.

pub fn set_position(&mut self, position: FreePoint)

Sets the position of the body, disregarding collision.

Note: This may have effects that normal time stepping does not. In particular, body.set_position(body.position()) is not guaranteed to do nothing.

If position contains any component which is infinite or NaN, this function does nothing. This behavior may change in the future.

pub fn velocity(&self) -> Vector3D<f64, Velocity>

Returns the body’s current velocity.

pub fn add_velocity(&mut self, Δv: Vector3D<f64, Velocity>)

Adds the given value to the body’s velocity.

If Δv contains any component which is infinite or NaN, this function does nothing. This behavior may change in the future.

pub fn set_velocity(&mut self, v: Vector3D<f64, Velocity>)

Replaces the body’s velocity with the given value.

If Δv contains any component which is infinite or NaN, this function does nothing. This behavior may change in the future.

pub fn collision_box_rel(&self) -> Aab

Returns the body’s configured collision box in coordinates relative to Self::position().

use all_is_cubes::math::Aab;
use all_is_cubes::physics::Body;

let body = Body::new_minimal(
    (0.0, 20.0, 0.0),
    Aab::new(-1.0, 1.0, -2.0, 2.0, -3.0, 3.0)
);
assert_eq!(body.collision_box_abs(), Aab::new(-1.0, 1.0, 18.0, 22.0, -3.0, 3.0));

pub fn collision_box_abs(&self) -> Aab

Returns the body’s current collision box in world coordinates.

This is not necessarily equal in size to Self::collision_box_rel().

use all_is_cubes::math::Aab;
use all_is_cubes::physics::Body;

let body = Body::new_minimal(
    (0.0, 20.0, 0.0),
    Aab::new(-1.0, 1.0, -2.0, 2.0, -3.0, 3.0)
);
assert_eq!(body.collision_box_abs(), Aab::new(-1.0, 1.0, 18.0, 22.0, -3.0, 3.0));

pub fn look_direction(&self) -> FreeVector

Returns the direction the body is facing (when it is part of a character).

pub fn set_look_direction(&mut self, direction: FreeVector)

Changes self.yaw and self.pitch to look in the given direction vector.

If direction has zero length, the resulting direction is unspecified but valid.

Trait Implementations

impl Clone for Body

fn clone(&self) -> Body

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for Body

where Self: Send + Sync + 'static,

Required Components: [PhysicsOutputs], [rg :: Destination].

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 = Mutable

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, components: &mut ComponentsRegistrator<'_>, required_components: &mut RequiredComponents, inheritance_depth: u16, recursion_check_stack: &mut Vec<ComponentId>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

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

fn register_component_hooks(hooks: &mut ComponentHooks)

👎Deprecated since 0.16.0: Use the individual hook methods instead (e.g., Component::on_add, etc.)

Called when registering this component, allowing mutable access to its ComponentHooks.

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

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

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 Debug for Body

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Body

Available on crate feature save only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Fmt<StatusText> for Body

Omits collision box on the grounds that it is presumably constant

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

Formats self as specified by fopt into destination fmt.

impl PartialEq for Body

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Body

Available on crate feature save only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Transactional for Body

type Transaction = BodyTransaction

The type of transaction which should be used with Self.

fn transact<'c, F, O>( &mut self, f: F, ) -> Result<O, ExecuteError<Self::Transaction>>

where F: FnOnce(&mut Self::Transaction, &Self) -> Result<O, <Self::Transaction as Merge>::Conflict>, Self::Transaction: Transaction<Target = Self, Context<'c> = (), Output = NoOutput> + Default,

Convenience method for building and then applying a transaction to self, equivalent to the following steps:

impl StructuralPartialEq for Body