resourcepool.h

/*--License:
        Lilith 3D Engine
        Copyright Lee Thomason (Grinning Lizard Software) 2002-2007
        www.grinninglizard.com/lilith

        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.

        You should have received a copy of the GNU General Public License
        along with this program; if not, write to the Free Software
        Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

        The full text of the license can be found in license.txt
*/

#ifndef LILITH_RESOURCE_POOL
#define LILITH_RESOURCE_POOL

#include "texture.h"
#include "meshresource.h"
#include "shader.h"

namespace lilith3d
{

class ResourcePool
{
public:
        TextureManager textureManager;
        MeshResManager meshManager;
        ShaderManager  shaderManager;

        static ResourcePool* Instance() { return instance; }

        ResourcePool()  {       GLASSERT( !instance );
                                                instance = this;
                                        }
        ~ResourcePool() {       instance = 0; }

        void SetImportPath( const std::string& path )   
        {       
                textureManager.SetImportPath( path );
                meshManager.SetImportPath( path );
                shaderManager.SetImportPath( path );
        }

        bool LoadRequiredAssets()
        {
                return    textureManager.LoadRequiredTextures()
                           && meshManager.LoadRequiredModels()
                           && shaderManager.LoadRequiredShaders();
        }

        const Texture* LoadTexture(     const std::string& filename,            
                                                                const std::string& textureName,
                                                                int textureId = 0,
                                                                int flags = 0 )
        {
                return textureManager.LoadTexture( filename, textureName, textureId, flags );
        }

        const Texture* GetTexture( const std::string& textureName, U32 textureId )
        {
                return textureManager.GetTexture( textureName, textureId );
        }

        StaticResource* LoadStaticRes(  const std::string& filename, const std::string& name, U32 flags )
        {
                return meshManager.LoadStaticRes( filename, name, flags );
        }

        MD2Resource* LoadMD2Res(        const std::string& name,
                                                                const std::string& md2MeshFilename,
                                                                const std::string& skinTextureFilename,
                                                                const std::string& md2WeaponFilename,
                                                                const std::string& weaponTextureFilename )
        {
                return meshManager.LoadMD2ResComplete( name, md2MeshFilename, skinTextureFilename, md2WeaponFilename, weaponTextureFilename );
        }
        
        const StaticResource* GetStaticRes( const std::string& name )
        {
                return meshManager.GetStaticRes( name );
        }

        const MD2Resource* GetMD2Res( const std::string& name )
        {
                return meshManager.GetMD2Res( name );   
        }

private:
        static ResourcePool* instance;

};

};      // lilith3d
#endif

---