tb_game_scene.hpp

 
#ifndef TurtleBrains_GameSceneInterface_hpp
#define TurtleBrains_GameSceneInterface_hpp
 
#include <turtle_brains/game/tb_entity_manager.hpp>
#include <turtle_brains/graphics/tb_graphic_list.hpp>
#include <turtle_brains/graphics/tb_camera.hpp>
#include <turtle_brains/graphics/tb_render_target.hpp>
#include <turtle_brains/graphics/tb_sprite.hpp>
 
#include <list>
 
namespace TurtleBrains::Game
{
    class TransitionScene;
 
    class GameScene : public EntityManager
    {
    public:
 
        GameScene(void);
 
        virtual ~GameScene(void) = 0;
 
        static bool IsTransitionPlaying(void);
 
        static void ChangeToScene(GameScene& gameScene);
 
        static void ChangeToScene(GameScene& gameScene, std::unique_ptr<TransitionScene>&& transitionScene);
 
        static void PerformFrame(const float deltaTime);
 
        static void PerformFrame(GameScene& gameScene, const float deltaTime);
 
    protected:
        virtual void OnSimulate(void);
 
        virtual void OnUpdate(const float deltaTime);
 
        virtual void OnRender(void) const;
 
        virtual void OnOpen(void);
 
        virtual void OnClose(void);
 
        virtual void OnRuntimeReload(void);
 
    private:
        tbGraphics::Camera mCamera;
        float mAccumulatedSimulationTime;
    };
 
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
//--------------------------------------------------------------------------------------------------------------------//
 
    class TransitionScene : public GameScene
    {
    public:
        TransitionScene(void);
        virtual ~TransitionScene(void) = 0;
 
        inline bool IsTransitionStarted(void) const { return mIsStarted; }
 
        virtual bool IsTransitionFinished(void) const = 0;
 
    protected:
 
        virtual void OnSimulate(void) override;
        virtual void OnUpdate(const float deltaTime) override;
 
        virtual void OnRender(void) const override;
        virtual void OnOpen(void) override;
        virtual void OnClose(void) override;
 
        tbGraphics::Sprite RenderBeforeScene(void) const;
        tbGraphics::Sprite RenderAfterScene(void) const;
 
    private:
        friend class GameScene;
 
        // This is actually an implementation detail... we may want to make it private and add a friend to preotect
        //   the developer from calling it unexpectedly...
        void SetBeforeAndAfterScenes(GameScene* before, GameScene* after);
 
        std::unique_ptr<tbGraphics::RenderTarget> mBeforeSceneTarget;
        std::unique_ptr<tbGraphics::RenderTarget> mAfterSceneTarget;
 
        GameScene* mBeforeScene;
        GameScene* mAfterScene;
        bool mIsStarted;
    };
 
}; /* namespace TurtleBrains::Game */
 
namespace tbGame = TurtleBrains::Game;
 
#endif /* TurtleBrains_GameSceneInterface_hpp */