blam/html/_graphics_system_8h_source.html

#ifndef _Demo_GraphicsSystem_H_

#define _Demo_GraphicsSystem_H_


#include "BaseSystem.h"

#include "GameEntityManager.h"

#include "System/StaticPluginLoader.h"

#include "OGRE/OgrePrerequisites.h"

#include "OGRE/OgreColourValue.h"

#include "OGRE/Overlay/OgreOverlayPrerequisites.h"


#include "OGRE/Threading/OgreUniformScalableTask.h"

#include "SdlEmulationLayer.h"

#include "OGRE/Overlay/OgreOverlaySystem.h"


#include "components/rendering/ogre/compositor/compositor.h"


#if OGRE_USE_SDL2

    #include <SDL2/SDL.h>

#endif


namespace Demo

{

    class SdlInputHandler;


    class GraphicsSystem : public BaseSystem, public Ogre::UniformScalableTask

    {

    private:

        using BaseSystem::initialize;


    protected:

        BaseSystem          *mLogicSystem;


    #if OGRE_USE_SDL2

        SDL_Window          *mSdlWindow;

    #endif


        Ogre::Root                  *mRoot;

        Ogre::Window                *mRenderWindow;

        Ogre::SceneManager          *mSceneManager;

        Ogre::Camera                *mCamera;

        Ogre::CompositorWorkspace   *mWorkspace;

        Ogre::String                mPluginsFolder;

        Ogre::String                mWriteAccessFolder;

        Ogre::String                mResourcePath;


        Ogre::v1::OverlaySystem     *mOverlaySystem;


        StaticPluginLoader          mStaticPluginLoader;


        float               mAccumTimeSinceLastLogicFrame;

        Ogre::uint32        mCurrentTransformIdx;

        GameEntityVec       mGameEntities[Ogre::NUM_SCENE_MEMORY_MANAGER_TYPES];

        GameEntityVec const *mThreadGameEntityToUpdate;

        float               mThreadWeight;


        bool                mQuit;

        bool                mAlwaysAskForConfig;

        bool                mUseHlmsDiskCache;

        bool                mUseMicrocodeCache;


        Ogre::ColourValue   mBackgroundColour;


        bool isWriteAccessFolder( const Ogre::String &folderPath, const Ogre::String &fileToSave );


        virtual void processIncomingMessage( Mq::MessageId messageId, const void *data );


        static void addResourceLocation( const Ogre::String &archName, const Ogre::String &typeName,

                                         const Ogre::String &secName );

        void loadTextureCache(void);

        void saveTextureCache(void);

        void loadHlmsDiskCache(void);

        void saveHlmsDiskCache(void);

        virtual void setupResources(void);

        virtual void registerHlms(void);

        virtual void loadResources(void);

        virtual void chooseSceneManager(void);

        virtual void createCamera(void);

        virtual Ogre::CompositorWorkspace* setupCompositor(void);


        virtual void initMiscParamsListener( Ogre::NameValuePairList &params );


        virtual void createResourceListener(void) {}


        void gameEntityAdded( const GameEntityManager::CreatedGameEntity *createdGameEntity );

        void gameEntityRemoved( GameEntity *toRemove );

    public:

        size_t debug_mode_thread_count = 1;


        BlamCompositorPassRegistry* ogre_pass_registry = nullptr;


        GraphicsSystem( GameState *gameState = nullptr, Ogre::String resourcePath = Ogre::String(""), Ogre::ColourValue backgroundColour = Ogre::ColourValue( 0.2f, 0.4f, 0.6f ) );

        virtual ~GraphicsSystem();


        void _notifyLogicSystem( BaseSystem *logicSystem )      { mLogicSystem = logicSystem; }


        void initialize( const Ogre::String &windowTitle );

        void deinitialize(void);


#if OGRE_USE_SDL2

        void handleWindowEvent(const SDL_Event& evt);

        SdlInputHandler* mInputHandler;

#endif


        void update( float timeSinceLast );


        void updateGameEntities( const GameEntityVec &gameEntities, float weight );


        virtual void execute( size_t threadId, size_t numThreads );


        const GameEntityVec& getGameEntities( Ogre::SceneMemoryMgrTypes type ) const

                                                                { return mGameEntities[type]; }


    #if OGRE_USE_SDL2

        SdlInputHandler* getInputHandler(void)                  { return mInputHandler; }

    #endif


        void setQuit(void)                                      { mQuit = true; }

        bool getQuit(void) const                                { return mQuit; }


        float getAccumTimeSinceLastLogicFrame(void) const       { return mAccumTimeSinceLastLogicFrame; }


        Ogre::Root* getRoot(void) const                         { return mRoot; }

        Ogre::Window* getRenderWindow(void) const               { return mRenderWindow; }

        Ogre::SceneManager* getSceneManager(void) const         { return mSceneManager; }

        Ogre::Camera* getCamera(void) const                     { return mCamera; }

        Ogre::CompositorWorkspace* getCompositorWorkspace(void) const { return mWorkspace; }

        Ogre::v1::OverlaySystem* getOverlaySystem(void) const   { return mOverlaySystem; }


        void setAlwaysAskForConfig( bool alwaysAskForConfig );

        bool getAlwaysAskForConfig( void ) const                { return mAlwaysAskForConfig; }


        const Ogre::String& getPluginsFolder(void) const        { return mPluginsFolder; }

        const Ogre::String& getWriteAccessFolder(void) const    { return mWriteAccessFolder; }

        const Ogre::String& getResourcePath(void) const         { return mResourcePath; }

        const char *getMediaReadArchiveType( void ) const;


        virtual void stopCompositor(void);

        virtual void restartCompositor(void);

    };

}


#endif