Crafter.Graphics/interfaces/Crafter.Graphics-Animation.cppm

//SPDX-License-Identifier: LGPL-3.0-only
//SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®

export module Crafter.Graphics:Animation;
import std;

namespace Crafter {
    template <typename T>
    constexpr T Lerp(T a, T b, double elapsed) {
        return a + static_cast<T>(elapsed * (b - a));
    }

    // Template specialization for std::string
    template <>
    std::string Lerp<std::string>(std::string a, std::string b, double elapsed) {
        // Clamp elapsed to [0, 1]
        if (elapsed < 0.0) elapsed = 0.0;
        if (elapsed > 1.0) elapsed = 1.0;

        // Number of characters from b to reveal
        std::size_t len = static_cast<std::size_t>(std::floor(b.size() * elapsed));

        return a + b.substr(0, len);
    }

    template <typename Tuple, std::size_t... Is>
    constexpr auto LerpTupleImpl(const Tuple& a, const Tuple& b, double elapsed, std::index_sequence<Is...>) {
        return std::make_tuple(Lerp(std::get<Is>(a), std::get<Is>(b), elapsed)...);
    }

    template <typename Tuple>
    constexpr auto LerpTuple(const Tuple& a, const Tuple& b, double elapsed) {
        return LerpTupleImpl(a, b, elapsed, std::make_index_sequence<std::tuple_size_v<Tuple>>{});
    }

    export template <typename T>
    struct Keyframe{
        std::chrono::duration<double> duration;
        T startValues;
        T endValues;
    };

    export template <typename T>
    struct Animation {
        std::vector<Keyframe<T>> keyframes;
        std::uint_fast32_t currentFrame;
        std::chrono::time_point<std::chrono::high_resolution_clock> startedAt;
        std::chrono::duration<double> accumulated;
        Animation(std::vector<Keyframe<T>>&& keyframes) : keyframes(std::move(keyframes)) {}
        void Start(std::chrono::time_point<std::chrono::high_resolution_clock> time) {
            currentFrame = 0;
            accumulated = std::chrono::duration<double>(0);
            startedAt = time;
        }
        T Play(std::chrono::time_point<std::chrono::high_resolution_clock> time) {
            std::chrono::duration<double> elapsed = time - startedAt;

            for (; currentFrame < keyframes.size(); ++currentFrame) {
                if (elapsed < accumulated + keyframes[currentFrame].duration) {
                    std::chrono::duration<double> frameStartTime = accumulated;
                    auto t = (elapsed - frameStartTime) / keyframes[currentFrame].duration.count();

                    return LerpTuple(
                        keyframes[currentFrame].startValues,
                        keyframes[currentFrame].endValues,
                        t.count()
                    );
                } else {
                    accumulated += keyframes[currentFrame].duration;
                }
            }

            // If we get here, we're past the last keyframe
            currentFrame = keyframes.size();
            return keyframes.back().endValues;
        }
    };
}