Screen.h

/* ---------------------------------------------------------------  /

     ██╗  ██╗  █████╗  ████████╗  █████╗  ███╗   ██╗  █████╗
     ██║ ██╔╝ ██╔══██╗ ╚══██╔══╝ ██╔══██╗ ████╗  ██║ ██╔══██╗
     █████╔╝  ███████║    ██║    ███████║ ██╔██╗ ██║ ███████║
     ██╔═██╗  ██╔══██║    ██║    ██╔══██║ ██║╚██╗██║ ██╔══██║
     ██║  ██╗ ██║  ██║    ██║    ██║  ██║ ██║ ╚████║ ██║  ██║
     ╚═╝  ╚═╝ ╚═╝  ╚═╝/\  ╚═╝    ╚═╝  ╚═╝ ╚═╝  ╚═══╝ ╚═╝  ╚═╝
   /vvvvvvvvvvvvvvvvvvv \=========================================,
   `^^^^^^^^^^^^^^^^^^^ /---------------------------------------"
        Katana Engine \/ © 2012 - Shuriken Studios LLC

/  --------------------------------------------------------------- */

#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 *pResourceManager) { }

        virtual void UnloadContent() { }

        virtual void HandleInput(const InputState *pInput) { }

        virtual void Update(const GameTime *pGameTime) = 0;

        virtual void Draw(SpriteBatch *pSpriteBatch) = 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 ParticleManager *GetParticleManager() const;

        virtual void SetScreenManager(ScreenManager *pScreenManager);

        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 void SetPassthroughFlags(const bool draw = false, const bool update = false, const bool handleInput = 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_handleInputBelow;
        bool m_updateBelow;
        bool m_drawBelow;
        bool m_isExiting;

        bool m_needsToBeRemoved;

        double m_transitionInTime;
        double m_transitionOutTime;

        ScreenTransition m_transition;

        float m_transitionValue;
        double m_transitionTime;

        ScreenManager *m_pScreenManager;

        RenderTarget *m_pRenderTarget;

        void TransitionIn();
        void TransitionOut();

        void UpdateTransition(const GameTime *pGameTime);

        bool UpdateBelow() const { return m_updateBelow; }
        bool DrawBelow() const { return m_drawBelow; }
        bool HandleInputBelow() const { return m_handleInputBelow; }

    };
}