pygame.math.lerp should recieve "easing function"

[lazamal]

Problem

Currently, pygame.math.lerp(a, b, t) only performs linear interpolation. While useful, linear movement often feels "robotic" or "stiff" in game design.

To achieve smooth animations (like a UI panel sliding in or a camera smoothing effect), developers currently have to:
Manually apply an easing formula to the t value before passing it to lerp.

Find or write their own easing library.Proposed SolutionEnhance pygame.math.lerp to accept an optional easing parameter. This could be a string identifier for built-in presets or a callable function.

Proposed Syntax:

pygame.math.lerp(start, end, t, easing="ease_out_cubic")

Using a custom callable

pygame.math.lerp(start, end, t, easing=my_custom_ease_func)

Feature Details Built-in Presets: Include common formulas like quad, cubic, expo, and sine.
Mathematical Formula: The easing function would transform the t (0.0 to 1.0) value before the linear calculation is applied:$t_{eased} = f(t)$$result = a + (b - a) \times t_{eased}$Performance: These could be implemented in C within the pygame.math module for high-performance animation updates.
Documentation ImprovementsAdding this feature would require a new section in the docs explaining: The difference between linear and eased interpolation.
A list of all supported easing strings.
Visual examples or graphs of the easing curves to help developers choose the right one.

Sources for easing functions can be found here

https://easings.net/

[BatteRaquette581]

pygame.math.lerp is only a linear interpolation easing function, I think it would be very confusing to add an easing function to an linear interpolation function, to make it not linear. However, having another function like pygame.math.easing(start, end, t, easing_function) could be a better solution, with a few built-in easing functions in some new pygame.math.easings submodule.

[lazamal]

I agree with that suggestion @BatteRaquette581

[BatteRaquette581]

Well then, I'm going to have a try at implementing something like this (or even a draft if I'm lucky), but no guarantees. :p

[BatteRaquette581]

Actually, it probably would be a lot easier if they were their own seperate functions in the pygame.math.easings submodule, the pygame.math.easing function here would basically be useless.

[BatteRaquette581]

There wouldn't be much purpose to implement an easings submodule, snippets or libraries for easings in python already exists, and they may even work out of the boxes since vectors implement the Python operators.

[lazamal]

wouldnt that affect performance though? importing another library for a simple formula?

[oddbookworm]

wouldnt that affect performance though? importing another library for a simple formula?

How so? Import is a one-time thing

[BatteRaquette581]

Not really if you only import the wanted functions. For example, I found a library called rpeasings, and it seems to be programmed as a C extension to Python similar to Pygame, which should make it have optimal performance.

[joereynolds]

Hello!

I've just seen this. I've made my tween stuff public (for the purposes of this chat) for inspiration.
It's got all of the common ease types and some other niceties.

It's very coupled to my game so won't work out of the box but thought it might be a good place to pick ideas from. It took me a while to arrive at a "nice" solution

I realise this is probably too high level for what we're proposing here but at the very least you I can save you copy/pasting the easing formulas, heh.

I heavily leaned on phasers implementation of tweening for inspiration. I also looked at some how HaxeFlixel and a few others do it and arrived at this

https://github.com/joereynolds/demo-tween-stuff/tree/main

[Fantastair]

Hi everyone 👋

Just wanted to mention that pygame-ce already has a built-in smooth interpolation function called pygame.math.smoothstep(a, b, value) to solve the "robotic" linear interpolation problem.

It performs a smooth, non-linear interpolation (using the standard 3value² - 2value³ formula) with a "slow-in, fast-middle, slow-out" effect, which is perfect for UI animations, camera smoothing, etc.

Official docs for reference: https://pyga.me/docs/ref/math.html#pygame.math.smoothstep

This might be a useful reference for the feature discussion here 😊