TweenAnimation.h

// Copyright (c) 2016-2018 Kiwano - Nomango
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
 
#pragma once
#include <kiwano/2d/animation/Animation.h>
#include <kiwano/2d/animation/EaseFunc.h>
#include <kiwano/utils/Logger.h>
 
namespace kiwano
{
 
class KGE_API TweenAnimation : public Animation
{
public:
    Duration GetDuration() const;
 
    void SetDuration(Duration duration);
 
    const EaseFunc& GetEaseFunc() const;
 
    void SetEaseFunc(const EaseFunc& func);
 
protected:
    TweenAnimation();
 
    TweenAnimation(Duration duration);
 
    float Interpolate(float frac);
 
    void Update(Actor* target, Duration dt) override;
 
    virtual void UpdateTween(Actor* target, float frac) = 0;
 
    void DoClone(TweenAnimation* to) const;
 
private:
    Duration dur_;
    EaseFunc ease_func_;
};
 
class KGE_API MoveByAnimation : public TweenAnimation
{
public:
    MoveByAnimation(Duration duration, const Vec2& displacement);
 
    Vec2 GetDisplacement() const;
 
    void SetDisplacement(const Vec2& displacement);
 
    MoveByAnimation* Clone() const override;
 
    MoveByAnimation* Reverse() const override;
 
protected:
    void Init(Actor* target) override;
 
    void UpdateTween(Actor* target, float frac) override;
 
protected:
    Point start_pos_;
    Point prev_pos_;
    Vec2  displacement_;
};
 
class KGE_API MoveToAnimation : public MoveByAnimation
{
public:
    MoveToAnimation(Duration duration, const Point& distination);
 
    Point GetDistination() const;
 
    void SetDistination(const Point& distination);
 
    MoveToAnimation* Clone() const override;
 
    MoveToAnimation* Reverse() const override
    {
        KGE_ERRORF("Reverse() not supported in MoveToAnimation");
        return nullptr;
    }
 
protected:
    void Init(Actor* target) override;
 
private:
    Point distination_;
};
 
class KGE_API JumpByAnimation : public TweenAnimation
{
public:
    JumpByAnimation(Duration duration, const Vec2& displacement, float height, int count = 1);
 
    Vec2 GetDisplacement() const;
 
    float GetJumpHeight() const;
 
    int GetJumpCount() const;
 
    void SetDisplacement(const Vec2& displacement);
 
    void SetJumpHeight(float height);
 
    void SetJumpCount(int count);
 
    JumpByAnimation* Clone() const override;
 
    JumpByAnimation* Reverse() const override;
 
protected:
    void Init(Actor* target) override;
 
    void UpdateTween(Actor* target, float frac) override;
 
protected:
    float height_;
    int   jump_count_;
    Point start_pos_;
    Point displacement_;
    Point prev_pos_;
};
 
class KGE_API JumpToAnimation : public JumpByAnimation
{
public:
    JumpToAnimation(Duration duration, const Point& distination, float height, int count = 1);
 
    Point GetDistination() const;
 
    void SetDistination(const Point& distination);
 
    JumpToAnimation* Clone() const override;
 
    JumpToAnimation* Reverse() const override
    {
        KGE_ERRORF("Reverse() not supported in JumpToAnimation");
        return nullptr;
    }
 
protected:
    void Init(Actor* target) override;
 
private:
    Point distination_;
};
 
class KGE_API ScaleByAnimation : public TweenAnimation
{
public:
    ScaleByAnimation(Duration duration, const Vec2& scale);
 
    float GetScaleX() const;
 
    float GetScaleY() const;
 
    void SetScaleX(float scale_x);
 
    void SetScaleY(float scale_y);
 
    ScaleByAnimation* Clone() const override;
 
    ScaleByAnimation* Reverse() const override;
 
protected:
    void Init(Actor* target) override;
 
    void UpdateTween(Actor* target, float frac) override;
 
protected:
    Vec2 start_val_;
    Vec2 delta_;
};
 
class KGE_API ScaleToAnimation : public ScaleByAnimation
{
public:
    ScaleToAnimation(Duration duration, const Vec2& scale);
 
    float GetTargetScaleX() const;
 
    float GetTargetScaleY() const;
 
    void SetTargetScaleX(float scale_x);
 
    void SetTargetScaleY(float scale_y);
 
    ScaleToAnimation* Clone() const override;
 
    ScaleToAnimation* Reverse() const override
    {
        KGE_ERRORF("Reverse() not supported in ScaleToAnimation");
        return nullptr;
    }
 
protected:
    void Init(Actor* target) override;
 
private:
    Vec2 end_val_;
};
 
class KGE_API FadeToAnimation : public TweenAnimation
{
public:
    FadeToAnimation(Duration duration, float opacity);
 
    float GetTargetOpacity() const;
 
    void SetTargetOpacity(float opacity);
 
    FadeToAnimation* Clone() const override;
 
    FadeToAnimation* Reverse() const override
    {
        KGE_ERRORF("Reverse() not supported in FadeToAnimation");
        return nullptr;
    }
 
protected:
    void Init(Actor* target) override;
 
    void UpdateTween(Actor* target, float frac) override;
 
private:
    float start_val_;
    float delta_val_;
    float end_val_;
};
 
class KGE_API RotateByAnimation : public TweenAnimation
{
public:
    RotateByAnimation(Duration duration, float rotation);
 
    float GetRotation() const;
 
    void SetRotation(float rotation);
 
    RotateByAnimation* Clone() const override;
 
    RotateByAnimation* Reverse() const override;
 
protected:
    void Init(Actor* target) override;
 
    void UpdateTween(Actor* target, float frac) override;
 
protected:
    float start_val_;
    float delta_val_;
};
 
class KGE_API RotateToAnimation : public RotateByAnimation
{
public:
    RotateToAnimation(Duration duration, float rotation);
 
    float GetTargetRotation() const;
 
    void SetTargetRotation(float rotation);
 
    RotateToAnimation* Clone() const override;
 
    RotateToAnimation* Reverse() const override
    {
        KGE_ERRORF("Reverse() not supported in RotateToAnimation");
        return nullptr;
    }
 
protected:
    void Init(Actor* target) override;
 
private:
    float end_val_;
};
 
inline const EaseFunc& TweenAnimation::GetEaseFunc() const
{
    return ease_func_;
}
 
inline Duration TweenAnimation::GetDuration() const
{
    return dur_;
}
 
inline void TweenAnimation::SetDuration(Duration duration)
{
    dur_ = duration;
}
 
inline void TweenAnimation::SetEaseFunc(const EaseFunc& func)
{
    ease_func_ = func;
}
 
inline Vec2 MoveByAnimation::GetDisplacement() const
{
    return displacement_;
}
 
inline void MoveByAnimation::SetDisplacement(const Vec2& displacement)
{
    displacement_ = displacement;
}
 
inline Point MoveToAnimation::GetDistination() const
{
    return distination_;
}
 
inline void MoveToAnimation::SetDistination(const Point& distination)
{
    distination_ = distination;
}
 
inline Vec2 JumpByAnimation::GetDisplacement() const
{
    return displacement_;
}
 
inline float JumpByAnimation::GetJumpHeight() const
{
    return height_;
}
 
inline int JumpByAnimation::GetJumpCount() const
{
    return jump_count_;
}
 
inline void JumpByAnimation::SetDisplacement(const Vec2& displacement)
{
    displacement_ = displacement;
}
 
inline void JumpByAnimation::SetJumpHeight(float height)
{
    height_ = height;
}
 
inline void JumpByAnimation::SetJumpCount(int count)
{
    jump_count_ = count;
}
 
inline Point JumpToAnimation::GetDistination() const
{
    return distination_;
}
 
inline void JumpToAnimation::SetDistination(const Point& distination)
{
    distination_ = distination;
}
 
inline float ScaleByAnimation::GetScaleX() const
{
    return delta_.x;
}
 
inline float ScaleByAnimation::GetScaleY() const
{
    return delta_.y;
}
 
inline void ScaleByAnimation::SetScaleX(float scale_x)
{
    delta_.x = scale_x;
}
 
inline void ScaleByAnimation::SetScaleY(float scale_y)
{
    delta_.y = scale_y;
}
 
inline float ScaleToAnimation::GetTargetScaleX() const
{
    return end_val_.x;
}
 
inline float ScaleToAnimation::GetTargetScaleY() const
{
    return end_val_.y;
}
 
inline void ScaleToAnimation::SetTargetScaleX(float scale_x)
{
    end_val_.x = scale_x;
}
 
inline void ScaleToAnimation::SetTargetScaleY(float scale_y)
{
    end_val_.y = scale_y;
}
 
inline float FadeToAnimation::GetTargetOpacity() const
{
    return end_val_;
}
 
inline void FadeToAnimation::SetTargetOpacity(float opacity)
{
    end_val_ = opacity;
}
 
inline float RotateByAnimation::GetRotation() const
{
    return delta_val_;
}
 
inline void RotateByAnimation::SetRotation(float rotation)
{
    delta_val_ = rotation;
}
 
inline float RotateToAnimation::GetTargetRotation() const
{
    return end_val_;
}
 
inline void RotateToAnimation::SetTargetRotation(float rotation)
{
    end_val_ = rotation;
}
 
}  // namespace kiwano