IRoot.h

Go to the documentation of this file.

// mortic - A game engine for the Expanses of Naryan.
// Copyright (C) 2007  Aaron Griffith
// This file is under the LGPL. See mortic.h for more information.

//  _____             _                                                       //
// |  __ \           | |                                                      //
// | |__) |___   ___ | |_                                                     //
// |  _  // _ \ / _ \| __|                                                    //
// | | \ \ (_) | (_) | |_                                                     //
// |_|  \_\___/ \___/ \__|                                                    //
//                                                                            //
//                                                                            //
// IRoot.h - Interface of Root                                                //

#ifndef __IRoot_h_INCLUDED__
#define __IRoot_h_INCLUDED__

#include <string>
#include <vector>
#include "IObject.h"

namespace mortic
{
        class IRoot;
        class IConfigManager;
        class IConfigSet;
        class IFileManager;
        class IMountable;
        class IEventManager; // Still awaiting review
        class IEvent; // Still awaiting review
        class ILogManager;
        class ISceneManager; // Still awaiting review
        class IVideoManager; // Still awaiting review
        class IScriptManager;
        
    
    enum EManagerType
    {
        EMT_ROOT,

        EMT_CONFIGMANAGER,

        EMT_FILEMANAGER,

        EMT_EVENTMANAGER,

        EMT_LOGMANAGER,
        EMT_LOGMANAGERFILE,

        EMT_SCENEMANAGER,
        EMT_SCENEEND,

        EMT_VIDEOMANAGER,

        EMT_SCRIPTMANAGER,

        EMT_COUNT
    };
};

#include "utilities.h"
#include "IConfigManager.h"
#include "IFileManager.h"
#include "IEventManager.h"
#include "ILogManager.h"
#include "ISceneManager.h"
#include "IVideoManager.h"
#include "IScriptManager.h"

namespace mortic
{
    
    class IRoot
    {
    public:
        IRoot()
        { }
        virtual ~IRoot()
        { }

        
        virtual void addObject(IObject* o) = 0;
        
        
        virtual void removeObject(IObject* o) = 0;
        
        
        virtual void removeObject(unsigned int id) = 0;

        
        virtual IObject* getObject(unsigned int id) = 0;
        
        
        virtual IObject* getObject(enum EManagerType id) = 0;
        
        
        virtual std::vector<IObject*> getObjects(std::string name) = 0;
        
        
        template<class T> T* getObjectCast(unsigned int id)
        {
            return static_cast<T*>(getObject(id));
        }
        
        
        template<class T> T* getObjectCast(enum EManagerType id)
        {
            return static_cast<T*>(getObject(id));
        }
        
        
        virtual unsigned int newID() = 0;
        
        
        virtual void returnID(unsigned int id) = 0;
        
        
        virtual void shutdown() = 0;
        
        
        virtual bool run() = 0;
        
        
        virtual bool isRunning() = 0;
        
        
        virtual std::string getVersion() = 0;

        // Convenience
        
        
        IConfigManager* getConfigManager()
        {
                return getObjectCast<IConfigManager>(EMT_CONFIGMANAGER);
        }
        
        
        IFileManager* getFileManager()
        {
                return getObjectCast<IFileManager>(EMT_FILEMANAGER);
        }
        
        
        ILogManager* getLogManager()
        {
                return getObjectCast<ILogManager>(EMT_LOGMANAGER);
        }
        
        
        ISceneManager* getSceneManager()
        {
                return getObjectCast<ISceneManager>(EMT_SCENEMANAGER);
        }
        
        
        IVideoManager* getVideoManager()
        {
                return getObjectCast<IVideoManager>(EMT_VIDEOMANAGER);
        }
        
        
        IEventManager* getEventManager()
        {
                return getObjectCast<IEventManager>(EMT_EVENTMANAGER);
        }
        
        
        IScriptManager* getScriptManager()
        {
                return getObjectCast<IScriptManager>(EMT_SCRIPTMANAGER);
        }
    };
        
        
    IRoot* createRoot(std::string configFilename = "settings.xml",
                                  IConfigSet* defaults = NULL, IConfigSet* overrides = NULL);
    
    
    void destroyRoot(IRoot* root);
    
    
    IRoot* getLastRoot();

}; // namespace mortic

#ifdef SWIG
#ifndef SWIGINTERN
%template(ObjectList) std::vector<mortic::IObject*>;
%template(getObjectConfigManager) mortic::IRoot::getObjectCast<mortic::IConfigManager>;
%template(getObjectFileManager) mortic::IRoot::getObjectCast<mortic::IFileManager>;
%template(getObjectFile) mortic::IRoot::getObjectCast<mortic::IFile>;
%template(getObjectEventManager) mortic::IRoot::getObjectCast<mortic::IEventManager>;
%template(getObjectEvent) mortic::IRoot::getObjectCast<mortic::IEvent>;
%template(getObjectLogManager) mortic::IRoot::getObjectCast<mortic::ILogManager>;
%template(getObjectSceneManager) mortic::IRoot::getObjectCast<mortic::ISceneManager>;
%template(getObjectScene) mortic::IRoot::getObjectCast<mortic::IScene>;
%template(getObjectVideoManager) mortic::IRoot::getObjectCast<mortic::IVideoManager>;
%template(getObjectScriptManager) mortic::IRoot::getObjectCast<mortic::IScriptManager>;
%template(getObjectScript) mortic::IRoot::getObjectCast<mortic::IScript>;
#endif // SWIGINTERN
#endif // SWIG

#endif // __IRoot_h_INCLUDED__

---