ht_tween_component.h

#pragma once

#include <ht_component.h>
#include <ht_tween_value.h>
#include <stdint.h>
#include <vector>

namespace Hatchit {

    namespace Game {

        enum class TweenPlayMode : uint8_t
        {
            Once,
            Loop,
            PingPong
        };

        enum class TweenMethod : uint8_t
        {
            Linear,
            QuadraticEaseOut,
            QuadraticEaseIn,
            QuadraticEaseInOut,
            QuadraticEaseOutIn,
            ExponentialEaseOut,
            ExponentialEaseIn,
            ExponentialEaseInOut,
            ExponentialEaseOutIn,
            CubicEaseOut,
            CubicEaseIn,
            CubicEaseInOut,
            CubicEaseOutIn,
            QuarticEaseOut,
            QuarticEaseIn,
            QuarticEaseInOut,
            QuarticEaseOutIn,
            QuinticEaseOut,
            QuinticEaseIn,
            QuinticEaseInOut,
            QuinticEaseOutIn,
            CircularEaseOut,
            CircularEaseIn,
            CircularEaseInOut,
            CircularEaseOutIn,
            SineEaseOut,
            SineEaseIn,
            SineEaseInOut,
            SineEaseOutIn,
            ElasticEaseOut,
            ElasticEaseIn,
            ElasticEaseInOut,
            ElasticEaseOutIn,
            /*
            BounceEaseOut,
            BounceEaseIn,
            BounceEaseInOut,
            BounceEaseOutIn,
            */
            BackEaseOut,
            BackEaseIn,
            BackEaseInOut,
            BackEaseOutIn,

            TweenMethodCount
        };

        class HT_API TweenComponent : public Component
        {
        public:
            typedef float(*TweenFunction)(float start, float end, float time, float duration);

            TweenComponent();

            virtual ~TweenComponent();

            virtual Core::JSON VSerialize(void) override;
            virtual bool VDeserialize(const Core::JSON& jsonObject) override;

            float GetDuration() const;

            TweenMethod GetMethod() const;

            TweenPlayMode GetPlayMode() const;

            bool IsPlaying() const;

            bool Play();

            bool Play(float duration);

            bool Play(float duration, TweenMethod method);

            bool Play(float duration, TweenMethod method, TweenPlayMode mode);

            void SetDuration(float duration);

            void SetMethod(TweenMethod method);

            void SetPlayMode(TweenPlayMode mode);

            void Stop();

            void VOnInit() override;

            virtual void VOnUpdate() override;

            void VOnDestroy() override;

            Component* VClone(void) const override;

            virtual Core::Guid VGetComponentId(void) const override;
        protected:
            static std::vector<TweenFunction> s_tweenFunctions;

            TweenValue    m_targetValue;
            TweenValue    m_startValue;
            TweenValue    m_endValue;
            TweenFunction m_tweenFunction;
            TweenMethod   m_tweenMethod;
            TweenPlayMode m_tweenPlayMode;
            float         m_startTime;
            float         m_duration;
            bool          m_isPlaying;

            static void CreateTweenFunctions();

            bool AreValuesCompatible() const;

            void VOnEnabled() override;

            void VOnDisabled() override;

        private:
            bool BeginPlay();

            void OnStop(bool interrupted);
        };

    }

}