Animations.h

Go to the documentation of this file.

#pragma once
 
#pragma warning(disable:4250)
 
#include "Drawables.h"
#include "../Animation.h"
#include "../Animation/Discrete.h"
#include "../Animation/Instance.h"
#include "../Animation/Storage.h"
 
namespace Gorgon { namespace Graphics { 
 
    class Animation : public virtual Drawable, public virtual Gorgon::Animation::Base {
 
    };
    
    class RectangularAnimation : public virtual RectangularDrawable, public virtual Animation {
 
    };
 
    class DiscreteAnimation: public virtual Graphics::RectangularAnimation, public virtual Gorgon::Animation::DiscreteAnimation {
    };
 
    class AnimationProvider : public virtual Gorgon::Animation::Provider {
    public:
        virtual ~AnimationProvider() { }
        
        using AnimationType = Animation;
        
        virtual AnimationProvider &MoveOutProvider() override = 0;
 
        virtual Animation &CreateAnimation(Gorgon::Animation::ControllerBase &timer) const override = 0;
 
        virtual Animation &CreateAnimation(bool create=true) const override = 0;
    };
 
    class RectangularAnimationProvider : public AnimationProvider {
    public:
        using AnimationType = RectangularAnimation;
        
        virtual RectangularAnimationProvider &MoveOutProvider() override = 0;
 
        virtual RectangularAnimation &CreateAnimation(Gorgon::Animation::ControllerBase &timer) const override = 0;
 
        virtual RectangularAnimation &CreateAnimation(bool create=true) const override = 0;
 
        virtual Geometry::Size GetSize() const = 0;
 
        int GetWidth() const { return GetSize().Width; }
        int GetHeight() const { return GetSize().Height; }
    };
 
    class DiscreteAnimationProvider : public virtual Graphics::RectangularAnimationProvider, public virtual Gorgon::Animation::DiscreteProvider {
    public:
        using AnimationType = DiscreteAnimation;
 
        virtual DiscreteAnimation &CreateAnimation(Gorgon::Animation::ControllerBase &timer) const override = 0;
 
        virtual DiscreteAnimation &CreateAnimation(bool create=true) const override = 0;
 
    };
    
    class ImageProvider : public virtual Image, public virtual RectangularAnimation, public virtual RectangularAnimationProvider {
    public:
        
        ImageProvider &CreateAnimation(Gorgon::Animation::ControllerBase &) const override { return const_cast<ImageProvider &>(*this); }
        
        ImageProvider &CreateAnimation(bool =false) const override { return const_cast<ImageProvider &>(*this); }
        
        virtual void DeleteAnimation() const override { }
        
        using Image::GetSize;
        using Image::GetWidth;
        using Image::GetHeight;
        
    protected:
        bool Progress(unsigned &) override { return true; }
        
        int GetDuration() const override { return 0; }
        
    };
    
} 
 
namespace Animation { 
    
    template<>
    class basic_StorageInjection<Graphics::AnimationProvider> {
        //nothing for now
    };
    
    template<>
    class basic_StorageInjection<Graphics::RectangularAnimationProvider> : public Graphics::RectangularAnimationProvider {
        
        //types are derived not to type the same code for every class
        virtual auto MoveOutProvider() -> decltype(*this) override {
            auto ret = new typename std::remove_reference<decltype(*this)>::type(std::move(*this));
            
            return *ret;
        }
 
        virtual Graphics::RectangularAnimation &CreateAnimation(Gorgon::Animation::ControllerBase &timer) const override {
            auto &me = dynamic_cast<const basic_Storage<Graphics::RectangularAnimationProvider>&>(*this);
            return me.CreateAnimation(timer);
        }
 
        virtual Graphics::RectangularAnimation &CreateAnimation(bool create=true) const override {
            auto &me = dynamic_cast<const basic_Storage<Graphics::RectangularAnimationProvider>&>(*this);
            return me.CreateAnimation(create);
        }
 
        virtual Geometry::Size GetSize() const override {
            auto &me = dynamic_cast<const basic_Storage<Graphics::RectangularAnimationProvider>&>(*this);
            if(me.HasAnimation())
                return me->GetSize();
            else
                return {0, 0};
        }
        
        int GetWidth() const { return GetSize().Width; }
        int GetHeight() const { return GetSize().Height; }
    };
    
    template<>
    class basic_StorageInjection<Graphics::DiscreteAnimationProvider> : public Graphics::DiscreteAnimationProvider {
    public:
        //types are derived not to type the same code for every class
        virtual auto MoveOutProvider() -> decltype(*this) override {
            auto ret = new typename std::remove_reference<decltype(*this)>::type(std::move(*this));
            
            return *ret;
        }
 
        virtual Graphics::DiscreteAnimation &CreateAnimation(Gorgon::Animation::ControllerBase &timer) const override {
            auto &me = dynamic_cast<const basic_Storage<Graphics::DiscreteAnimationProvider>&>(*this);
            return me.CreateAnimation(timer);
        }
 
        virtual Graphics::DiscreteAnimation &CreateAnimation(bool create=true) const override {
            auto &me = dynamic_cast<const basic_Storage<Graphics::DiscreteAnimationProvider>&>(*this);
            return me.CreateAnimation(create);
        }
        
        virtual Geometry::Size GetSize() const override {
            auto &me = dynamic_cast<const basic_Storage<Graphics::DiscreteAnimationProvider>&>(*this);
            if(me.HasAnimation())
                return me->GetSize();
            else
                return {0, 0};
        }
        
        
        virtual void Add(const Frame &frame) override {
            auto &me = dynamic_cast<basic_Storage<Graphics::DiscreteAnimationProvider>&>(*this);
            if(me.HasAnimation())
                me->Add(frame);
        }
 
        virtual void Insert(const Frame &frame, int before) override {
            auto &me = dynamic_cast<basic_Storage<Graphics::DiscreteAnimationProvider>&>(*this);
            if(me.HasAnimation())
                me->Insert(frame, before);
        }
 
        virtual void MoveBefore(unsigned index, int before) override {
            auto &me = dynamic_cast<basic_Storage<Graphics::DiscreteAnimationProvider>&>(*this);
            if(me.HasAnimation())
                me->MoveBefore(index, before);
        }
 
        virtual void Remove(unsigned index) override {
            auto &me = dynamic_cast<basic_Storage<Graphics::DiscreteAnimationProvider>&>(*this);
            if(me.HasAnimation())
                me->Remove(index);
        }
 
        virtual const Frame &FrameAt(int index) const override {
            auto &me = dynamic_cast<const basic_Storage<Graphics::DiscreteAnimationProvider>&>(*this);
            if(me.HasAnimation())
                return me->FrameAt(index);
            else
                throw std::runtime_error("Animation storage is empty");
        }
 
        virtual unsigned StartOf(unsigned frame) const override {
            auto &me = dynamic_cast<const basic_Storage<Graphics::DiscreteAnimationProvider>&>(*this);
            if(me.HasAnimation())
                return me->StartOf(frame);
            else
                return -1;
        }
 
        virtual unsigned GetDuration() const override {
            auto &me = dynamic_cast<const basic_Storage<Graphics::DiscreteAnimationProvider>&>(*this);
            if(me.HasAnimation())
                return me->GetDuration();
            else
                return 0;
        }
 
        virtual unsigned GetDuration(unsigned frame) const override {
            auto &me = dynamic_cast<const basic_Storage<Graphics::DiscreteAnimationProvider>&>(*this);
            if(me.HasAnimation())
                return me->GetDuration(frame);
            else
                return 0;
        }
 
        virtual void Clear() override {
            auto &me = dynamic_cast<basic_Storage<Graphics::DiscreteAnimationProvider>&>(*this);
            if(me.HasAnimation())
                me->Clear();
        }
 
        virtual int GetCount() const override {
            auto &me = dynamic_cast<const basic_Storage<Graphics::DiscreteAnimationProvider>&>(*this);
            if(me.HasAnimation())
                return me->GetCount();
            else
                return 0;
        }
    };
    
    template<>
    class basic_InstanceInjection<Graphics::RectangularAnimation> : public Graphics::RectangularAnimation {
    public:
        virtual bool Progress(unsigned &leftover) override {
           auto &me = dynamic_cast<const basic_Instance<Graphics::RectangularAnimation>&>(*this);
            if(me.HasAnimation())
                return me->Progress(leftover);
            else
                return true;
        }
        
        int GetDuration() const override {
            auto &me = dynamic_cast<const basic_Instance<Graphics::RectangularAnimation>&>(*this);
            if(me.HasAnimation())
                return me.GetDuration();
            else
                return 0;
        }
    
        virtual void SetController(ControllerBase &controller) override {
            auto &me = dynamic_cast<const basic_Instance<Graphics::RectangularAnimation>&>(*this);
            if(me.HasAnimation())
                return me->SetController(controller);
        }
 
        virtual bool HasController() const override { 
            auto &me = dynamic_cast<const basic_Instance<Graphics::RectangularAnimation>&>(*this);
            if(me.HasAnimation())
                return me->HasController();
            else
                return false;
        }
 
        virtual ControllerBase &GetController() const override {
#ifndef NDEBUG
            if(!HasController()) {
                throw std::runtime_error("Animation does not have a controller");
            }
#endif
            auto &me = dynamic_cast<const basic_Instance<Graphics::RectangularAnimation>&>(*this);
            return me->GetController();
        }
        
        virtual void RemoveController() override {
            auto &me = dynamic_cast<const basic_Instance<Graphics::RectangularAnimation>&>(*this);
            if(me.HasAnimation())
                return me->RemoveController();
        }
 
        
    protected:
        virtual void draw(Graphics::TextureTarget &target, const Geometry::Pointf &p, Graphics::RGBAf color) const override {
           auto &me = dynamic_cast<const basic_Instance<Graphics::RectangularAnimation>&>(*this);
            if(me.HasAnimation())
                me->Draw(target, p, color);
        }
 
        virtual void draw(Graphics::TextureTarget &target, const Geometry::Pointf &p1, const Geometry::Pointf &p2,
            const Geometry::Pointf &p3, const Geometry::Pointf &p4,
            const Geometry::Pointf &tex1, const Geometry::Pointf &tex2,
            const Geometry::Pointf &tex3, const Geometry::Pointf &tex4, Graphics::RGBAf color) const override 
        {
            auto &me = dynamic_cast<const basic_Instance<Graphics::RectangularAnimation>&>(*this);
            if(me.HasAnimation())
                me->Draw(target, p1, p2, p3, p4, tex1, tex2, tex3, tex4, color);
        }
 
        virtual void draw(Graphics::TextureTarget &target, const Geometry::Pointf &p1, const Geometry::Pointf &p2,
            const Geometry::Pointf &p3, const Geometry::Pointf &p4, Graphics::RGBAf color) const override
        {
            auto &me = dynamic_cast<const basic_Instance<Graphics::RectangularAnimation>&>(*this);
            if(me.HasAnimation())
                me->Draw(target, p1, p2, p3, p4);
        }
 
        virtual void drawstretched(Graphics::TextureTarget &target, const Geometry::Rectanglef &r, Graphics::RGBAf color) const override {
            auto &me = dynamic_cast<const basic_Instance<Graphics::RectangularAnimation>&>(*this);
            if(me.HasAnimation())
                me->DrawStretched(target, r, color);
        }
 
        virtual void drawin(Graphics::TextureTarget &target, const Geometry::Rectanglef &r, Graphics::RGBAf color) const override { 
            auto &me = dynamic_cast<const basic_Instance<Graphics::RectangularAnimation>&>(*this);
            if(me.HasAnimation())
                me->DrawIn(target, r, color);
        }
 
        virtual void drawin(Graphics::TextureTarget &target, const Graphics::SizeController &controller, const Geometry::Rectanglef &r, Graphics::RGBAf color) const override {
            auto &me = dynamic_cast<const basic_Instance<Graphics::RectangularAnimation>&>(*this);
            if(me.HasAnimation())
                me->DrawIn(target, controller, r, color);
        }
 
        virtual Geometry::Size calculatesize(const Geometry::Size &area) const override {
            auto &me = dynamic_cast<const basic_Instance<Graphics::RectangularAnimation>&>(*this);
            if(me.HasAnimation())
                return me->CalculateSize(area);
            else
                return {0, 0};
        }
 
        virtual Geometry::Size calculatesize(const Graphics::SizeController &controller, const Geometry::Size &s) const override {
            auto &me = dynamic_cast<const basic_Instance<Graphics::RectangularAnimation>&>(*this);
            if(me.HasAnimation())
                return me->CalculateSize(controller, s);
            else
                return {0, 0};
        }
 
        virtual Geometry::Size getsize() const override {
            auto &me = dynamic_cast<const basic_Instance<Graphics::RectangularAnimation>&>(*this);
            if(me.HasAnimation())
                return me->GetSize();
            else
                return {0, 0};
        }
    };
    
} 
 
namespace Graphics { 
 
    using AnimationStorage = Gorgon::Animation::basic_Storage<AnimationProvider>;
    using RectangularAnimationStorage = Gorgon::Animation::basic_Storage<RectangularAnimationProvider>;
    using DiscreteAnimationStorage = Gorgon::Animation::basic_Storage<DiscreteAnimationProvider>;
    using Instance = Gorgon::Animation::basic_Instance<RectangularAnimation>;
 
} }