include/rive/animation/linear_animation_instance.hpp

#ifndef _RIVE_LINEAR_ANIMATION_INSTANCE_HPP_
#define _RIVE_LINEAR_ANIMATION_INSTANCE_HPP_

#include "rive/artboard.hpp"
#include "rive/scene.hpp"

namespace rive {
    class LinearAnimation;

    class LinearAnimationInstance : public Scene {
    private:
        const LinearAnimation* m_Animation = nullptr;
        float m_Time;
        float m_TotalTime;
        float m_LastTotalTime;
        float m_SpilledTime;
        int m_Direction;
        bool m_DidLoop;
        int m_LoopValue = -1;

    public:
        LinearAnimationInstance(const LinearAnimation*, ArtboardInstance*);

        // Advance the animation by the specified time. Returns true if the
        // animation will continue to animate after this advance.
        bool advance(float seconds);
    
        // Returns a pointer to the instance's animation
        const LinearAnimation* animation() const { return m_Animation; }

        // Returns the current point in time at which this instance has advance
        // to
        float time() const { return m_Time; }

        // Returns the direction that we are currently playing in
        float direction() const { return m_Direction; }

        // Update the direction of the animation instance, positive value for
        // forwards Negative for backwards
        void direction(int direction) {
            if (direction > 0) {
                m_Direction = 1;
            } else {
                m_Direction = -1;
            }
        }

        // Sets the animation's point in time.
        void time(float value);

        // Applies the animation instance to its artboard instance. The mix (a value
        // between 0 and 1) is the strength at which the animation is mixed with
        // other animations applied to the artboard.
        void apply(float mix = 1.0f) const {
            m_Animation->apply(m_ArtboardInstance, m_Time, mix);
        }

        // Set when the animation is advanced, true if the animation has stopped
        // (oneShot), reached the end (loop), or changed direction (pingPong)
        bool didLoop() const { return m_DidLoop; }

        float totalTime() const { return m_TotalTime; }
        float lastTotalTime() const { return m_LastTotalTime; }
        float spilledTime() const { return m_SpilledTime; }
        float durationSeconds() const override;

        // Forwarded from animation
        uint32_t fps() const;
        uint32_t duration() const;
        float speed() const;
        float startSeconds() const;
    
        // Returns either the animation's default or overridden loop values
        Loop loop() const override { return (Loop)loopValue(); }
        int loopValue() const;
        // Override the animation's default loop
        void loopValue(int value);

        bool isTranslucent() const override;
        bool advanceAndApply(float seconds) override;
        std::string name() const override;
    };
} // namespace rive
#endif