animation.h

#ifndef ANIMATION_H
#define ANIMATION_H
 
#include <vector>
#include <map>
#include "../chrono/chrono.h"
#include "../signal/signal.h"
#include "../geometry/geometry.h"
#include "../signal/signal.h"
#include "../arithmetic/arithmetic.h"
 
namespace pixled { namespace animation {
 
    template<typename R>
        class Wave : public Function<Wave<R>, R, time, R, R> {
            public:
                using Function<Wave<R>, R, time, R, R>::Function;
 
                R operator()(led l, time t) const override {
                    return this->template call<1>(l, t)
                        + this->template call<2>(l, t) * std::sin(
                                2*PI * t / this->template call<0>(l, t)
                                );
                }
        };
 
    class LinearUnitWave : public Function<LinearUnitWave, float, coordinate, time, line> {
        public:
            using Function<LinearUnitWave, float, coordinate, time, line>::Function;
 
            /*
             * f1 : lambda
             * f2 : origin line
             * f3 : time period
             */
            float operator()(led l, time t) const override;
    };
 
    class RadialUnitWave : public Function<RadialUnitWave, float, coordinate, time, point> {
        public:
            using Function<RadialUnitWave, float, coordinate, time, point>::Function;
 
            /*
             * f1 : lambda
             * f2 : origin line
             * f3 : time period
             */
            float operator()(led l, time t) const override;
    };
 
    class Rainbow : public Function<Rainbow, float, time> {
        private:
            signal::Sine sin {
                Cast<float>(chrono::T()) / Cast<float>(this->arg<0>())
            };
 
        public:
            using Function<Rainbow, float, time>::Function;
 
            float operator()(led l, time t) const override;
    };
 
    class RainbowWave : public Function<RainbowWave, float, float, time, line> {
        public:
            using Function<RainbowWave, float, float, time, line>::Function;
 
            float operator()(led l, time t) const override;
    };
 
    class RadialRainbowWave : public Function<RadialRainbowWave, float, coordinate, time, point> {
        public:
            using Function<RadialRainbowWave, float, coordinate, time, point>::Function;
 
            float operator()(led l, time t) const override;
    };
 
    class Blooming : public Function<Blooming, color, color, point, coordinate> {
        public:
            using Function<Blooming, color, color, point, coordinate>::Function;
 
            color operator()(led l, time t) const override;
    };
 
 
    class Blink : public Function<Blink, color, color, time> {
        private:
            signal::Square square {
                Cast<float>(chrono::T()) // parameter
                / Cast<float>(this->arg<1>()) // period
            };
            color black {color::rgb(0, 0, 0)};
 
        public:
            using Function<Blink, color, color, time>::Function;
 
            color operator()(led l, time t) const override;
    };
 
    struct SequenceItem {
        FctWrapper<color> animation;
        time duration;
 
        template<typename Anim>
            SequenceItem(Anim&& animation, time duration)
            : animation(std::forward<Anim>(animation)), duration(duration) {}
    };
 
 
    class Sequence : public base::Function<color> {
        private:
            std::map<time, FctWrapper<color>> animations;
            time duration = 0;
 
            mutable const FctWrapper<color>* cache;
            mutable time cache_time = 0;
            mutable time cache_time_duration = 0;
        public:
            Sequence() {
            }
 
            Sequence(std::vector<SequenceItem> sequence) {
                for(auto item : sequence)
                    this->add(item.animation, item.duration);
            }
 
            template<typename Anim>
                Sequence& add(Anim&& animation, time duration) {
                    animations.insert({this->duration, std::forward<Anim>(animation)});
                    cache_time = this->duration;
                    cache = &animations.at(cache_time);
                    this->duration+=duration;
                    cache_time_duration=duration;
                    return *this;
                }
 
            color operator()(led l, time t) const override;
 
            Sequence* copy() const override;
    };
 
}}
#endif