Struct DualAxisDeadZone 

pub struct DualAxisDeadZone {
    pub deadzone_x: AxisDeadZone,
    pub deadzone_y: AxisDeadZone,
}

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));
    }
}

Fields

deadzone_x: AxisDeadZone

The AxisDeadZone for the X-axis inputs.

deadzone_y: AxisDeadZone

The AxisDeadZone for the Y-axis inputs.

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 only_positive(x_positive_min: f32, y_positive_min: f32) -> Self

Creates a DualAxisDeadZone that only passes positive values that greater than positive_min on each axis.

Requirements

• positive_min >= 0.0 on each axis.

Panics

Panics if the requirements aren’t met.

pub fn only_positive_all(positive_min: f32) -> Self

Creates a DualAxisDeadZone that only passes positive values that greater than positive_min on both axes.

Requirements

• positive_min >= 0.0.

Panics

Panics if the requirements aren’t met.

pub fn only_positive_x(positive_min: f32) -> Self

Creates a DualAxisDeadZone that only excludes X values that less than or equal to positive_min.

Requirements

• positive_min >= 0.0.

Panics

Panics if the requirements aren’t met.

pub fn only_positive_y(positive_min: f32) -> Self

Creates a DualAxisDeadZone that only excludes Y values that less than or equal to positive_min.

Requirements

• positive_min >= 0.0.

Panics

Panics if the requirements aren’t met.

pub fn only_negative(x_negative_max: f32, y_negative_max: f32) -> Self

Creates a DualAxisDeadZone that only passes negative values that less than negative_max on each axis.

Requirements

• negative_max <= 0.0 on each axis.

Panics

Panics if the requirements aren’t met.

pub fn only_negative_all(negative_max: f32) -> Self

Creates a DualAxisDeadZone that only passes negative values that less than negative_max on both axes.

Requirements

• negative_max <= 0.0.

Panics

Panics if the requirements aren’t met.

pub fn only_negative_x(negative_max: f32) -> Self

Creates a DualAxisDeadZone that only excludes X values that greater than or equal to negative_max.

Requirements

• positive_min >= 0.0.

Panics

Panics if the requirements aren’t met.

pub fn only_negative_y(negative_max: f32) -> Self

Creates a DualAxisDeadZone that only excludes Y values that greater than or equal to negative_max.

Requirements

• positive_min >= 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 duplicate 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

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

Constructs a concrete instance of Self from a reflected value.

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

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

impl GetTypeRegistration for DualAxisDeadZone

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 PartialReflect for DualAxisDeadZone

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

Returns the TypeInfo of the type represented by this value.

fn try_apply(&mut self, value: &dyn PartialReflect) -> 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 try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&dyn Reflect>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &dyn PartialReflect

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

Casts this type to a mutable, reflected value.

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

Returns a “partial equality” comparison result.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

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

Applies a reflected value to this value.

fn to_dynamic(&self) -> Box<dyn PartialReflect>

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

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 is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for DualAxisDeadZone

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, fully-reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a fully-reflected value.

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

Casts this type to a mutable, fully-reflected value.

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

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

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

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

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

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

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

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

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

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

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

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 to_dynamic_struct(&self) -> DynamicStruct

Creates a new DynamicStruct from this struct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl TypePath for DualAxisDeadZone

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

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