animation.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2023  Christopher J. Howard
 *
 * This file is part of Antkeeper source code.
 *
 * Antkeeper source code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Antkeeper source code is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Antkeeper source code.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef ANTKEEPER_ANIMATION_HPP
#define ANTKEEPER_ANIMATION_HPP
 
#include <engine/animation/animation-channel.hpp>
#include <algorithm>
#include <functional>
#include <type_traits>
#include <unordered_map>
 
class animation_base
{
public:
    animation_base();
    
    virtual void advance(float dt) = 0;
    
    void seek(float t);
    
    void rewind();
    
    void loop(bool enabled);
    
    void pause();
    
    void play();
    
    void stop();
    
    void set_speed(float speed);
    
    bool is_looped() const;
    
    bool is_paused() const;
    
    bool is_stopped() const;
    
    float get_position() const;
    
    int get_loop_count() const;
    
    virtual float get_duration() const = 0;
    
    void set_start_callback(std::function<void()> callback);
    
    void set_end_callback(std::function<void()> callback);
    
    void set_loop_callback(std::function<void(int)> callback);
    
protected:
    bool looped;
    int loop_count;
    bool paused;
    bool stopped;
    float position;
    float speed;
 
    std::function<void()> start_callback;
    std::function<void()> end_callback;
    std::function<void(int)> loop_callback;
};
 
inline bool animation_base::is_looped() const
{
    return looped;
}
 
inline bool animation_base::is_paused() const
{
    return paused;
}
 
inline bool animation_base::is_stopped() const
{
    return stopped;
}
 
inline float animation_base::get_position() const
{
    return position;
}
    
inline int animation_base::get_loop_count() const
{
    return loop_count;
}
 
template <typename T>
class animation: public animation_base
{
public:
    typedef animation_channel<T> channel;
    
    // Keyframe type for this animation.
    typedef typename channel::keyframe keyframe;
    
    typedef typename std::decay<std::function<T(const T&, const T&, float)>>::type interpolator_type;
    
    animation();
    
    virtual void advance(float dt);
    
    channel* add_channel(int id);
    
    void remove_channel(int id);
    
    void remove_channels();
    
    void set_interpolator(interpolator_type interpolator);
    
    void set_frame_callback(std::function<void(int, const T&)> callback);
    
    const channel* get_channel(int id) const;
    
    channel* get_channel(int id);
    
    virtual float get_duration() const;
 
private:
    std::unordered_map<int, channel> channels;
    interpolator_type interpolator;
    std::function<void(int, const T&)> frame_callback;
};
 
template <typename T>
animation<T>::animation():
    interpolator(nullptr),
    frame_callback(nullptr)
{}
 
template <typename T>
void animation<T>::advance(float dt)
{
    if (paused || stopped)
    {
        return;
    }
    
    // Advance position by dt
    position += dt * speed;
    
    // Determine duration of the animation
    float duration = get_duration();
    
    if (position < duration)
    {
        if (frame_callback != nullptr && interpolator != nullptr)
        {
            for (const auto& channel: channels)
            {
                auto frames = channel.second.find_keyframes(position);
                
                if (frames[0] != nullptr && frames[1] != nullptr)
                {
                    // Calculate interpolated frame
                    float t0 = std::get<0>(*frames[0]);
                    float t1 = std::get<0>(*frames[1]);
                    float alpha = (position - t0) / (t1 - t0);
                    T frame = interpolator(std::get<1>(*frames[0]), std::get<1>(*frames[1]), alpha);
                    
                    // Pass frame to frame callback
                    frame_callback(channel.first, frame);
                }
                else if (frames[0] != nullptr)
                {
                    // Pass frame to frame callback
                    frame_callback(channel.first, std::get<1>(*frames[0]));
                }
                else if (frames[1] != nullptr)
                {
                    // Pass frame to frame callback
                    frame_callback(channel.first, std::get<1>(*frames[1]));
                }
            }
        }
    }
    else
    {
        if (looped)
        {
            ++loop_count;
            
            // Subtract duration of animation from position
            position -= duration;
            
            // Execute loop callback
            if (loop_callback)
            {
                loop_callback(loop_count);
            }
            
            // Call frame callback on looped frame
            if (frame_callback)
            {
                advance(0.0);
            }
        }
        else
        {
            // Call frame callback for end frame
            if (frame_callback != nullptr)
            {
                for (auto& channel: channels)
                {
                    auto frames = channel.second.find_keyframes(channel.second.get_duration());
                    if (frames[0] != nullptr)
                    {
                        frame_callback(channel.first, std::get<1>(*frames[0]));
                    }
                }
            }
            
            stopped = true;
            
            // Call end callback
            if (end_callback)
            {
                end_callback();
            }
        }
    }
}
 
template <typename T>
typename animation<T>::channel* animation<T>::add_channel(int id)
{
    return &(*channels.emplace(id, id).first).second;
}
 
template <typename T>
void animation<T>::remove_channel(int id)
{
    auto it = channels.find(id);
    if (it != channels.end())
    {
        channels.erase(it);
    }
}
 
template <typename T>
void animation<T>::remove_channels()
{
    channels.clear();
}
 
template <typename T>
void animation<T>::set_interpolator(interpolator_type interpolator)
{
    this->interpolator = interpolator;
}
 
template <typename T>
void animation<T>::set_frame_callback(std::function<void(int, const T&)> callback)
{
    this->frame_callback = callback;
}
 
template <typename T>
const typename animation<T>::channel* animation<T>::get_channel(int id) const
{
    auto it = channels.find(id);
    if (it != channels.end())
    {
        return &it->second;
    }
    
    return nullptr;
}
 
template <typename T>
typename animation<T>::channel* animation<T>::get_channel(int id)
{
    auto it = channels.find(id);
    if (it != channels.end())
    {
        return &it->second;
    }
    
    return nullptr;
}
 
template <typename T>
float animation<T>::get_duration() const
{
    float duration = 0.0;
    
    for (auto it = channels.begin(); it != channels.end(); ++it)
    {
        duration = std::max<float>(duration, it->second.get_duration());
    }
    
    return duration;
}
 
#endif // ANTKEEPER_ANIMATION_HPP