Screen.h

Go to the documentation of this file.

 
/*
     ██╗  ██╗  █████╗  ████████╗  █████╗  ███╗   ██╗  █████╗ 
     ██║ ██╔╝ ██╔══██╗ ╚══██╔══╝ ██╔══██╗ ████╗  ██║ ██╔══██╗
     █████╔╝  ███████║    ██║    ███████║ ██╔██╗ ██║ ███████║
     ██╔═██╗  ██╔══██║    ██║    ██╔══██║ ██║╚██╗██║ ██╔══██║
     ██║  ██╗ ██║  ██║    ██║    ██║  ██║ ██║ ╚████║ ██║  ██║
     ╚═╝  ╚═╝ ╚═╝  ╚═╝/\  ╚═╝    ╚═╝  ╚═╝ ╚═╝  ╚═══╝ ╚═╝  ╚═╝
   /vvvvvvvvvvvvvvvvvvv \=========================================,
   `^^^^^^^^^^^^^^^^^^^ /---------------------------------------"
        Katana Engine \/ © 2012 - Shuriken Studios LLC
                http://www.shurikenstudios.com
*/
 
#pragma once
 
namespace KatanaEngine
{
    class ScreenManager;
    class Screen;
 
    typedef void(*OnExit)(Screen *pScreen);
 
    typedef void(*OnRemove)(Screen *pScreen);
 
    class Screen
    {
        friend class ScreenManager;
 
    public:
 
        Screen();
        virtual ~Screen() { }
 
 
        virtual void LoadContent(ResourceManager& resourceManager) { }
 
        virtual void UnloadContent() { }
 
        virtual void HandleInput(const InputState& input) { }
 
        virtual void Update(const GameTime& gameTime) = 0;
 
        virtual void Draw(SpriteBatch& spriteBatch) = 0;
 
        virtual bool IsExiting() const { return m_isExiting; }
 
        float GetAlpha() const { return m_transitionValue; }
 
        virtual ScreenManager *GetScreenManager() { return m_pScreenManager; }
 
        virtual Game *GetGame() const;
 
        virtual void SetScreenManager(ScreenManager& screenManager);
 
        virtual void Show();
 
        virtual void Exit();
 
        virtual void SetExitCallback(OnExit callback) { m_onExit = callback; }
 
        virtual void SetRemoveCallback(OnRemove callback) { m_onRemove = callback; }
 
        virtual double GetTransitionOutTime() const { return m_transitionOutTime; }
 
 
    protected:
 
        enum class ScreenTransition
        {
            None,   
            In,     
            Out     
        };
 
        virtual bool ShouldHandleInputBelow() { return false; }
 
        virtual bool ShouldUpdateBelow() { return false; }
 
        virtual bool ShouldDrawBelow() { return false; }
 
        virtual void SetTransitionInTime(double seconds) { m_transitionInTime = seconds; }
 
        virtual void SetTransitionOutTime(double seconds) { m_transitionOutTime = seconds; }
 
        virtual double GetTransitionInTime() const { return m_transitionInTime; }
 
        virtual ScreenTransition GetTransition() const { return m_transition; }
 
        virtual float GetTransitionValue() const { return m_transitionValue; }
 
        virtual bool NeedsToBeRemoved() const { return m_needsToBeRemoved; }
 
        virtual void UseRenderTarget();
 
        virtual RenderTarget *GetRenderTarget() const { return m_pRenderTarget; }
 
        virtual Color GetRenderTargetColor() const { return Color::White * GetAlpha(); }
 
 
    private:
 
        void *m_onExit;
        void *m_onRemove;
 
        bool m_isExiting = false;
 
        bool m_needsToBeRemoved;
 
        double m_transitionInTime = 0;
        double m_transitionOutTime = 0;
 
        ScreenTransition m_transition = ScreenTransition::None;
 
        float m_transitionValue = 0;
        double m_transitionTime = 0;
 
        ScreenManager *m_pScreenManager = nullptr;
 
        RenderTarget *m_pRenderTarget = nullptr;
 
        void TransitionIn();
        void TransitionOut();
 
        void UpdateTransition(const GameTime& gameTime);
    };
}