Struct leafwing_input_manager::input_processing::dual_axis::DualAxisDeadZone

pub struct DualAxisDeadZone { /* private fields */ }

A scaled version of DualAxisExclusion with the bounds set to DualAxisBounds::symmetric_all(1.0) that normalizes non-excluded input values into the “live zone”, the remaining range within the bounds after dead zone exclusion.

Each axis is processed individually, resulting in a per-axis “snapping” effect, which enhances control precision for pure axial motion.

It is worth considering that this normalizer increases the magnitude of diagonal values. If that is not your goal, you might want to explore alternative normalizers.

In simple terms, this processor is just the dual-axis version of AxisDeadZone. Helpers like AxisDeadZone::extend_dual() and its peers can be used to create a DualAxisDeadZone.

use bevy::prelude::*;
use leafwing_input_manager::prelude::*;

// Exclude X within [-0.2, 0.3] and Y within [-0.1, 0.4].
let deadzone = DualAxisDeadZone::new((-0.2, 0.3), (-0.1, 0.4));
assert_eq!(deadzone.deadzone_x().exclusion().min_max(), (-0.2, 0.3));
assert_eq!(deadzone.deadzone_y().exclusion().min_max(), (-0.1, 0.4));

// Another way to create a DualAxisDeadZone.
let deadzone_x = AxisDeadZone::new(-0.2, 0.3);
let deadzone_y = AxisDeadZone::new(-0.1, 0.4);
assert_eq!(deadzone_x.extend_dual_with_y(deadzone_y), deadzone);

for x in -300..300 {
    let x = x as f32 * 0.01;
    for y in -300..300 {
        let y = y as f32 * 0.01;
        let value = Vec2::new(x, y);

        assert_eq!(deadzone.normalize(value).x, deadzone_x.normalize(x));
        assert_eq!(deadzone.normalize(value).y, deadzone_y.normalize(y));
    }
}

Implementations

impl DualAxisDeadZone

pub const ZERO: Self = _

Zero-size DualAxisDeadZone, only restricting values to the range [-1.0, 1.0] on both axes.

pub fn new( (x_negative_max, x_positive_min): (f32, f32), (y_negative_max, y_positive_min): (f32, f32), ) -> Self

Creates a DualAxisDeadZone that excludes values within the range [negative_max, positive_min] on each axis.

Requirements

• negative_max <= 0.0 <= positive_min on each axis.

Panics

Panics if the requirements aren’t met.

pub fn all(negative_max: f32, positive_min: f32) -> Self

Creates a DualAxisDeadZone that excludes values within the range [negative_max, positive_min] on both axes.

Requirements

• negative_max <= 0.0 <= positive_min.

Panics

Panics if the requirements aren’t met.

pub fn only_x(negative_max: f32, positive_min: f32) -> Self

Creates a DualAxisDeadZone that only excludes X values within the range [negative_max, positive_min].

Requirements

• negative_max <= 0.0 <= positive_min.

Panics

Panics if the requirements aren’t met.

pub fn only_y(negative_max: f32, positive_min: f32) -> Self

Creates a DualAxisDeadZone that only excludes Y values within the range [negative_max, positive_min].

Requirements

• negative_max <= 0.0 <= positive_min.

Panics

Panics if the requirements aren’t met.

pub fn symmetric(threshold_x: f32, threshold_y: f32) -> Self

Creates a DualAxisDeadZone that excludes values within the range [-threshold, threshold] on each axis.

Requirements

• threshold >= 0.0 on each axis.

Panics

Panics if the requirements aren’t met.

pub fn symmetric_all(threshold: f32) -> Self

Creates a DualAxisDeadZone that excludes values within the range [-threshold, threshold] on both axes.

Requirements

• threshold >= 0.0.

Panics

Panics if the requirements aren’t met.

pub fn symmetric_only_x(threshold: f32) -> Self

Creates a DualAxisDeadZone that only excludes X values within the range [-threshold, threshold].

Requirements

• threshold >= 0.0.

Panics

Panics if the requirements aren’t met.

pub fn symmetric_only_y(threshold: f32) -> Self

Creates a DualAxisDeadZone that only excludes Y values within the range [-threshold, threshold].

Requirements

• threshold >= 0.0.

Panics

Panics if the requirements aren’t met.

pub fn deadzones(&self) -> (AxisDeadZone, AxisDeadZone)

Returns the dead zones for inputs along each axis.

pub fn deadzone_x(&self) -> AxisDeadZone

Returns the dead zone for the X-axis inputs.

pub fn deadzone_y(&self) -> AxisDeadZone

Returns the dead zone for the Y-axis inputs.

pub fn exclusion(&self) -> DualAxisExclusion

Returns the DualAxisExclusion used by this deadzone.

pub fn bounds(&self) -> DualAxisBounds

Returns the DualAxisBounds used by this deadzone.

pub fn within_exclusion(&self, input_value: Vec2) -> BVec2

Is the given input_value within the exclusion ranges?

pub fn within_bounds(&self, input_value: Vec2) -> BVec2

Is the given input_value within the bounds?

pub fn within_livezone_lower(&self, input_value: Vec2) -> BVec2

Is the given input_value within the lower live zone?

pub fn within_livezone_upper(&self, input_value: Vec2) -> BVec2

Is the given input_value within the upper live zone?

pub fn normalize(&self, input_value: Vec2) -> Vec2

Normalizes input values into the live zone.

Trait Implementations

impl Clone for DualAxisDeadZone

fn clone(&self) -> DualAxisDeadZone

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DualAxisDeadZone

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

Formats the value using the given formatter.

impl Default for DualAxisDeadZone

fn default() -> Self

Creates a DualAxisDeadZone that excludes input values within the deadzone [-0.1, 0.1] on both axes.

impl<'de> Deserialize<'de> for DualAxisDeadZone

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<DualAxisDeadZone> for DualAxisProcessor

fn from(value: DualAxisDeadZone) -> Self

Converts to this type from the input type.

impl From<DualAxisExclusion> for DualAxisDeadZone

fn from(exclusion: DualAxisExclusion) -> Self

Converts to this type from the input type.

impl FromReflect for DualAxisDeadZone

where Self: Any + Send + Sync, AxisDeadZone: FromReflect + TypePath + RegisterForReflection,

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

Constructs a concrete instance of Self from a reflected value.

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

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for DualAxisDeadZone

where Self: Any + Send + Sync, AxisDeadZone: FromReflect + TypePath + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl Hash for DualAxisDeadZone

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for DualAxisDeadZone

fn eq(&self, other: &DualAxisDeadZone) -> 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 Reflect for DualAxisDeadZone

where Self: Any + Send + Sync, AxisDeadZone: FromReflect + TypePath + RegisterForReflection,

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

Returns the TypeInfo of the type represented by this value.

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

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

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

Returns the value as a &mut dyn Any.

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

Casts this type to a boxed reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a reflected value.

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

Casts this type to a mutable reflected value.

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

Clones the value as a Reflect trait object.

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

Performs a type-checked assignment of a reflected value to this value.

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

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

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

Returns an immutable enumeration of “kinds” of type.

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

Returns a mutable enumeration of “kinds” of type.

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

Returns an owned enumeration of “kinds” of type.

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

Returns a “partial equality” comparison result.

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

Applies a reflected value to this value.

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

Returns a hash of the value (which includes the type).

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

Debug formatter for the value.

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

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Serialize for DualAxisDeadZone

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Struct for DualAxisDeadZone

where Self: Any + Send + Sync, AxisDeadZone: FromReflect + TypePath + RegisterForReflection,

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

Returns a reference to the value of the field named name as a &dyn Reflect.

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

Returns a mutable reference to the value of the field named name as a &mut dyn Reflect.

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

Returns a reference to the value of the field with index index as a &dyn Reflect.

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

Returns a mutable reference to the value of the field with index index as a &mut dyn Reflect.

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

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

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

Returns an iterator over the values of the reflectable fields for this struct.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

impl TypePath for DualAxisDeadZone

where Self: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

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

Returns the name of the type, or None if it is anonymous.

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

Returns the name of the crate the type is in, or None if it is anonymous.

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

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for DualAxisDeadZone

where Self: Any + Send + Sync, AxisDeadZone: FromReflect + TypePath + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for DualAxisDeadZone

impl Eq for DualAxisDeadZone

impl StructuralPartialEq for DualAxisDeadZone