Struct Smooth 

pub struct Smooth<A: AxisBinding> {
    pub binding: A,
    pub tau: f32,
    /* private fields */
}

A filter that smooths axis values using exponential smoothing.

tau is the time constant that controls the amount of smoothing. Small tau values result in less smoothing (more responsive), while large tau values result in more smoothing (less responsive).

Fields

binding: A

tau: f32

Implementations

impl<A: AxisBinding> Smooth<A>

pub fn new(binding: A, tau: f32) -> Self

Examples found in repository

examples/smoothing.rs (line 13)

fn main() {
    let bindings = (
        Pair(KeyCode::KeyA, KeyCode::KeyD),
        Deadzone(GamepadAxis::LeftStickX, 0.1),
    );
    App::new()
        .add_plugins(DefaultPlugins)
        .add_axis::<Unsmoothed>(bindings)
        .add_axis::<Smoothed>(Smooth::new(bindings, 0.1))
        .add_systems(Startup, setup)
        .add_systems(Update, test)
        .run();
}

examples/all_bindings.rs (lines 13-22)

fn main() {
    // Any type that implements AxisBinding can be used as an axis binding. A lot of bindings can be nested and combined
    // to create more complex behaviors.
    let _super_complex_axis_binding = WithTriggerBinding(
        Smooth::new(
            Deadzone(
                (
                    Pair(KeyCode::KeyA, GamepadAxis::LeftStickX),
                    Multiply(32.0, GamepadAxis::LeftStickX),
                ),
                0.1,
            ),
            0.2,
        ),
        MouseButton::Left,
    );

    // The same complex axis binding can be built using the AxisBindingBuilder trait methods. AxisBindingBuilder is
    // implemented for all AxisBinding types, so all bindings have access to these combinator methods. Triggers have the
    // equivalent TriggerBindingBuilder trait.
    let _super_complex_axis_binding_built_different = (
        Pair(KeyCode::KeyA, GamepadAxis::LeftStickX),
        32.0.mult(GamepadAxis::LeftStickX),
    )
        .deadzone(0.1)
        .smooth(0.2)
        .with_trigger_binding(MouseButton::Left);

    //
    // Bindings:
    //
    App::new()
        .add_plugins(DefaultPlugins)
        //
        // Axis bindings:
        //
        // Basic axis bindings
        .add_axis::<EmptyAxis>(()) // Empty binding that always returns and will not contribute to the axis value.
        .add_axis::<ConstantAxis>(1.0) // AxisBinding is implemented for f32. It's a constant binding that always returns the given value.
        .add_axis::<KeyCodeAxis>(KeyCode::Space) // Binding that returns 1.0 when the specified key is pressed.
        .add_axis::<MouseButtonAxis>(MouseButton::Left) // Binding that returns 1.0 when the specified mouse button is pressed.
        .add_axis::<GamepadButtonAxis>(GamepadButton::South) // Binding that returns the value of the specified gamepad button.
        .add_axis::<GamepadAxisAxis>(GamepadAxis::LeftStickX) // Binding that returns the value of the specified gamepad axis.
        .add_axis::<MouseMovementAxis>(MouseY) // Binding that returns the mouse movement delta. Also works for MouseX.
        .add_axis::<MouseWheelAxis>(MouseWheel::default()) // Binding that returns the mouse wheel scroll delta.
        .add_axis::<BoxedAxis>(Box::new(KeyCode::KeyW) as Box<dyn AxisBinding>) // Box<dyn AxisBinding> also implements the AxisBinding trait.
        // Axis combinators
        .add_axis::<TupleAxis>((KeyCode::KeyW, GamepadAxis::LeftStickX)) // Tuple of AxisBindings. All active bindings are averaged.
        .add_axis::<VecAxis>(vec![KeyCode::KeyW, KeyCode::ArrowUp]) // Vec of AxisBindings. All active bindings are averaged.
        .add_axis::<PairAxis>(Pair(KeyCode::KeyS, KeyCode::KeyW)) // Pair combinator that uses the first binding for negative direction and the second for positive.
        .add_axis::<WithTriggerAxis>(WithTriggerBinding(MouseY, MouseButton::Left)) // Axis that is only active when the trigger binding is active.
        // Axis filters
        .add_axis::<DeadzoneAxis>(Deadzone(GamepadAxis::LeftStickX, 0.2)) // Deadzone filter that ignores small input values.
        .add_axis::<SmoothAxis>(Smooth::new(GamepadAxis::LeftStickX, 0.1)) // Smooth filter that smooths input values over time.
        .add_axis::<NormalizeAxis>(Normalize(GamepadAxis::LeftStickX, GamepadAxis::LeftStickY)) // Constrain the first given axis to a unit circle when combined with the second axis.
        .add_axis::<RateLimitAxis>(RateLimit::new(GamepadAxis::LeftStickX, 1.0)) // Rate limit filter that limits how quickly the axis value can change over time.
        .add_axis::<ClampAxis>(Clamp(GamepadAxis::LeftStickX, -0.5, 0.5)) // Clamp filter that clamps the axis value to the given min and max.
        // Axis modifiers
        .add_axis::<MultiplyAxis>(Multiply(GamepadAxis::LeftStickX, 0.5)) // Modifier that multiplies two axis values together.
        .add_axis::<DivideAxis>(Divide(GamepadAxis::LeftStickX, 2.0)) // Modifier that divides the first axis by the second axis.
        .add_axis::<AddAxis>(Add(GamepadAxis::LeftStickX, 0.5)) // Modifier that adds two axis values together.
        .add_axis::<SubtractAxis>(Subtract(GamepadAxis::LeftStickX, 0.5)) // Modifier that subtracts the second axis from the first axis.
        .add_axis::<InvertAxis>(Invert(GamepadAxis::LeftStickX)) // Invert modifier that negates the axis value.
        .add_axis::<WithCurveAxis>(WithCurve(GamepadAxis::LeftStickX, EaseFunction::BounceIn)) // Modifier that applies a curve to the axis value.
        .add_axis::<TransformationAxis>(Transformation(GamepadAxis::LeftStickX, |v| v * v)) // Modifier that applies a custom transformation function to the axis value.
        .add_axis::<RemapAxis>(Remap(GamepadAxis::LeftStickX, -1.0, 1.0, 0.0, 1.0)) // Modifier that remaps the axis value from one range to another.
        //
        // Triggers:
        //
        // Basic trigger bindings
        .add_trigger::<EmptyTrigger>(()) // Empty trigger that is never active.
        .add_trigger::<ConstantTrigger>(true) // Constant trigger that reflects the given boolean value.
        .add_trigger::<KeyCodeTrigger>(KeyCode::Space) // Trigger that is active when the specified key is pressed.
        .add_trigger::<MouseButtonTrigger>(MouseButton::Left) // Trigger that is active when the specified mouse button is pressed.
        .add_trigger::<GamepadButtonTrigger>(GamepadButton::South) // Trigger that is active when the specified gamepad button is pressed.
        .add_trigger::<BoxedTrigger>(Box::new(KeyCode::KeyW) as Box<dyn TriggerBinding>) // Box<dyn TriggerBinding> also implements the TriggerBinding trait.
        // Trigger combinators
        .add_trigger::<TupleTrigger>((KeyCode::KeyW, GamepadButton::South)) // Tuple of TriggerBindings. Active if any binding is active.
        .add_trigger::<VecTrigger>(vec![KeyCode::KeyW, KeyCode::ArrowUp]) // Vec of TriggerBindings. Active if any binding is active.
        .add_trigger::<AndTrigger>(And(KeyCode::KeyW, GamepadButton::South)) // Combinator that is only active if both bindings are active.
        // Trigger modifiers
        .add_trigger::<NotTrigger>(Not(KeyCode::KeyW)) // Modifier that inverts the trigger state.
        .add_systems(
            Update,
            (
                visualize_basic,
                visualize_combinators,
                visualize_filters,
                visualize_modifiers,
                draw_triggers,
            ),
        )
        .add_systems(Startup, setup)
        .insert_resource(ClearColor(Color::WHITE))
        .run();
}

Trait Implementations

impl<A: AxisBinding + Clone> AxisBinding for Smooth<A>

fn value(&mut self, inputs: &Inputs<'_>) -> Option<f32>

fn clone_axis(&self) -> Box<dyn AxisBinding>

Clones the inner value and returns it as a boxed trait object.

fn as_any(&self) -> Box<dyn Any>

Clones the inner value and returns it as a boxed Any trait object.

fn all_axes(&self) -> Vec<Box<dyn AxisBinding>>

If the binding is a “collection binding” (tuple, vec, etc.), this will split the binding into its components and return a vec of boxed bindings. Otherwise, returns a vector with a single binding.

impl<A: Clone + AxisBinding> Clone for Smooth<A>

fn clone(&self) -> Smooth<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Copy + AxisBinding> Copy for Smooth<A>