E:/Programming/MyProject/K_Game_hg/GameEngine/include/resource/ResourceManager.h

Go to the documentation of this file.

// Copyright 2006-2011 by Kat'Oun

#ifndef _RESOURCE_MANAGER_H_
#define _RESOURCE_MANAGER_H_

#include <EngineConfig.h>
#include <core/Types.h>
#include <core/Singleton.h>
#include <core/Math.h>
#include <engine/Object.h>

#include <string>
#include <vector>
#include <list>
#include <map>

namespace core
{
class ConfigFile;
}

namespace platform
{
class FileSystem;
}

namespace resource
{

class DataStream;
class Serializer;
class Resource;
class ResourceFactory;
class LoadEventReceiver;
struct LoadEvent;
enum ResourceType;

class ENGINE_PUBLIC_EXPORT ResourceManager: public engine::Object, public core::Singleton<ResourceManager>
{
public:

        ResourceManager();
        ~ResourceManager();

        void start();

        void stop();

        Resource* createResource(const ResourceType& type, const std::string& filename);

        void loadResources();
        void unloadResources();

        bool loadResource(Resource* resource);
        void unloadResource(Resource* resource);
        bool reloadResource(Resource* resource);

        void removeResource(Resource *resource);
        void removeResource(const u32& id);

        void removeAllResources();

        Resource* find(const u32& id);

        Resource* find(const ResourceType& type, const u32& id);

        void registerResourceFactory(const ResourceType& type, ResourceFactory* factory);
        void removeResourceFactory(const ResourceType& type);

        void registerSerializer(const ResourceType& type, Serializer* serializer);
        void removeSerializer(const ResourceType& type);

        void setPaths(const std::string& resourcesfile);

        void addSearchPath(const std::string& path, const std::string& type);

        DataStream* openResource(const std::string& filename);

        void addLoadEventReceiver(LoadEventReceiver* newEventReceiver);
        void removeLoadEventReceiver(LoadEventReceiver* oldEventReceiver);

        u32 getMemoryBudget() const;

        u32 getMemoryUsage() const;

        static ResourceManager* getInstance();

protected:

        void initializeImpl();
        void uninitializeImpl();
        void updateImpl(f32 elapsedTime);

        core::ConfigFile* mConfigFile;

        std::list<LoadEventReceiver*> mLoadEventReceivers;
        
        std::map<std::string, platform::FileSystem*> mFiles;

        std::vector<std::list<Resource*>> mLoadResources;

        std::vector<ResourceFactory*> mResourceFactories;

        std::vector<Serializer*> mSerializers;

        std::map<u32, Resource*> mResources;
        std::map<std::string, Resource*> mResourcesByFilename;
        
        u32 mMemoryBudget;              // In bytes
        u32 mMemoryUsage;               // In bytes

        u32 mTotalLoadSize;
        u32 mLoadedSize;

        LoadEvent* mLoadEvent;

        void fireLoadStarted();

        void fireLoadUpdate();

        void fireLoadEnded();
};

}// end namespace resource

#endif