If you absolutely must use only one trigger and want to avoid having to hold a precise intermediate value to stay still, without a discontinuity in the middle of the input domain, you can also opt to double-cover part of the output range:
In this version:
Leaving the trigger at its neutral position maps to zero output (stationary)
Slightly squeezing the trigger begins to accelerate backwards
Holding the trigger 1/3 of the way maps to 100% reverse speed
Pushing past 1/3 slows down again, until reaching 2/3 which is again zero output
Pushing past 2/3 of the way begins to accelerate forward
Holding the trigger at 100% maps to 100% forward speed
This is a bit awkward, but it means that rest and 100% forward speed, the outputs that a player will probably want to be using most often, map to the extremes that are easiest to hold, and there are no sudden discontinuities in between. 100% reverse speed is awkward to hold precisely, but hopefully it accounts for a minority of your gameplay.
A formula to achieve this is:
output = abs(input - 1f/3f) * 3f - 1f;
We can make it a little easier to hold the extremes (stationary, full forward, and full reverse) by flattening the curve where it crosses through those points (the "soft" version graphed above):
output = (0.5f * cos(3f * PI * input) - 0.5f) * (input < 2f/3f ? 1f : -1f);
Another option you could try is to use some hysteresis, where you use one of two different mapping curves depending on recent input history.
One version of this would be that with the trigger in the neutral position, you read zero output. If you gradually squeeze the trigger, you begin accelerating forward, and once you're in "forward mode" you can use the whole analog range of the trigger to vary your forward speed. But if you return to neutral, then snap the trigger to max quickly, you "shift gears" into reverse mode, and you can then feather-out the trigger to vary your reverse speed.
In the version below, I use a mapping where in reverse gear both 0% and 100% input map to zero, so you can snap the trigger without moving immediately, then gradually ramp up your reverse speed by letting go a little, and return to neutral / get ready to switch back to forward by letting it out all the way.
public float modeSwitchThreshold = 0.9f;
public int modeSwitchTicks = 2;
public float deadZoneMin = 0.05f;
public float deadZoneMax = 0.95f;
bool _currentModeIsReverse = false;
int _ticksSinceNonZero = 0;
float UpdateSignedDisplacement(float input) {
float normalized = (input - deadZoneMin) / (deadZoneMax - deadZoneMin);
normalized = max(0, min(input, 1));
if (input == 0f) {
_ticksSinceNonZero = 0;
_currentModeIsReverse = false;
return 0f;
}
_ticksSinceNonZero++
if (_ticksSinceNonZero <= modeSwitchTicks && input > modeSwitchThreshold) {
_currentModeIsReverse = true;
}
if (_currentModeIsReverse) {
// Soft peak at 50% input -> -100% output,
// sloping smoothly to 0 at the extremes.
return 4f * (0.5f - input) * (0.5f - input) - 1;
} else {
// Straight line from 0 -> 0 to 1 -> 1
return input;
}
}
The version presented above is just an experimental starting point, and will likely need a lot of iteration and playtesting to find a mapping that feels good. The aim is just to demonstrate the core idea of the mode switch, and how you can use it to map both positive and negative speeds to your liking.
