Trait 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 at_least(self, min: f32) -> Self { ... }
    fn at_least_only_x(self, min: f32) -> Self { ... }
    fn at_least_only_y(self, min: f32) -> Self { ... }
    fn at_most(self, min: f32) -> Self { ... }
    fn at_most_only_x(self, min: f32) -> Self { ... }
    fn at_most_only_y(self, min: f32) -> Self { ... }
    fn with_circle_bounds(self, max: f32) -> Self { ... }
    fn with_deadzone(self, negative_max: f32, positive_min: f32) -> Self { ... }
    fn with_deadzone_symmetric(self, threshold: f32) -> Self { ... }
    fn only_positive(self, positive_min: f32) -> Self { ... }
    fn only_negative(self, negative_max: f32) -> Self { ... }
    fn with_deadzone_x(self, negative_max: f32, positive_min: f32) -> Self { ... }
    fn with_deadzone_x_symmetric(self, threshold: f32) -> Self { ... }
    fn only_positive_x(self, positive_min: f32) -> Self { ... }
    fn only_negative_x(self, negative_max: f32) -> Self { ... }
    fn with_deadzone_y(self, negative_max: f32, positive_min: f32) -> Self { ... }
    fn with_deadzone_y_symmetric(self, threshold: f32) -> Self { ... }
    fn only_positive_y(self, positive_min: f32) -> Self { ... }
    fn only_negative_y(self, negative_max: f32) -> Self { ... }
    fn with_circle_deadzone(self, min: f32) -> Self { ... }
    fn with_deadzone_unscaled(
        self,
        negative_max: f32,
        positive_min: f32,
    ) -> Self { ... }
    fn with_deadzone_symmetric_unscaled(self, threshold: f32) -> Self { ... }
    fn only_positive_unscaled(self, positive_min: f32) -> Self { ... }
    fn only_negative_unscaled(self, negative_max: f32) -> Self { ... }
    fn with_deadzone_x_unscaled(
        self,
        negative_max: f32,
        positive_min: f32,
    ) -> Self { ... }
    fn with_deadzone_x_symmetric_unscaled(self, threshold: f32) -> Self { ... }
    fn only_positive_x_unscaled(self, positive_min: f32) -> Self { ... }
    fn only_negative_x_unscaled(self, negative_max: f32) -> Self { ... }
    fn with_deadzone_y_unscaled(
        self,
        negative_max: f32,
        positive_min: f32,
    ) -> Self { ... }
    fn with_deadzone_y_symmetric_unscaled(self, threshold: f32) -> Self { ... }
    fn only_positive_y_unscaled(self, positive_min: f32) -> Self { ... }
    fn only_negative_y_unscaled(self, negative_max: 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 at_least(self, min: f32) -> Self

Appends a DualAxisBounds processor as the next processing step, restricting values to a minimum value on both axes.

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

Appends a DualAxisBounds processor as the next processing step, restricting X values to a minimum value.

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

Appends a DualAxisBounds processor as the next processing step, restricting Y values to a minimum value.

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

Appends a DualAxisBounds processor as the next processing step, restricting values to a maximum value on both axes.

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

Appends a DualAxisBounds processor as the next processing step, restricting X values to a maximum value.

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

Appends a DualAxisBounds processor as the next processing step, restricting Y values to a maximum value.

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

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

Requirements

• max >= 0.0.

Panics

Panics if the requirements aren’t met.

fn with_deadzone(self, negative_max: f32, positive_min: f32) -> Self

Appends a DualAxisDeadZone processor as the next processing step, excluding values within the dead zone range [negative_max, positive_min] 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.

Requirements

• negative_max <= 0.0 <= positive_min.

Panics

Panics if the requirements aren’t met.

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.

Requirements

• threshold >= 0.0.

Panics

Panics if the requirements aren’t met.

fn only_positive(self, positive_min: f32) -> Self

Appends a DualAxisDeadZone processor as the next processing step, only passing positive values that greater than positive_min on both axes and then normalizing them into the “live zone” range [positive_min, 1.0].

Requirements

• positive_min >= 0.0.

Panics

Panics if the requirements aren’t met.

fn only_negative(self, negative_max: f32) -> Self

Appends a DualAxisDeadZone processor as the next processing step, only passing negative values that less than negative_max on both axes and then normalizing them into the “live zone” range [-1.0, negative_max].

Requirements

• negative_max <= 0.0.

Panics

Panics if the requirements aren’t met.

fn with_deadzone_x(self, negative_max: f32, positive_min: f32) -> Self

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

Requirements

• negative_max <= 0.0 <= positive_min.

Panics

Panics if the requirements aren’t met.

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

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

Requirements

• threshold >= 0.0.

Panics

Panics if the requirements aren’t met.

fn only_positive_x(self, positive_min: f32) -> Self

Appends a DualAxisDeadZone processor as the next processing step, only excluding X values that less than or equal to positive_min, treating them as zeros and then normalizing non-excluded X values into the “live zone” range [positive_min, 1.0].

Requirements

• positive_min >= 0.0.

Panics

Panics if the requirements aren’t met.

fn only_negative_x(self, negative_max: f32) -> Self

Appends a DualAxisDeadZone processor as the next processing step, only excluding X values that greater than or equal to negative_max, treating them as zeros and then normalizing non-excluded X values into the “live zone” range [-1.0, negative_max].

Requirements

• negative_max <= 0.0.

Panics

Panics if the requirements aren’t met.

fn with_deadzone_y(self, negative_max: f32, positive_min: f32) -> Self

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

Requirements

• negative_max <= 0.0 <= positive_min.

Panics

Panics if the requirements aren’t met.

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

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

Requirements

• threshold >= 0.0.

Panics

Panics if the requirements aren’t met.

fn only_positive_y(self, positive_min: f32) -> Self

Appends a DualAxisDeadZone processor as the next processing step, only excluding Y values that less than or equal to positive_min, treating them as zeros and then normalizing non-excluded Y values into the range [positive_min, 1.0].

Requirements

• positive_min >= 0.0.

Panics

Panics if the requirements aren’t met.

fn only_negative_y(self, negative_max: f32) -> Self

Appends a DualAxisDeadZone processor as the next processing step, only excluding Y values that greater than or equal to negative_max, treating them as zeros and then normalizing non-excluded Y values into the range [-1.0, negative_max].

Requirements

• negative_max <= 0.0.

Panics

Panics if the requirements aren’t met.

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.

Requirements

• min >= 0.0.

Panics

Panics if the requirements aren’t met.

fn with_deadzone_unscaled(self, negative_max: f32, positive_min: f32) -> Self

Appends a DualAxisExclusion processor as the next processing step, ignoring values within the range [negative_max, positive_min] on both axes, treating them as zeros.

Requirements

• negative_max <= 0.0 <= positive_min.

Panics

Panics if the requirements aren’t met.

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

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

Requirements

• threshold >= 0.0.

Panics

Panics if the requirements aren’t met.

fn only_positive_unscaled(self, positive_min: f32) -> Self

Appends a DualAxisExclusion processor as the next processing step, only passing positive values that greater than positive_min on both axes, treating them as zeros.

Requirements

• positive_min >= 0.0.

Panics

Panics if the requirements aren’t met.

fn only_negative_unscaled(self, negative_max: f32) -> Self

Appends a DualAxisExclusion processor as the next processing step, only passing negative values that less than negative_max on both axes, treating them as zeros.

Requirements

• negative_max <= 0.0.

Panics

Panics if the requirements aren’t met.

fn with_deadzone_x_unscaled(self, negative_max: f32, positive_min: f32) -> Self

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

Requirements

• negative_max <= 0.0 <= positive_min.

Panics

Panics if the requirements aren’t met.

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

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

Requirements

• threshold >= 0.0.

Panics

Panics if the requirements aren’t met.

fn only_positive_x_unscaled(self, positive_min: f32) -> Self

Appends a DualAxisExclusion processor as the next processing step, only excluding X values that less than or equal to positive_min, treating them as zeros.

Requirements

• positive_min >= 0.0.

Panics

Panics if the requirements aren’t met.

fn only_negative_x_unscaled(self, negative_max: f32) -> Self

Appends a DualAxisExclusion processor as the next processing step, only excluding X values that greater than or equal to negative_max, treating them as zeros.

Requirements

• negative_max <= 0.0.

Panics

Panics if the requirements aren’t met.

fn with_deadzone_y_unscaled(self, negative_max: f32, positive_min: f32) -> Self

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

Requirements

• negative_max <= 0.0 <= positive_min.

Panics

Panics if the requirements aren’t met.

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

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

Requirements

• threshold >= 0.0.

Panics

Panics if the requirements aren’t met.

fn only_positive_y_unscaled(self, positive_min: f32) -> Self

Appends a DualAxisExclusion processor as the next processing step, only excluding Y values that less than or equal to positive_min, treating them as zeros.

Requirements

• positive_min >= 0.0.

Panics

Panics if the requirements aren’t met.

fn only_negative_y_unscaled(self, negative_max: f32) -> Self

Appends a DualAxisExclusion processor as the next processing step, only excluding Y values that greater than or equal to negative_max, treating them as zeros.

Requirements

• negative_max <= 0.0.

Panics

Panics if the requirements aren’t met.

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.

Requirements

• min >= 0.0.

Panics

Panics if the requirements aren’t met.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl WithDualAxisProcessingPipelineExt for GamepadStick

impl WithDualAxisProcessingPipelineExt for MouseMove

impl WithDualAxisProcessingPipelineExt for MouseScroll

impl WithDualAxisProcessingPipelineExt for VirtualDPad