scale animation problem

[Mortal]

hello

i'm having trouble time with scale animation which i thought it will be most easiest part in my game that i'm working on. but it turned i was wrong about it.

my goal is to achieve smooth and constant scaling animation. i have implemented the "easing" technique to calculate ratio of scale amount that need to step each frame to sprite object. it seems run but i didn't get what i was looking for.  the scaling effect is varying from time to time which is not suppose to happen. some time it goes faster while other goes slower.

also, i have faced problem with float point comparison that i can't compare two float values for equality with if statement, i had to implement "close enough" approach.

i have created minimal example to demonstrate the issue:

(click to show/hide)

#include <iostream>
#include <limits>
#include <cstdlib>
#include <cassert>
#include <functional>
#include <SFML/Graphics.hpp>

int main()
{
        sf::RenderWindow window({ 512u, 512u }, "scale animation test");

        sf::RectangleShape shape({ 16, 32 });
        shape.setFillColor(sf::Color::Red);
        shape.setPosition(window.getDefaultView().getCenter());
        shape.setOrigin(shape.getLocalBounds().width / 2.f, shape.getLocalBounds().height / 2.f);

        sf::Clock clock;
        auto timeSinceLastUpdate = sf::Time::Zero;
        const auto TimePerFrame = sf::seconds(1 / 60.f);

        bool scaleToggle = true;

        auto closeEnough = // for float point comparing
                [](auto a, auto b, auto epsilon)
        {
                assert(std::isless(0, epsilon)); // epsilon is a part of the whole quantity
                assert(std::isless(epsilon, 1));

                const auto delta = std::abs(a - b);
                const auto x = std::abs(a);
                const auto y = std::abs(b);

                // comparable generally and |a - b| < eps * (|a| + |b|) / 2
                return std::isless(epsilon * y, x)
                        && std::isless(epsilon * x, y)
                        && std::isless((delta + delta) / (x + y), epsilon);
        };

        auto scalingEffect =
                [&](const auto& targetScale)
        {
                auto resultScale = shape.getScale();
                const static auto speed = 16.f;

                // easing in tearm of constant speed
                resultScale += (targetScale - resultScale) * speed * TimePerFrame.asSeconds();

                shape.setScale(resultScale);

                return closeEnough(targetScale.y, resultScale.y, 0.001f); // compare float points
        };

        auto update = [&]()
        {
                auto dt = clock.restart();
                timeSinceLastUpdate += dt;

                while (timeSinceLastUpdate > TimePerFrame)
                {
                        timeSinceLastUpdate -= TimePerFrame;

                        // run the animation
                        if (scaleToggle)
                        {
                                if (scalingEffect(sf::Vector2f{ 1.f, 0.5f }))
                                        scaleToggle = !scaleToggle;
                        }
                        else
                        {
                                if (scalingEffect(sf::Vector2f{ 1.f, 1.f }))
                                        scaleToggle = !scaleToggle;
                        }
                }
        };

        auto render = [&]()
        {
                window.clear();
                window.draw(shape);
                window.display();
        };

        auto processEvent = [&]()
        {
                sf::Event event;
                while (window.pollEvent(event))
                {
                        if (event.type == sf::Event::Closed)
                                window.close();
                }
        };

        // game loop
        while (window.isOpen())
        {
                processEvent();
                update();
                render();
        }
}

my questions
how can i fix this tripping in animation?, is my implementation is correct? and are there other ways to achieve smooth and constant scale animation?

Edit: i fixed it, my bad, it was a bug in both source code. i corrected example here and code in my game both work fine at last but it seems i overly complicated it for just scaling , i'm sure there is an easy way to do it, but i don't know it.

is there a better way to do scale animation?

[Ixrec]

I don't know the direct solution to your problem, but I see a huge opportunity for simplification that may very well solve it or at least make it much easier for you to figure out yourself.

Pass the desired duration of the animation to scalingEffect() along with the stuff you're already passing to it, and compute the speed based on that. Then you can get rid of scalingEffect's return value, and the entire closeEnough() function and its epsilon weirdness, since you can detect whether the animation is over simply by comparing the time elapsed so far to the desired duration of the animation.

[Mortal]

thanks Ixrec

I don't know the direct solution to your problem, but I see a huge opportunity for simplification that may very well solve it or at least make it much easier for you to figure out yourself.

yeah, me too i like the simplicity over any thing else in this matter but i had to do it for the site rules that says the minimal example should be within the main. in my game i used regular functions only

Pass the desired duration of the animation to scalingEffect() along with the stuff you're already passing to it, and compute the speed based on that. Then you can get rid of scalingEffect's return value, and the entire closeEnough() function and its epsilon weirdness, since you can detect whether the animation is over simply by comparing the time elapsed so far to the desired duration of the animation.

good point, gonna try it. luckily it works now after fixed the bug in both source codes