move_towards as an analogue of lerp and rotate_towards as an analogue of slerp?

[Drumstickz64]

It would be nice to be able to "interpolate" between things with hard values rather than percentages, and this is that these methods enable us to do.

[bitshifter]

Can you elaborate on what the function signature for move towards or rotate towards methods would look like and what they would do?

[Drumstickz64]

move_towards

move_towards would allow you to move from a starting value to an ending value by a given delta, it functions much like lerp, but the difference is that it takes a delta instead of a percentage. The method signature for a Vec3 would look like this:

fn move_towards(&self, to: Vec3, delta: f32) -> Vec3

Here is some example uses of it:

// move an enemy to the player at a constant speed
enemy.transform.translation = enemy.transform.translation.move_towards(player_translation, ENEMY_SPEED * time.delta_seconds());

// gradually accelerate towards a target velocity
let target_velocity = input_direction * MAX_SPEED;
velocity = velocity.move_towards(target_velocity, ACCELERATION * time.delta_seconds())

Here is an example implementation from the godot engine, it's in c++, but it should still be helpful.

Vector3 Vector3::move_toward(const Vector3 &p_to, const real_t p_delta) const {
	Vector3 v = *this;
	Vector3 vd = p_to - v;
	real_t len = vd.length();
	return len <= p_delta || len < CMP_EPSILON ? p_to : v + vd / len * p_delta;
}

rotate_towards

For rotate_towards the aim is to gradually rotate to a target rotation, it functions much like slerp but it uses a delta instead of a percentage.
The method signature for Quat would look like this:

fn rotate_towards(&self, target: Quat, delta: f32) -> Quat

Here is an example usecase:

// gradually rotate to face the player
turret.transform.rotation = turret.transform.rotation.rotate_towards(rotation_to_player, TURRET_ROTATION_SPEED * time.delta_seconds());

[paul-hansen]

For prior art to look at, Godot just added support for rotate_toward godotengine/godot#80225 and they already had move towards

There's also a rotate towards trait that's already implemented for glam's Quat in leafwing input manager here: https://docs.rs/leafwing-input-manager/0.10.0/leafwing_input_manager/orientation/trait.Orientation.html#method.rotate_towards
Perhaps a bit more generic than needed, and awkwardly takes an option for the rotation for unknown reasons.
(Also is an odd crate to have to import it from esp. if you don't need input mapping)

[bitshifter]

Merged in #492

[bitshifter]

Actually re-opened because only move_torwards was added.

[bitshifter]

rotate_towards was added for Vec2 and Quat.