OgreResource.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser 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, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/
#ifndef _Resource_H__
#define _Resource_H__

#include "OgrePrerequisites.h"
#include "OgreString.h"
#include "OgreSharedPtr.h"
#include "OgreStringInterface.h"

namespace Ogre {

    typedef unsigned long ResourceHandle;


    // Forward declaration
    class ManualResourceLoader;

    class _OgreExport Resource : public StringInterface
    {
    public:
        OGRE_AUTO_MUTEX // public to allow external locking
    protected:
        ResourceManager* mCreator;
        String mName;
        String mGroup;
        ResourceHandle mHandle;
        bool mIsLoaded;
        size_t mSize;
        bool mIsManual;
        String mOrigin;
        ManualResourceLoader* mLoader;

        Resource() 
            : mCreator(0), mHandle(0), mIsLoaded(false), mSize(0), mIsManual(0), mLoader(0)
        { 
        }

        virtual void loadImpl(void) = 0;
        virtual void unloadImpl(void) = 0;
        virtual size_t calculateSize(void) const = 0;

    public:
        Resource(ResourceManager* creator, const String& name, ResourceHandle handle,
            const String& group, bool isManual = false, ManualResourceLoader* loader = 0);

        virtual ~Resource();

        virtual void load(void);

        virtual void reload(void);

        bool isReloadable(void) const
        {
            return !mIsManual || mLoader;
        }

        bool isManuallyLoaded(void) const
        {
            return mIsManual;
        }

        virtual void unload(void);

        size_t getSize(void) const
        { 
            return mSize; 
        }

        virtual void touch(void);

        const String& getName(void) const 
        { 
            return mName; 
        }

        ResourceHandle getHandle(void) const
        {
            return mHandle;
        }

        bool isLoaded(void) const 
        { 
            OGRE_LOCK_AUTO_MUTEX
            return mIsLoaded; 
        }

        const String& getGroup(void) { return mGroup; }

        ResourceManager* getCreator(void) { return mCreator; }
        const String& getOrigin(void) const { return mOrigin; }
        void _notifyOrigin(const String& origin) { mOrigin = origin; }

    };

    typedef SharedPtr<Resource> ResourcePtr;

    class _OgreExport ManualResourceLoader
    {
    public:
        ManualResourceLoader() {}
        virtual ~ManualResourceLoader() {}

        virtual void loadResource(Resource* resource) = 0;
    };
}

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Feb 12 12:59:51 2006