Animation.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdexcept>
#include <iostream>
 
#include "Event.h"
#include "Containers/Collection.h"
 
namespace Gorgon { 
    namespace Animation {
 
        class Base;
        class ControllerBase;
        
        class Governor {
            friend class ControllerBase;
        public:
            
            virtual ~Governor();
            
            virtual void Activate() {
                active = this;
            }
            
            virtual void Animate() const;
            
            static Governor &Default() {
                static Governor def;
                
                return def;
            }
            
            static Governor &Active() {
                if(active)
                    return *active;
                else
                    return Default();
            }
            
        private:
            static Governor *active;
            Containers::Collection<ControllerBase> controllers;
        };
 
        class ControllerBase {
        public:
            ControllerBase();
 
            explicit ControllerBase(Governor &governor);
 
            virtual ~ControllerBase();
 
            virtual void Progress(unsigned timepassed)  = 0;
 
            virtual void Add(Base &animation);
 
            virtual void Remove(Base &animation);
 
            virtual void Delete(Base &animation);
 
            virtual unsigned GetProgress() const        = 0;
 
            virtual bool IsControlled() const           = 0;
 
            void AutoDestruct() { collectable=true; }
 
            void Keep() { collectable=false; }
            
            virtual void Reset() = 0;
            
            virtual void SetGovernor(Governor &governor);
 
        protected:
            bool collectable = false;
            
            Governor *governor = nullptr;
 
            Containers::Collection<Base> animations;
        };
 
        class Timer : public ControllerBase {
        public:
 
            virtual ~Timer() { }
 
            virtual void Progress(unsigned timepassed) override final;
 
            virtual void Reset() override { 
                progress=0; 
            }
 
            virtual void SetProgress(unsigned progress) { 
                this->progress=progress; 
            }
 
            virtual unsigned GetProgress() const override final { 
                return progress; 
            }
 
            virtual bool IsControlled() const override final {
                return false;
            }
 
        protected:
            unsigned progress = 0;
        };
 
        class Controller : public ControllerBase {
        public:
 
            Controller(double progress = 0.0);
 
            virtual ~Controller() {}
 
 
            virtual void Progress(unsigned timepassed) override final;
 
            virtual void SetProgress(unsigned progress) { this->progress=progress; }
 
            void SetProgress(double progress) { this->progress=progress; }
 
            virtual void Reset() override;
 
 
            virtual void Play();
 
            virtual void Loop() { Play(); islooping=true; }
 
            virtual void Pause();
 
            virtual void Resume() { ispaused=false; }
 
            virtual void SetSpeed(float speed) { this->speed=speed; }
 
            virtual void Reverse() { speed=-speed; }
 
            virtual void SetLength(unsigned length) { this->length=length; }
 
 
            virtual float GetSpeed() { return speed; }
 
            bool IsPaused() const { return ispaused; }
 
            bool IsFinished() const { return isfinished; }
 
            bool IsPlaying() const { return !ispaused && !isfinished; }
 
            bool IsLooping() const { return (speed>=0 ? islooping : islooping && length!=0); }
 
            virtual bool IsControlled() const override final { return true; }
 
 
            Event<Controller> FinishedEvent;
 
        protected:
            bool ispaused = false;
 
            bool islooping = false;
 
            float speed = 1.0f;
 
            bool isfinished = false;
 
            double progress = 0.0;
 
            unsigned length=0;
        };
 
        class Provider {
        public:
            using AnimationType = Base;
            
            
            virtual ~Provider() { }
            
            virtual Provider &MoveOutProvider() = 0;
        
            virtual Base &CreateAnimation(ControllerBase &timer) const = 0;
 
            virtual Base &CreateAnimation(bool create=true) const = 0;
        };
 
        class Base {
            friend class ControllerBase;
        public:
            explicit Base(ControllerBase &controller) {
                SetController(controller);
            }
 
            Base(const Base &base) {
                if(base.HasController())
                    SetController(base.GetController());
            }
 
            explicit Base(bool create=false) {
                if(create) {
                    auto timer = new Timer;
                    timer->AutoDestruct();
                    SetController(*timer);
                }
            }
 
            virtual void SetController(ControllerBase &controller) {
                if(&controller==this->controller) return;
                if(this->controller) {
                    this->controller->Remove(*this);
                }
                this->controller=&controller;
                controller.Add(*this);
            }
 
            virtual bool HasController() const { return controller!=nullptr; }
 
            virtual ControllerBase &GetController() const {
#ifndef NDEBUG
                if(!controller) {
                    throw std::runtime_error("Animation does not have a controller");
                }
#endif
                return *controller;
            }
            
            virtual void RemoveController() {
                if(controller) {
                    controller->Remove(*this);
                }
                controller=nullptr;
            }
 
            virtual bool Progress(unsigned &leftover) = 0;
            
            virtual int GetDuration() const = 0;
 
            virtual void DeleteAnimation() const { 
                delete this; 
            }
 
        protected:
            virtual ~Base();
            
            ControllerBase *controller = nullptr;
        };
    }
}