GraphicsSystem.h

Go to the documentation of this file.

 
#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/OgreLog.h"
 
#include "OGRE/Threading/OgreUniformScalableTask.h"
#include "SdlEmulationLayer.h"
#include "OGRE/Overlay/OgreOverlaySystem.h"
 
#include "components/rendering/compositor/compositor.h"
 
#if OGRE_USE_SDL2
    #include <SDL2/SDL.h>
#endif
 
namespace Demo
{
    class SdlInputHandler;
 
    class GraphicsSystem : public BaseSystem, public Ogre::UniformScalableTask, public Ogre::LogListener
    {
    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);
 
        void messageLogged(const Ogre::String& message, Ogre::LogMessageLevel lml, bool maskDebug,
            const Ogre::String& logName, bool& skipThisMessage) override;
    };
}
 
#endif