leafwing_input_manager::input_processing::dual_axis

Struct CircleDeadZone

pub struct CircleDeadZone { /* private fields */ }

Expand description

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

It is worth considering that this normalizer reduces input values on diagonals. If that is not your goal, you might want to explore alternative normalizers.

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

// Exclude magnitudes less than or equal to 0.2
let deadzone = CircleDeadZone::new(0.2);

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

        // Values within the dead zone are treated as zeros.
        if value.length() <= 0.2 {
            assert!(deadzone.within_exclusion(value));
            assert_eq!(deadzone.normalize(value), Vec2::ZERO);
        }

        // Values within the live zone are scaled linearly.
        else if value.length() <= 1.0 {
            assert!(deadzone.within_livezone(value));

            let expected_scale = f32::inverse_lerp(0.2, 1.0, value.length());
            let expected = value.normalize() * expected_scale;
            let delta = (deadzone.normalize(value) - expected).abs();
            assert!(delta.x <= 0.00001);
            assert!(delta.y <= 0.00001);
        }

        // Values outside the bounds are restricted to the region.
        else {
            assert!(!deadzone.within_bounds(value));

            let expected = value.clamp_length_max(1.0);
            let delta = (deadzone.normalize(value) - expected).abs();
            assert!(delta.x <= 0.00001);
            assert!(delta.y <= 0.00001);
        }
    }
}

Struct CircleDeadZoneCopy item path

Implementations§

impl CircleDeadZone

pub const ZERO: Self = _

pub fn new(threshold: f32) -> Self

§Requirements

§Panics

pub fn radius(&self) -> f32

pub fn exclusion(&self) -> CircleExclusion

pub fn bounds(&self) -> CircleBounds

pub fn livezone_min_max(&self) -> (f32, f32)

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

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

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

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

Trait Implementations§

impl Clone for CircleDeadZone

fn clone(&self) -> CircleDeadZone

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

impl Debug for CircleDeadZone

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

impl Default for CircleDeadZone

fn default() -> Self

impl<'de> Deserialize<'de> for CircleDeadZone

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

impl From<CircleDeadZone> for DualAxisProcessor

fn from(value: CircleDeadZone) -> Self

impl FromReflect for CircleDeadZonewhere Self: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

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

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

impl GetTypeRegistration for CircleDeadZonewhere Self: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

fn register_type_dependencies(registry: &mut TypeRegistry)

impl Hash for CircleDeadZone

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

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

impl PartialEq for CircleDeadZone

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

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

impl Reflect for CircleDeadZonewhere Self: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

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 apply(&mut self, value: &(dyn Reflect + 'static))

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

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

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

fn is_dynamic(&self) -> bool

impl Serialize for CircleDeadZone

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

impl Struct for CircleDeadZonewhere Self: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

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

impl Typed for CircleDeadZonewhere Self: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

fn type_info() -> &'static TypeInfo

impl Copy for CircleDeadZone

Struct CircleDeadZone

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where __D: Deserializer<'de>,

impl FromReflect for CircleDeadZone
where Self: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

impl GetTypeRegistration for CircleDeadZone
where Self: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

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

impl Reflect for CircleDeadZone
where Self: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

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

impl Struct for CircleDeadZone
where Self: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

impl TypePath for CircleDeadZone
where Self: Any + Send + Sync,

impl Typed for CircleDeadZone
where Self: Any + Send + Sync, f32: FromReflect + TypePath + RegisterForReflection,

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<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<T> DynClone for T
where T: Clone,

impl<T> DynEq for T
where T: Any + Eq,

impl<T> DynEq for T
where T: Eq + 'static,

impl<T> DynHash for T
where T: DynEq + Hash,

impl<T> DynHash for T
where T: Hash + ?Sized,

impl<T> DynamicTypePath for T
where T: TypePath,

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

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,