Rescale Axis and Button value to avoid compression

[thibaudio]

Objective

Fixes #3450

Solution

Apply the suggested solution to both AxisSettings positive/negative values and ButtonAxisSettings

[thibaudio]

I'll update the test later today

[sixfold-origami]

Looks pretty nice! I have one nitpick, and a weird edge case to consider

[sixfold-origami]

This looks really good! Just one question for you

[alice-i-cecile]

This needs more comments, or a simpler approach.

[thibaudio]

Tried to split this into several smaller functions. Is that better?

[alice-i-cecile]

Two changes:

1. Add inline annotations to the added methods.
2. The changes on line 203 are far too complex; this needs more comments or preferably structure.

@thibaudio, you can mark comments as resolved by pressing the "Resolve comment" button once they're addressed, which makes it easier for reviewers.

[thibaudio]

Two changes:

1. Add `inline` annotations to the added methods.

2. The changes on line 203 are far too complex; this needs more comments or preferably structure.

@thibaudio, you can mark comments as resolved by pressing the "Resolve comment" button once they're addressed, which makes it easier for reviewers.

Thanks for the review @alice-i-cecile
I tried to refactor the changes around threshold testing for better readability, looking forward to your comments!

[alice-i-cecile]

This refactor is definitely an improvement! Spending some time thinking about this, I think the most natural way to model and communicate this in Rust would actually be with:

enum AxisPosition {
   BelowLowZone,
   LowZone,
   DeadZone,
   HighZone,
   AboveHighZone,
}

I think that if we start there, we can make this code much easier to read and refactor in the future. Does that make sense to you?

[thibaudio]

Thanks for your feedback @alice-i-cecile!
Before going any further, I just wanted to check if you had something like that in mind:

enum ScaledAxisPosition {
    BelowLowZone,
    LowZone(f32),
    DeadZone,
    HighZone(f32),
    AboveHighZone,
}

#[derive(Debug, Clone)]
struct AxisPosition {
    scaled: Option<ScaledAxisPosition>,
    raw: f32
}

impl AxisSettings {
    fn filter(&self, new_value: f32, old_value: Option<AxisPosition>) -> Option<AxisPosition> {
        let axis_position = AxisPosition {
            scaled: Some(self.get_axis_position_from_raw_value(new_value)),
            raw: new_value
        };
        if let Some(old_value) = old_value {
            if self.delta_bellow_threshold(axis_position, old_value) {
                return None;
            }
        }

        Some(axis_position)
    }

    fn get_axis_position_from_raw_value(&self, value: f32) -> ScaledAxisPosition {
        if value <= self.positive_low && value >= self.negative_low {
            ScaledAxisPosition::DeadZone
        } else if value >= self.positive_high {
            ScaledAxisPosition::AboveHighZone
        } else if value <= self.negative_high {
            ScaledAxisPosition::BelowLowZone
        } else if value > self.positive_low {
            ScaledAxisPosition::HighZone(scale(value, self.positive_low, self.positive_high))
        } else {
            ScaledAxisPosition::LowZone(-1.0 * scale(value, self.negative_low, self.negative_high))
        }
    }

[alice-i-cecile]

Yes, that's lovely!

[thibaudio]

After toying with that, changing the return type of the filter method is too big of an impact for me to handle.

[alice-i-cecile]

Thanks for letting us know. I'll see about making a PR to your branch with the changes :)