Scene.h

Go to the documentation of this file.

#pragma once
 
#include "Utils/Assert.h"
#include "Event.h"
#include "ConsumableEvent.h"
#include "Main.h"
 
#include "Layer.h"
#include "Input/Layer.h"
#include "Input/Keyboard.h"
#include "Graphics/Layer.h"
#include "Containers/Hashmap.h"
#include "Window.h"
#include "Time.h"
 
#include <stdexcept>
 
 
namespace Gorgon {
    using SceneID = int;
 
    static constexpr SceneID NoSceneID = -1;
    
    class SceneManager;
    
    class Scene : public Animation::Governor {
        friend class SceneManager;
    public:
 
        explicit Scene(SceneID id = NoSceneID, bool mouseinput = true) : id(id), mouseinput(mouseinput) {
            main.Add(graphics);
            if(mouseinput)
                main.Add(mouse);
        }
 
        explicit Scene(SceneManager &parent, SceneID id = NoSceneID, bool mouseinput = true) : Scene(id, mouseinput) {
            this->parent = &parent;
        }
 
        virtual bool RequiresKeyInput() const = 0;
        
        virtual void Activate() override;
 
        SceneID GetID() const {
            return id;
        }
 
        virtual void KeyEvent(Gorgon::Input::Key, float) { }
 
        Gorgon::Event<Scene> ActivatedEvent{*this};
 
        Gorgon::Event<Scene> DeactivatedEvent{*this};
 
    protected:
        virtual void first_activation() { }
        
        virtual void activate() { }
 
        virtual void deactivate() { }
 
        virtual void doframe(unsigned int delta) = 0;
        
        virtual void render() = 0;
        
        void setlayerbounds(const Geometry::Bounds &bounds) {
            main.SetBounds(bounds);
        }
 
 
        SceneID id;
 
        Gorgon::Graphics::Layer graphics;
 
        Gorgon::Input::Layer    mouse;
 
        SceneManager *parent = nullptr;
 
    private:
 
        void activate_scene();
 
        void deactivate_scene();
        
        Gorgon::Layer  main;
        bool mouseinput = false;
        bool isactive = false;
        bool first    = true;
    };
 
    class SceneManager : public Window, public Runner {
    public:
        using Window::Window;
 
        SceneManager() : Window() {
        }
        
        SceneManager(SceneManager &&) = default;
        
        SceneManager &operator =(SceneManager &&) = default;
 
        ~SceneManager() {
            scenes.Destroy();
        }
 
        void SwitchScene(SceneID scene) {
            if(active && active->GetID() == scene)
                return;
 
            Deactivate();
 
            if(scene == NoSceneID) {
                return;
            }
 
            if(!scenes.Exists(scene))
                throw std::runtime_error("Scene does not exist");
 
            active = &scenes[scene];
            active->activate_scene();
            if(active->RequiresKeyInput()) {
                KeyEvent.Enable(inputtoken);
                KeyEvent.MoveToTop(inputtoken);
            }
 
            ActivatedEvent(*active);
        }
 
        void Deactivate() {
            if(active) {
                active->deactivate_scene();
            }
 
            active = nullptr;
 
            KeyEvent.Disable(inputtoken);
        }
 
        
        void ActivateKeyboard() {
            if(active && active->RequiresKeyInput()) {
                KeyEvent.Enable(inputtoken);
                KeyEvent.MoveToTop(inputtoken);
            }
        }
 
        void Run() override {
            while(!quiting) {
                if(active) {
                    active->doframe(Time::DeltaTime());
                    active->render();
                }
 
                Gorgon::NextFrame();
            }
 
            SwitchScene(NoSceneID);
        }
 
        void Step() override {
            if(active) {
                active->doframe(Time::DeltaTime());
                active->render();
            }
 
            Gorgon::NextFrame();
        }
 
        int GetSceneCount() const {
            return scenes.GetCount();
        }
 
        bool SceneExists(SceneID id) const {
            return scenes.Exists(id);
        }
 
        Scene &GetScene(SceneID scene) {
            return scenes[scene];
        }
 
        void DeleteScene(SceneID scene) {
            scenes.Delete(scene);
        }
 
        Scene &Release(SceneID id) {
            auto &scene = scenes[id];
 
            scenes.Remove(id);
            scene.parent = nullptr;
 
            return scene;
        }
 
        void Assume(Scene &scene) {
            scene.parent = this;
            scenes.Add(scene.id, scene);
        }
 
        auto begin() {
            return scenes.begin();
        }
 
        auto begin() const {
            return scenes.begin();
        }
 
        auto end()  {
            return scenes.end();
        }
 
        auto end() const {
            return scenes.end();
        }
 
        void Quit() override {
            quiting = true;
        }
 
        template<class S_, class ... P_>
        S_ &NewScene(SceneID id, P_ && ... params) {
            auto *s = new S_(*this, id, std::forward<P_>(params)...);
 
            scenes.Add(id, s, true);
 
            return *s;
        }
 
        Gorgon::Event<SceneManager, Scene&> ActivatedEvent{*this};
 
    protected:
        decltype(KeyEvent)::Token init() {
            inputtoken = KeyEvent.Register([this](Input::Key key, float amount) {
                if(active && active->RequiresKeyInput())
                    active->KeyEvent(key, amount);
 
                return true;
            });
 
            KeyEvent.Disable(inputtoken);
 
            return inputtoken;
        }
 
        Gorgon::Containers::Hashmap<SceneID, Scene> scenes;
        Scene *active = nullptr;
        decltype(KeyEvent)::Token inputtoken = init(); //to initialize token after window got constructed
        bool quiting = false;
    };
 
 
    inline void Scene::activate_scene() {
        if(isactive) return;
 
        if(!parent)
            throw std::runtime_error("This scene has no parent");
 
        parent->Add(main);
        main.Add(graphics);
        
        Animation::Governor::Activate();
 
        isactive = true;
 
        if(first) {
            first = false;
            first_activation();
        }
        
        activate();
 
        ActivatedEvent();
    }
 
    inline void Scene::deactivate_scene() {
        if(!isactive) return;
 
        deactivate();
 
        if(main.HasParent())
            main.GetParent().Remove(main);
        
        Animation::Governor::Default().Activate();
 
        isactive = false;
 
        DeactivatedEvent();
    }
    
    inline void Scene::Activate() {
        if(parent)
            parent->SwitchScene(id);
    }
 
}