Ignore:
Timestamp:
12/23/2006 08:44:49 PM (13 years ago)
Author:
art
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed
  • nrEngine/include/Resource.h

    r1 r15  
    2121#include "Prerequisities.h" 
    2222#include "ResourceSystem.h" 
     23#include <boost/enable_shared_from_this.hpp> 
    2324 
    2425namespace nrEngine{ 
     
    4849        * \ingroup resource 
    4950        **/ 
    50         class _NRExport IResource{ 
     51        class _NRExport IResource : public boost::enable_shared_from_this<IResource>{ 
    5152        public: 
     53 
     54                /** 
     55                * Here the class should return cound of bytes reserved 
     56                * by the resource. The size must not contain the size of the class itself. 
     57                * For example: 32Bit Texture of 16x16 Pixel has the size: 16*16*4 = 1024 Bytes + 
     58                * some more bytes which does class need to store himself in the memory. 
     59                **/ 
     60                NR_FORCEINLINE std::size_t getResDataSize(){return mResDataSize;} 
     61 
     62 
     63                /** 
     64                * Return here the name of the resource type. This name will be used 
     65                * to assign right empty resources to the resource pointer/holder objects. 
     66                * E.g: "Texture", "Sound",  ... 
     67                **/ 
     68                NR_FORCEINLINE const std::string& getResType() const { return mResType; } 
     69 
     70 
     71                /** 
     72                * Return true if the resource is marked as loaded. If any resource is loaded 
     73                * so it contains in the memory and has it's full data there. 
     74                **/ 
     75                NR_FORCEINLINE bool                             isResLoaded() const {return mResIsLoaded;} 
     76 
     77                /** 
     78                * Return handle of this resource 
     79                **/ 
     80                NR_FORCEINLINE ResourceHandle           getResHandle() const {return mResHandle;} 
     81 
     82                /** 
     83                * Return group name to which one this resource belongs 
     84                **/ 
     85                NR_FORCEINLINE const std::string&       getResGroup() const {return mResGroup;} 
     86 
     87                /** 
     88                * Get the name of the resource 
     89                **/ 
     90                NR_FORCEINLINE const std::string&       getResName() const {return mResName;} 
     91 
     92                /** 
     93                * Get the file name from which one this resource can be restored or loaded 
     94                **/ 
     95                NR_FORCEINLINE const std::string&       getResFileName() const {return mResFileName;} 
     96 
     97                /** 
     98                * Returns true if this resource is a empty resource. Empty resources are used 
     99                * to replace normal resources if they are unloaded. 
     100                **/ 
     101                NR_FORCEINLINE bool                             isResEmpty()    {return mResIsEmpty;} 
     102 
     103        protected: 
     104                 
     105                /** 
     106                 * Create resource instance. 
     107                 **/ 
     108                IResource(const std::string& resourceType); 
    52109 
    53110 
     
    65122                 **/ 
    66123                virtual ~IResource(); 
    67  
    68                 /** 
    69                 * Here the class should return cound of bytes reserved 
    70                 * by the resource. The size must not contain the size of the class itself. 
    71                 * For example: 32Bit Texture of 16x16 Pixel has the size: 16*16*4 = 1024 Bytes + 
    72                 * some more bytes which does class need to store himself in the memory. 
    73                 **/ 
    74                 NR_FORCEINLINE std::size_t getResDataSize(){return mResDataSize;} 
    75  
    76  
    77                 /** 
    78                 * Return here the name of the resource type. This name will be used 
    79                 * to assign right empty resources to the resource pointer/holder objects. 
    80                 * E.g: "Texture", "Sound",  ... 
    81                 **/ 
    82                 NR_FORCEINLINE const std::string& getResType() const { return mResType; } 
    83  
    84  
    85                 /** 
    86                 * Return true if the resource is marked as loaded. If any resource is loaded 
    87                 * so it contains in the memory and has it's full data there. 
    88                 **/ 
    89                 NR_FORCEINLINE bool                             isResLoaded() const {return mResIsLoaded;} 
    90  
    91                 /** 
    92                 * Return handle of this resource 
    93                 **/ 
    94                 NR_FORCEINLINE ResourceHandle           getResHandle() const {return mResHandle;} 
    95  
    96                 /** 
    97                 * Return group name to which one this resource belongs 
    98                 **/ 
    99                 NR_FORCEINLINE const std::string&       getResGroup() const {return mResGroup;} 
    100  
    101                 /** 
    102                 * Get the name of the resource 
    103                 **/ 
    104                 NR_FORCEINLINE const std::string&       getResName() const {return mResName;} 
    105  
    106                 /** 
    107                 * Get the file name from which one this resource can be restored or loaded 
    108                 **/ 
    109                 NR_FORCEINLINE const std::string&       getResFileName() const {return mResFileName;} 
    110  
    111                 /** 
    112                 * Returns true if this resource is a empty resource. Empty resources are used 
    113                 * to replace normal resources if they are unloaded. 
    114                 **/ 
    115                 NR_FORCEINLINE bool                             isResEmpty()    {return mResIsEmpty;} 
    116  
    117         protected: 
    118                  
    119                 /** 
    120                  * Create resource instance. 
    121                  **/ 
    122                 IResource(const std::string& resourceType); 
    123124 
    124125                /** 
     
    145146                 * on the restored data. 
    146147                 **/ 
    147                 virtual void notifyResReloaded() { } 
     148                //virtual void notifyResReloaded() { } 
    148149                 
    149150                /** 
     
    171172 
    172173                //! Resource's loader with which one it was created 
    173                 IResourceLoader*        mResLoader; 
     174                SharedPtr<IResourceLoader>      mResLoader; 
    174175 
    175176                //! Handle of the resource given from manager 
     
    214215                 **/ 
    215216                Result removeResThroughLoader(); 
    216                  
     217 
     218                /** 
     219                * Get shared pointer from this class 
     220                **/      
     221                SharedPtr<IResource> getSharedPtrFromThis() 
     222                { 
     223                        return shared_from_this(); 
     224                } 
     225                 
     226                class _deleter{ 
     227                public: 
     228                        void operator()(IResource* p) { delete p; } 
     229                }; 
    217230        }; 
    218231 
Note: See TracChangeset for help on using the changeset viewer.