Trait leafwing_input_manager::input_processing::dual_axis::WithDualAxisProcessingPipelineExt

pub trait WithDualAxisProcessingPipelineExt: Sized {
    // Required methods
    fn reset_processing_pipeline(self) -> Self;
    fn replace_processing_pipeline(
        self,
        processors: impl IntoIterator<Item = DualAxisProcessor>,
    ) -> Self;
    fn with_processor(self, processor: impl Into<DualAxisProcessor>) -> Self;

    // Provided methods
    fn digital(self) -> Self { ... }
    fn inverted(self) -> Self { ... }
    fn inverted_x(self) -> Self { ... }
    fn inverted_y(self) -> Self { ... }
    fn sensitivity(self, sensitivity: f32) -> Self { ... }
    fn sensitivity_x(self, sensitivity: f32) -> Self { ... }
    fn sensitivity_y(self, sensitivity: f32) -> Self { ... }
    fn with_bounds(self, min: f32, max: f32) -> Self { ... }
    fn with_bounds_symmetric(self, threshold: f32) -> Self { ... }
    fn with_bounds_x(self, min: f32, max: f32) -> Self { ... }
    fn with_bounds_x_symmetric(self, threshold: f32) -> Self { ... }
    fn with_bounds_y(self, min: f32, max: f32) -> Self { ... }
    fn with_bounds_y_symmetric(self, threshold: f32) -> Self { ... }
    fn with_circle_bounds(self, max: f32) -> Self { ... }
    fn with_deadzone(self, min: f32, max: f32) -> Self { ... }
    fn with_deadzone_symmetric(self, threshold: f32) -> Self { ... }
    fn with_deadzone_x(self, min: f32, max: f32) -> Self { ... }
    fn with_deadzone_x_symmetric(self, threshold: f32) -> Self { ... }
    fn with_deadzone_y(self, min: f32, max: f32) -> Self { ... }
    fn with_deadzone_y_symmetric(self, threshold: f32) -> Self { ... }
    fn with_circle_deadzone(self, min: f32) -> Self { ... }
    fn with_deadzone_unscaled(self, min: f32, max: f32) -> Self { ... }
    fn with_deadzone_symmetric_unscaled(self, threshold: f32) -> Self { ... }
    fn with_deadzone_x_unscaled(self, min: f32, max: f32) -> Self { ... }
    fn with_deadzone_x_symmetric_unscaled(self, threshold: f32) -> Self { ... }
    fn with_deadzone_y_unscaled(self, min: f32, max: f32) -> Self { ... }
    fn with_deadzone_y_symmetric_unscaled(self, threshold: f32) -> Self { ... }
    fn with_circle_deadzone_unscaled(self, min: f32) -> Self { ... }
}

Provides methods for configuring and manipulating the processing pipeline for dual-axis input.

Required Methods

fn reset_processing_pipeline(self) -> Self

Resets the processing pipeline, removing any currently applied processors.

fn replace_processing_pipeline( self, processors: impl IntoIterator<Item = DualAxisProcessor>, ) -> Self

Replaces the current processing pipeline with the given DualAxisProcessors.

fn with_processor(self, processor: impl Into<DualAxisProcessor>) -> Self

Appends the given DualAxisProcessor as the next processing step.

Provided Methods

fn digital(self) -> Self

Appends an DualAxisProcessor::Digital processor as the next processing step, similar to Vec2::signum but returning 0.0 for zero values.

fn inverted(self) -> Self

Appends a DualAxisInverted::ALL processor as the next processing step, flipping the sign of values on both axes.

fn inverted_x(self) -> Self

Appends a DualAxisInverted::ONLY_X processor as the next processing step, only flipping the sign of the X-axis values.

fn inverted_y(self) -> Self

Appends a DualAxisInverted::ONLY_Y processor as the next processing step, only flipping the sign of the Y-axis values.

fn sensitivity(self, sensitivity: f32) -> Self

Appends a DualAxisSensitivity processor as the next processing step, multiplying values on both axes with the given sensitivity factor.

fn sensitivity_x(self, sensitivity: f32) -> Self

Appends a DualAxisSensitivity processor as the next processing step, only multiplying the X-axis values with the given sensitivity factor.

fn sensitivity_y(self, sensitivity: f32) -> Self

Appends a DualAxisSensitivity processor as the next processing step, only multiplying the Y-axis values with the given sensitivity factor.

fn with_bounds(self, min: f32, max: f32) -> Self

Appends a DualAxisBounds processor as the next processing step, restricting values within the same range [min, max] on both axes.

fn with_bounds_symmetric(self, threshold: f32) -> Self

Appends a DualAxisBounds processor as the next processing step, restricting values within the same range [-threshold, threshold] on both axes.

fn with_bounds_x(self, min: f32, max: f32) -> Self

Appends a DualAxisBounds processor as the next processing step, only restricting values within the range [min, max] on the X-axis.

fn with_bounds_x_symmetric(self, threshold: f32) -> Self

Appends a DualAxisBounds processor as the next processing step, restricting values within the range [-threshold, threshold] on the X-axis.

fn with_bounds_y(self, min: f32, max: f32) -> Self

Appends a DualAxisBounds processor as the next processing step, only restricting values within the range [min, max] on the Y-axis.

fn with_bounds_y_symmetric(self, threshold: f32) -> Self

Appends a DualAxisBounds processor as the next processing step, restricting values within the range [-threshold, threshold] on the Y-axis.

fn with_circle_bounds(self, max: f32) -> Self

Appends a CircleBounds processor as the next processing step, restricting values to a max magnitude.

fn with_deadzone(self, min: f32, max: f32) -> Self

Appends a DualAxisDeadZone processor as the next processing step, excluding values within the dead zone range [min, max] on both axes, treating them as zeros, then normalizing non-excluded input values into the “live zone”, the remaining range within the DualAxisBounds::symmetric_all(1.0) after dead zone exclusion.

fn with_deadzone_symmetric(self, threshold: f32) -> Self

Appends a DualAxisDeadZone processor as the next processing step, excluding values within the dead zone range [-threshold, threshold] on both axes, treating them as zeros, then normalizing non-excluded input values into the “live zone”, the remaining range within the DualAxisBounds::symmetric_all(1.0) after dead zone exclusion.

fn with_deadzone_x(self, min: f32, max: f32) -> Self

Appends a DualAxisDeadZone processor as the next processing step, excluding values within the dead zone range [min, max] on the X-axis, treating them as zeros, then normalizing non-excluded input values into the “live zone”, the remaining range within the DualAxisBounds::symmetric_all(1.0) after dead zone exclusion.

fn with_deadzone_x_symmetric(self, threshold: f32) -> Self

Appends a DualAxisDeadZone processor as the next processing step, excluding values within the dead zone range [-threshold, threshold] on the X-axis, treating them as zeros, then normalizing non-excluded input values into the “live zone”, the remaining range within the DualAxisBounds::symmetric_all(1.0) after dead zone exclusion.

fn with_deadzone_y(self, min: f32, max: f32) -> Self

Appends a DualAxisDeadZone processor as the next processing step, excluding values within the dead zone range [min, max] on the Y-axis, treating them as zeros, then normalizing non-excluded input values into the “live zone”, the remaining range within the DualAxisBounds::symmetric_all(1.0) after dead zone exclusion.

fn with_deadzone_y_symmetric(self, threshold: f32) -> Self

Appends a DualAxisDeadZone processor as the next processing step, excluding values within the deadzone range [-threshold, threshold] on the Y-axis, treating them as zeros, then normalizing non-excluded input values into the “live zone”, the remaining range within the DualAxisBounds::symmetric_all(1.0) after dead zone exclusion.

fn with_circle_deadzone(self, min: f32) -> Self

Appends a CircleDeadZone processor as the next processing step, ignoring values below a min magnitude, treating them as zeros, then normalizing non-excluded input values into the “live zone”, the remaining range within the CircleBounds::new(1.0) after dead zone exclusion.

fn with_deadzone_unscaled(self, min: f32, max: f32) -> Self

Appends a DualAxisExclusion processor as the next processing step, ignoring values within the dead zone range [min, max] on both axes, treating them as zeros.

fn with_deadzone_symmetric_unscaled(self, threshold: f32) -> Self

Appends a DualAxisExclusion processor as the next processing step, ignoring values within the dead zone range [-threshold, threshold] on both axes, treating them as zeros.

fn with_deadzone_x_unscaled(self, min: f32, max: f32) -> Self

Appends a DualAxisExclusion processor as the next processing step, only ignoring values within the dead zone range [min, max] on the X-axis, treating them as zeros.

fn with_deadzone_x_symmetric_unscaled(self, threshold: f32) -> Self

Appends a DualAxisExclusion processor as the next processing step, only ignoring values within the dead zone range [-threshold, threshold] on the X-axis, treating them as zeros.

fn with_deadzone_y_unscaled(self, min: f32, max: f32) -> Self

Appends a DualAxisExclusion processor as the next processing step, only ignoring values within the dead zone range [min, max] on the Y-axis, treating them as zeros.

fn with_deadzone_y_symmetric_unscaled(self, threshold: f32) -> Self

Appends a DualAxisExclusion processor as the next processing step, only ignoring values within the dead zone range [-threshold, threshold] on the Y-axis, treating them as zeros.

fn with_circle_deadzone_unscaled(self, min: f32) -> Self

Appends a CircleExclusion processor as the next processing step, ignoring values below a min magnitude, treating them as zeros.

Object Safety

This trait is not object safe.

Implementors

impl WithDualAxisProcessingPipelineExt for GamepadStick

impl WithDualAxisProcessingPipelineExt for GamepadVirtualDPad

impl WithDualAxisProcessingPipelineExt for KeyboardVirtualDPad

impl WithDualAxisProcessingPipelineExt for MouseMove

impl WithDualAxisProcessingPipelineExt for MouseScroll