StateAnimatable.hpp

Go to the documentation of this file.

/*
   Copyright 2022 Rishi Challa
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
       http://www.apache.org/licenses/LICENSE-2.0
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
*/
 
#pragma once
 
#include <Kale/Core/Logger/Logger.hpp>
#include <Kale/Engine/Node/Node.hpp>
 
#include <unordered_map>
#include <vector>
#include <utility>
#include <mutex>
#include <memory>
 
#include <nlohmann/json.hpp>
 
namespace Kale {
 
    using JSON = nlohmann::json;
 
    template <typename S> class StateAnimatable {
    protected:
 
        int state;
 
        int transitionState;
 
        bool transitioning;
 
        float transitionTime;
 
        float transitionDuration;
 
        std::unordered_map<int, S> structures;
 
        std::vector<std::pair<int, float>> animationInfo;
 
        size_t animationIndex;
 
        bool animationLoop;
        
    public:
 
        StateAnimatable() {}
 
        StateAnimatable(JSON json) {
            // Loop through the structures & set them
            for (const std::pair<std::string, S>& pair : json["structures"].get<std::unordered_map<std::string, S>>())
                structures[std::stoi(pair.first)] = pair.second;
            
            // Set the first state if applicable
            if (json.contains("state")) setState<int>(json["state"].get<int>());
 
            // Start animating if applicable
            if (json.contains("animation")) {
                // Get the animation subset of the json
                JSON animationInfo = json["animation"];
 
                // Get the type of animation and convert it to lowercase (loop or once)
                std::string type = animationInfo["type"].get<std::string>();
                std::transform(type.begin(), type.end(), type.begin(), [](char c) -> char { return std::tolower(c); });
                
                // Get the stages data
                std::vector<std::pair<int, float>> stages;
                std::vector<JSON> stagesJson = animationInfo["stages"].get<std::vector<JSON>>();
                for (const JSON& json : stagesJson) stages.push_back(std::make_pair(json["state"].get<int>(), json["duration"].get<float>()));
 
                // Animate based on the type
                if (type == "loop") animateLoop(stages);
                if (type == "once") animateOnce(stages);
            }
        }
 
        void updateState(float deltaTime) {
            if (!transitioning) return;
            transitionTime += deltaTime / (1000000.0f * transitionDuration);
 
            // Animation complete
            if (transitionTime >= 1.0f) {
                state = transitionState;
 
                // There is no further animation required
                if (animationInfo.empty()) {
                    transitioning = false;
                    return;
                }
 
                // We need to move to the next animation stage
                if (++animationIndex >= animationInfo.size()) {
                    // We don't need to loop, we've finished.
                    if (!animationLoop) {
                        animationInfo.clear();
                        transitioning = false;
                        return;
                    }
 
                    // We finished going through the animation info, check if we need to repeat
                    animationIndex = 0;
                }
 
                // Prepare the next animation
                transitionTime = 0.0f;
                transitionDuration = animationInfo[animationIndex].second;
                transitionState = animationInfo[animationIndex].first;
            }
        }
 
        template <typename T> void addStructure(T state, const S& structure) {
            structures[static_cast<int>(state)] = structure;
        }
 
        template <typename T> void removeStructure(T state) {
            structures.erase(static_cast<int>(state));
        }
 
        template <typename T> S getStructure(T state) const {
            return structures.at(static_cast<int>(state));
        }
        
        template <typename T> void animateTo(T state, float duration) {
            animationInfo.clear();
            transitioning = true;
            transitionTime = 0.0f;
            transitionDuration = duration;
            transitionState = static_cast<int>(state);
        }
 
        template <typename T> void animateOnce(std::vector<std::pair<T, float>> stages) {
            animationInfo.clear();
            for (const std::pair<T, float> stage : stages)
                animationInfo.push_back(std::make_pair(static_cast<int>(stage.first), stage.second));
            animationIndex = 0;
            animationLoop = false;
 
            transitioning = true;
            transitionTime = 0.0f;
            transitionDuration = stages[0].second;
            transitionState = static_cast<int>(stages[0].first);
        }
 
        template <typename T> void animateLoop(std::vector<std::pair<T, float>> stages) {
            animationInfo.clear();
            for (const std::pair<T, float> stage : stages)
                animationInfo.push_back(std::make_pair(static_cast<int>(stage.first), stage.second));
            animationIndex = 0;
            animationLoop = true;
 
            transitioning = true;
            transitionTime = 0.0f;
            transitionDuration = stages[0].second;
            transitionState = static_cast<int>(stages[0].first);
        }
 
        template <typename T> void setState(T state) {
            animationInfo.clear();
            transitioning = false;
            this->state = static_cast<int>(state);
        }
 
        template <typename T> T getCurrentState() const {
            if (!transitioning) return static_cast<T>(state);
            return transitionTime > 0.5f ? static_cast<T>(transitionState) : static_cast<T>(state);
        }
 
        template <typename T> std::vector<std::pair<T, float>> getStateComposition() const {
            std::vector<std::pair<T, float>> composition;
            if (!transitioning) {
                composition.push_back(std::make_pair(static_cast<T>(state), 1.0f));
                return composition;
            }
 
            composition.push_back(std::make_pair(static_cast<T>(state), 1.0f - transitionTime));
            composition.push_back(std::make_pair(static_cast<T>(transitionState), transitionTime));
            return composition;
        }
 
        bool isTransitioning() const {
            return transitioning;
        }
    };
}