Changeset 15 for nrEngine


Ignore:
Timestamp:
12/23/06 20:44:49 (12 years ago)
Author:
art
Message:
 
Location:
nrEngine
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • nrEngine/include/EventActor.h

    r1 r15  
    6868 
    6969                        /** 
     70                         * Send a message through all connected channels. 
     71                         *  
     72                         * @param event Message to be send 
     73                         **/ 
     74                        Result emit(SharedPtr<Event> event); 
     75                         
     76                        /** 
    7077                         * Connect an actor to a certain channel. 
    7178                         * 
  • nrEngine/include/EventManager.h

    r1 r15  
    184184                        Result removeFactory(const std::string& name); 
    185185 
    186  
     186                        #if 0 
     187                        /** 
     188                         * Create and emit a message through a channel. 
     189                         * @param channel Channel name where to emit  
     190                         * @return Result of emit() method 
     191                         **/ 
     192                        template<class EventT> 
     193                        Result createEmit(const std::string& channel, void* param = NULL) 
     194                        { 
     195                                SharedPtr<Event> msg(new EventT); 
     196                                return emit(channel, msg); 
     197                        } 
     198                        #endif 
     199                         
    187200                private: 
    188201 
  • nrEngine/include/FileStreamLoader.h

    r1 r15  
    4747                        /** 
    4848                        * Initialize supported resource and file types 
    49                         * @see IResourceLoader::initialize() 
     49                        * @see IResourceLoader::initializeResourceLoader() 
    5050                        **/ 
    51                         Result initialize(); 
     51                        Result initializeResourceLoader(); 
    5252         
    5353                        /** 
    54                         * @see IResourceLoader::loadImpl() 
     54                        * @see IResourceLoader::loadResourceImpl() 
    5555                        **/ 
    56                         Result loadImpl(IResource* res, const std::string& fileName, PropertyList* param = NULL); 
     56                        Result loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param = NULL); 
    5757         
    5858                        /** 
    59                         * @see IResourceLoader::createImpl() 
     59                        * @see IResourceLoader::createResourceImpl() 
    6060                        **/ 
    61                         IResource* createImpl(const std::string& resourceType, PropertyList* params = NULL); 
     61                        IResource* createResourceImpl(const std::string& resourceType, PropertyList* params = NULL); 
    6262                                 
    6363                        /** 
    64                         * @see IResourceLoader::createEmpty() 
     64                        * @see IResourceLoader::createResourceEmpty() 
    6565                        **/ 
    66                         IResource* createEmpty(const std::string& resourceType); 
     66                        IResource* createEmptyResource(const std::string& resourceType); 
    6767 
    6868        }; 
  • nrEngine/include/PluginLoader.h

    r1 r15  
    7272                * @see IResourceLoader::initialize() 
    7373                **/ 
    74                 Result initialize(); 
     74                Result initializeResourceLoader(); 
    7575 
    7676                /** 
    7777                 * @see IResourceLoader::loadImpl() 
    7878                 **/ 
    79                 Result loadImpl(IResource* res, const std::string& fileName, PropertyList* param = NULL); 
     79                Result loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param = NULL); 
    8080 
    8181                /** 
    8282                 * @see IResourceLoader::createImpl() 
    8383                 **/ 
    84                 IResource* createImpl(const std::string& resourceType, PropertyList* params = NULL); 
     84                IResource* createResourceImpl(const std::string& resourceType, PropertyList* params = NULL); 
    8585                         
    8686                /** 
    8787                 * @see IResourceLoader::createEmpty() 
    8888                 **/ 
    89                 IResource* createEmpty(const std::string& resourceType); 
     89                IResource* createEmptyResource(const std::string& resourceType); 
    9090 
    9191                /** 
    9292                 * Unload the given plugin resource 
    9393                 **/ 
    94                 Result unloadImpl(IResource*); 
     94                Result unloadResourceImpl(IResource*); 
    9595 
    9696                /** 
  • 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 
  • nrEngine/include/ResourceLoader.h

    r1 r15  
    2121#include "Prerequisities.h" 
    2222#include "ResourceSystem.h" 
     23#include <boost/enable_shared_from_this.hpp> 
    2324 
    2425namespace nrEngine{ 
     
    7576        * \ingroup resource 
    7677        **/ 
    77         class _NRExport IResourceLoader{ 
     78        class _NRExport IResourceLoader : public boost::enable_shared_from_this<IResourceLoader>{ 
    7879                public: 
    7980                         
     
    9798                         * @return either OK or an error code 
    9899                        **/ 
    99                         IResource* load(const std::string& name, const std::string& group, const std::string& fileName, const std::string& resourceType = std::string(), PropertyList* param = NULL); 
     100                        SharedPtr<IResource> load(const std::string& name, const std::string& group, const std::string& fileName, const std::string& resourceType = std::string(), PropertyList* param = NULL); 
    100101                                         
    101102                        /** 
     
    111112                         * object will be created of this type. This will be automaticaly registered by the manager. 
    112113                         **/ 
    113                         IResource* create(const std::string& resourceType, PropertyList* params = NULL); 
     114                        SharedPtr<IResource> create(const std::string& resourceType, PropertyList* params = NULL); 
    114115 
    115116                        /** 
     
    119120                         * already exists. 
    120121                         **/ 
    121                         IResource* create(const std::string& name, const std::string& group, const std::string& resourceType, PropertyList* params = NULL); 
     122                        SharedPtr<IResource> create(const std::string& name, const std::string& group, const std::string& resourceType, PropertyList* params = NULL); 
    122123 
    123124                        /** 
     
    151152                        **/ 
    152153                        bool supportFileType(const std::string& fileType) const ; 
    153          
     154 
     155                        /** 
     156                         * Unload the given resource. Unloading of a resource does not mean that the 
     157                         * resource is removed from the memory. It just release almost all used 
     158                         * memory and an empty resource will be used instead. To remove it completly 
     159                         * from the memory call remove() instead. 
     160                         * 
     161                         * This method will be called by the manager or the resource, as soon as a resource must 
     162                         * be unloaded. 
     163                         **/ 
     164                        Result unload(SharedPtr<IResource> resource); 
     165 
     166                        /** 
     167                         * Remove the resource from the memory. This method will be called 
     168                         * by the resource manager, so the loader can do the stuff needed 
     169                         * to remove the resource. 
     170                         **/ 
     171                        Result remove(SharedPtr<IResource> resource); 
     172 
     173                        /** 
     174                         * Reload a certain resource again. A resource object has to be created before. 
     175                         * If the resource object is loaded, so it will be unloaded and loaded again. Also 
     176                         * the resource object will be notified about this event, so it can react on this. 
     177                         * No new instancies will be created. 
     178                         **/ 
     179                        Result reload(SharedPtr<IResource> resource); 
     180 
     181 
    154182                protected: 
    155183 
     
    163191                         * 
    164192                         **/ 
    165                         virtual Result unloadImpl(IResource*); 
     193                        virtual Result unloadResourceImpl(IResource*); 
    166194 
    167195                        /** 
     
    175203                         * NULL will be passed). 
    176204                         **/ 
    177                         virtual Result reloadImpl(IResource*); 
     205                        virtual Result reloadResourceImpl(IResource*); 
    178206                         
    179207                        /** 
     
    185213                         * @param param Specific parameters specified by the user 
    186214                         **/ 
    187                         virtual Result loadImpl(IResource* res, const std::string& fileName, PropertyList* param = NULL) = 0; 
     215                        virtual Result loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param = NULL) = 0; 
    188216 
    189217                        /** 
     
    195223                         *  
    196224                         **/ 
    197                         virtual IResource* createImpl(const std::string& resourceType, PropertyList* params = NULL) = 0; 
     225                        virtual IResource* createResourceImpl(const std::string& resourceType, PropertyList* params = NULL) = 0; 
    198226                         
    199227                        /** 
     
    204232                         * @return Instance of empty resource 
    205233                         **/ 
    206                         virtual IResource* createEmpty(const std::string& resourceType) = 0; 
     234                        virtual IResource* createEmptyResource(const std::string& resourceType) = 0; 
    207235                         
    208236                        /** 
     
    213241                         * This method should be called from the constructor, to declare supported types. 
    214242                         **/ 
    215                         virtual Result initialize() = 0; 
     243                        virtual Result initializeResourceLoader() = 0; 
    216244                         
    217245                        /** 
     
    267295                private: 
    268296                         
    269                         //! Resource can notify the loader about certain events 
    270                         friend class IResource; 
    271                          
    272297                        //! List of supported resource types 
    273298                        std::vector< std::string >              mSupportedResourceTypes; 
     
    282307                        std::string mName; 
    283308 
    284                         //! List of resources loaded with the help of this loader 
    285                         std::list<IResource* > mHandledResources; 
    286  
    287                         /** 
    288                          * Unload the given resource. Unloading of a resource does not mean that the 
    289                          * resource is removed from the memory. It just release almost all used 
    290                          * memory and an empty resource will be used instead. To remove it completly 
    291                          * from the memory call remove() instead. 
    292                          * 
    293                          * This method will be called by the manager or the resource, as soon as a resource must 
    294                          * be unloaded. 
    295                          **/ 
    296                         Result unload(IResource* resource); 
    297  
    298                         /** 
    299                          * Remove the resource from the memory. This method will be called 
    300                          * by the resource manager, so the loader can do the stuff needed 
    301                          * to remove the resource. 
    302                          **/ 
    303                         Result remove(IResource* resource); 
    304  
    305                         /** 
    306                          * Reload a certain resource again. A resource object has to be created before. 
    307                          * If the resource object is loaded, so it will be unloaded and loaded again. Also 
    308                          * the resource object will be notified about this event, so it can react on this. 
    309                          * No new instancies will be created. 
    310                          **/ 
    311                         Result reload(IResource* resource); 
     309                        typedef std::list< SharedPtr<IResource> >  ResourceList; 
     310                         
     311                        //! List of resources managed by this loader 
     312                        ResourceList mHandledResources; 
     313 
     314                        /** 
     315                         * Get shared pointer from this class 
     316                         **/     
     317                        SharedPtr<IResourceLoader> getSharedPtrFromThis() 
     318                        { 
     319                                return shared_from_this(); 
     320                        } 
    312321 
    313322                        /** 
     
    315324                         * will be removed from the memory now. 
    316325                         **/ 
    317                         void notifyRemoveResource(IResource*); 
     326                        void notifyRemoveResource(SharedPtr<IResource>); 
    318327 
    319328                        /** 
     
    321330                         * from resource manager or by the resource itself 
    322331                         **/ 
    323                         void notifyUnloadResource(IResource*); 
     332                        void notifyUnloadResource(SharedPtr<IResource>); 
    324333                         
    325334        }; 
  • nrEngine/include/ResourceManager.h

    r1 r15  
    437437         
    438438         
    439                         typedef ::std::map<ResourceHandle, SharedPtr<ResourceHolder> >  res_hdl_map; 
    440                         typedef ::std::map< ::std::string, ResourceHandle>                                              res_str_map; 
    441                         typedef ::std::map< ::std::string, ::std::list<ResourceHandle> >                        res_grp_map; 
    442                         typedef ::std::map< ::std::string, SharedPtr<IResource> >               res_empty_map; 
     439                        typedef ::std::map<ResourceHandle, SharedPtr<ResourceHolder> >   res_hdl_map; 
     440                        typedef ::std::map< ::std::string, ResourceHandle>               res_str_map; 
     441                        typedef ::std::map< ::std::string, ::std::list<ResourceHandle> > res_grp_map; 
     442                        typedef ::std::map< ::std::string, SharedPtr<IResource> >        res_empty_map; 
    443443         
    444444                        res_hdl_map     mResource; 
     
    540540                         
    541541                        /** 
    542                         * Get an empty resource if given type. 
     542                        * Get an empty resource of given type. 
    543543                        * 
    544544                        * @param type Type of the resource for which one the empty object should be returned 
  • nrEngine/include/ScriptLoader.h

    r1 r15  
    5151                         * Initialize supported resource and file types for the resource script 
    5252                         **/ 
    53                         Result initialize(); 
     53                        Result initializeResourceLoader(); 
    5454                         
    5555                        /** 
     
    6161                        * so you have to worry about the adding the script into the kernel . 
    6262                        **/ 
    63                         Result loadImpl(IResource* res, const std::string& fileName, PropertyList* param = NULL); 
     63                        Result loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param = NULL); 
    6464         
    6565                        /** 
     
    7070                        * @return Instance of empty resource 
    7171                        **/ 
    72                         IResource* createEmpty(const std::string& resourceType); 
     72                        IResource* createEmptyResource(const std::string& resourceType); 
    7373                         
    7474                        /** 
    75                         * @see IResourceLoader::createImpl() 
     75                        * @see IResourceLoader::createResourceImpl() 
    7676                        **/ 
    77                         IResource* createImpl(const std::string& resourceType, PropertyList* params = NULL); 
     77                        IResource* createResourceImpl(const std::string& resourceType, PropertyList* params = NULL); 
    7878                         
    7979 
  • nrEngine/include/SmartPtr.h

    r1 r15  
    4040#define SharedPtr boost::shared_ptr 
    4141 
     42#if 0 
    4243        /** 
    43          * Smart pointers we are using does not coded extra for nrEngine. 
    44          * Just use boost's implementation of this for our purpose. 
    45          * 
    46          * We use this extra definition to do less typing and to stay in the 
    47          * same namespace as the engine. So instead of typing 
    48          * boost::shared_ptr, we simply type SharedPtr. 
     44         * In our engine we are use always smart pointers, so that you do not have  
     45         * to care about the lifetime of them. We provide our own pointer definition 
     46         * rather than using boost's for example. Boosts pointers are fine, but they 
     47         * depends on a big library and could not be changed in a way, which are 
     48         * usefull for our puprose. 
    4949         *  
     50         * The pointer does provide a reference counting mechanism. But rather then  
     51         * deriving the classes which could be referenced by this pointer, we store 
     52         * the counter 
    5053         * \ingroup gp 
    5154         **/ 
    52         /*template<class T> 
    53         class _NRExport SharedPtr : public boost::shared_ptr<T>{ 
     55        template <typename T>  
     56        class RefPtr { 
     57                private: 
     58                 
     59                        //! Store here the reference counter 
     60                        int32 mCounter; 
     61                         
     62                        //! here we store the pointer itself 
     63                        T* mPointer; 
     64                 
     65                        //! Reference the object, so it will increment the counter  
     66                        void ref()  
     67                        { 
     68                                mCount ++; 
     69                        } 
     70                 
     71                        //! Decrement the counter and release object if counter is equal 0 
     72                        void unref() 
     73                        {  
     74                                mCounter --; 
     75                                if (mCounter == 0){ 
     76                                        delete mPointer; 
     77                                } 
     78                        } 
     79 
    5480                public: 
    55                         SharedPtr() : boost::shared_ptr<T>(){} 
    56                         SharedPtr(T* t) : boost::shared_ptr<T>(t){} 
    57  
    58                         //! Copyconstructor 
    59                         SharedPtr(const SharedPtr& ptr) : boost::shared_ptr<T>(ptr) { 
    60                                  
    61                         } 
     81                 
     82                        //! Define the pointer as a friend of it's own 
     83                        template <class Y> friend class RefPtr;  
    6284                         
    63         };*/ 
    64  
     85                        //! Create a pointer and initialze it with a NULL pointer 
     86                        RefPtr() : mPointer(0), mCounter(0) 
     87                        { 
     88                        } 
     89                         
     90                        //! Create a smart pointer from a given raw pointer  
     91                        RefPtr(T* raw) : mPointer(0), mCounter(0) 
     92                        { 
     93                                // if the given object is valid, so reference it 
     94                                if (raw){ 
     95                                        mPointer = raw; 
     96                                        ref(); 
     97                                } 
     98                        } 
     99                 
     100                        //! Copyconstructor, copy the pointer and reference it again 
     101                        RefPtr(const RefPtr<T>& ptr) : mPointer(ptr.mPointer) 
     102                        { 
     103                                if (mPointer) ref(); 
     104                        } 
     105                         
     106                        //! Release the pointer, delete the holding object only if it reference counter goes to null 
     107                        ~RefPtr() 
     108                        { 
     109                                if (mPointer) unref(); 
     110                                mPointer = 0; 
     111                        } 
     112 
     113 
     114                        //! Assigment of a raw pointer. Use it with care, because now the RefPtr gets ownership  
     115                        NR_FORCEINLINE RefPtr& operator=(T* ptr) 
     116                        { 
     117                         if (_ptr==ptr) return *this; 
     118            T* tmp_ptr = _ptr; 
     119            _ptr = ptr; 
     120            if (_ptr) _ptr->ref(); 
     121            // unref second to prevent any deletion of any object which might 
     122            // be referenced by the other object. i.e rp is child of the 
     123            // original _ptr. 
     124            if (tmp_ptr) tmp_ptr->unref(); 
     125            return *this; 
     126                                if (mPointer == ptr) return *this; 
     127                                if () 
     128                                { 
     129                                        release();  
     130                                        counter = new Counter;  
     131                                        rawPtr = raw;  
     132                                } 
     133                                return *this; 
     134                        } 
     135         
     136        template <typename Y> 
     137        ptr& operator=(Y* raw) 
     138        { 
     139                if (raw) 
     140                { 
     141                        release(); 
     142                        counter = new Counter;  
     143                        rawPtr = static_cast<X*>(raw); 
     144                } 
     145                return *this; 
     146        } 
     147         
     148        /*  
     149                assignment to long to allow ptr< X > = NULL,  
     150                also allows raw pointer assignment by conversion.  
     151                Raw pointer assignment is really dangerous! 
     152                If the raw pointer is being used elsewhere,  
     153                it will get deleted prematurely.  
     154        */  
     155        ptr& operator=(long num) 
     156        { 
     157                if (num == 0)  //pointer set to null 
     158                { 
     159                        release();  
     160                } 
     161         
     162                else //assign raw pointer by conversion 
     163                { 
     164                        release(); 
     165                        counter = new Counter;  
     166                        rawPtr = reinterpret_cast<X*>(num); 
     167                }        
     168         
     169                return *this;  
     170        }  
     171         
     172        /* 
     173                Member Access 
     174        */ 
     175                X* operator->() const  
     176                { 
     177                        return GetRawPointer();  
     178                } 
     179         
     180         
     181        /* 
     182                Dereference the pointer 
     183        */ 
     184                X& operator* () const  
     185                { 
     186                        return *GetRawPointer();  
     187                } 
     188         
     189         
     190        /* 
     191                Conversion/casting operators 
     192        */ 
     193                operator bool() const 
     194                { 
     195                        return IsValid(); 
     196                } 
     197         
     198                template <typename Y> 
     199                operator Y*() const 
     200                { 
     201                        return static_cast<Y*>(rawPtr);   
     202                } 
     203         
     204                template <typename Y> 
     205                operator const Y*() const 
     206                { 
     207                        return static_cast<const Y*>(rawPtr); 
     208                } 
     209         
     210         
     211        /* 
     212                Provide access to the raw pointer  
     213        */ 
     214         
     215                X* GetRawPointer() const          
     216                { 
     217                        if (rawPtr == 0) throw new NullPointerException; 
     218                        return rawPtr; 
     219                } 
     220         
     221                 
     222        /*  
     223                Is there only one reference on the counter? 
     224        */ 
     225                bool IsUnique() const 
     226                { 
     227                        if (counter && counter->count == 1) return true;  
     228                        else return false;  
     229                } 
     230                 
     231                bool IsValid() const 
     232                { 
     233                        if (counter && rawPtr) return true; 
     234                        else return false;  
     235                } 
     236         
     237                unsigned GetCount() const 
     238                { 
     239                        if (counter) return counter->count; 
     240                        else return 0; 
     241                } 
     242         
     243        }; 
     244         
     245         
     246        template <typename X, typename Y> 
     247        bool operator==(const ptr< X >& lptr, const ptr< Y >& rptr)  
     248        { 
     249                return lptr.GetRawPointer() == rptr.GetRawPointer();  
     250        } 
     251         
     252        template <typename X, typename Y> 
     253        bool operator==(const ptr< X >& lptr, Y* raw)  
     254        { 
     255                return lptr.GetRawPointer() == raw ;  
     256        } 
     257         
     258        template <typename X> 
     259        bool operator==(const ptr< X >& lptr, long num) 
     260        { 
     261                if (num == 0 && !lptr.IsValid())  //both pointer and address are null 
     262                { 
     263                        return true;  
     264                } 
     265         
     266                else //convert num to a pointer, compare addresses 
     267                { 
     268                        return lptr == reinterpret_cast<X*>(num); 
     269                } 
     270                 
     271        }  
     272         
     273        template <typename X, typename Y> 
     274        bool operator!=(const ptr< X >& lptr, const ptr< Y >& rptr)  
     275        { 
     276                return ( !operator==(lptr, rptr) ); 
     277        } 
     278         
     279        template <typename X, typename Y> 
     280        bool operator!=(const ptr< X >& lptr, Y* raw)  
     281        { 
     282                        return ( !operator==(lptr, raw) ); 
     283        } 
     284         
     285        template <typename X> 
     286        bool operator!=(const ptr< X >& lptr, long num) 
     287        { 
     288                return (!operator==(lptr, num) );  
     289        } 
     290         
     291        template <typename X, typename Y> 
     292        bool operator&&(const ptr< X >& lptr, const ptr< Y >& rptr) 
     293        { 
     294                return lptr.IsValid() &&  rptr.IsValid(); 
     295        } 
     296         
     297        template <typename X> 
     298        bool operator&&(const ptr< X >& lptr, bool rval) 
     299        { 
     300                return lptr.IsValid() && rval; 
     301        } 
     302         
     303        template <typename X> 
     304        bool operator&&(bool lval, const ptr< X >& rptr) 
     305        { 
     306                return lval &&  rptr.IsValid(); 
     307        } 
     308         
     309        template <typename X, typename Y> 
     310        bool operator||(const ptr< X >& lptr, const ptr< Y >& rptr) 
     311        { 
     312                return lptr.IsValid() || rptr.IsValid(); 
     313        } 
     314         
     315        template <typename X> 
     316        bool operator||(const ptr< X >& lptr, bool rval) 
     317        { 
     318                return lptr.IsValid() || rval; 
     319        } 
     320         
     321        template <typename X> 
     322        bool operator||(bool lval, const ptr< X >& rptr) 
     323        { 
     324                return lval || rptr.IsValid();  
     325        } 
     326         
     327        template <typename X> 
     328        bool operator!(const ptr< X >& p) 
     329        { 
     330                return (!p.IsValid()); 
     331        } 
     332         
     333         
     334        /* less than comparisons for storage in containers */ 
     335        template <typename X, typename Y> 
     336        bool operator< (const ptr< X >& lptr, const ptr < Y >& rptr) 
     337        { 
     338                return lptr.GetRawPointer() < rptr.GetRawPointer(); 
     339        } 
     340         
     341        template <typename X, typename Y> 
     342        bool operator< (const ptr< X >& lptr, Y* raw) 
     343        { 
     344                return lptr.GetRawPointer() < raw; 
     345        } 
     346         
     347        template <typename X, typename Y> 
     348        bool operator< (X* raw, const ptr< Y >& rptr) 
     349        { 
     350                raw < rptr.GetRawPointer(); 
     351        } 
     352#endif 
    65353}; // end namespace 
    66354 
  • nrEngine/src/EventActor.cpp

    r1 r15  
    5050        }*/ 
    5151         
     52        //------------------------------------------------------------------------ 
     53        Result EventActor::emit(SharedPtr<Event> event) 
     54        { 
     55                // iterate through channels and emit messages 
     56                std::list<std::string>::iterator it = mChannel.begin(); 
     57                for (; it != mChannel.end(); it++) 
     58                { 
     59                        Result res = Engine::sEventManager()->emit(*it, event); 
     60                        if (res != OK)  
     61                        { 
     62                                NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "EventActor: Cannot emit message to '%s'", it->c_str()); 
     63                                return res; 
     64                        } 
     65                } 
     66                return OK; 
     67        } 
     68 
    5269        //------------------------------------------------------------------------ 
    5370        Result EventActor::connect (const std::string& name) 
  • nrEngine/src/FileStreamLoader.cpp

    r1 r15  
    2323        FileStreamLoader::FileStreamLoader() : IResourceLoader("FileStreamLoader") 
    2424        { 
    25                 initialize(); 
     25                initializeResourceLoader(); 
    2626        } 
    2727 
     
    3434 
    3535        //---------------------------------------------------------------------------------- 
    36         Result FileStreamLoader::initialize(){ 
     36        Result FileStreamLoader::initializeResourceLoader(){ 
    3737                 
    3838                // fill out supported resource types; 
     
    4343         
    4444        //---------------------------------------------------------------------------------- 
    45         Result FileStreamLoader::loadImpl(IResource* res, const std::string& fileName, PropertyList* param) 
     45        Result FileStreamLoader::loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param) 
    4646        { 
    4747                // create a pointer to the stream object and open the file 
     
    5252 
    5353        //---------------------------------------------------------------------------------- 
    54         IResource* FileStreamLoader::createImpl(const std::string& resourceType, PropertyList* params) 
     54        IResource* FileStreamLoader::createResourceImpl(const std::string& resourceType, PropertyList* params) 
    5555        { 
    5656                // create an plugin instance 
     
    6060 
    6161        //---------------------------------------------------------------------------------- 
    62         IResource* FileStreamLoader::createEmpty(const std::string& resourceType) 
     62        IResource* FileStreamLoader::createEmptyResource(const std::string& resourceType) 
    6363        { 
    6464                // create an instance of empty plugin 
  • nrEngine/src/Makefile

    r13 r15  
    5454TARGET=  libnrEngine.so 
    5555INCPATH += -I../include 
    56 CFLAGS += -fPIC 
     56CFLAGS += -fPIC -g 
    5757LIBS += -ldl 
    5858 
  • nrEngine/src/PluginLoader.cpp

    r1 r15  
    3939        PluginLoader::PluginLoader() : IResourceLoader("PluginLoader") 
    4040        { 
    41                 initialize(); 
     41                initializeResourceLoader(); 
    4242                 
    4343                // register some new functions by the scripting engine 
     
    5555         
    5656        //---------------------------------------------------------------------------------- 
    57         Result PluginLoader::initialize(){ 
     57        Result PluginLoader::initializeResourceLoader(){ 
    5858 
    5959                // fill out supported resource types; 
     
    7373                 
    7474        //---------------------------------------------------------------------------------- 
    75         Result PluginLoader::loadImpl(IResource* res, const std::string& fileName, PropertyList* param) 
     75        Result PluginLoader::loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param) 
    7676        { 
    7777 
     
    121121         
    122122        //---------------------------------------------------------------------------------- 
    123         Result PluginLoader::unloadImpl(IResource* resource) 
     123        Result PluginLoader::unloadResourceImpl(IResource* resource) 
    124124        { 
    125125 
     
    148148         
    149149        //---------------------------------------------------------------------------------- 
    150         IResource* PluginLoader::createImpl(const std::string& resourceType, PropertyList* params) 
     150        IResource* PluginLoader::createResourceImpl(const std::string& resourceType, PropertyList* params) 
    151151        {        
    152152                // create an plugin instance 
     
    156156         
    157157        //---------------------------------------------------------------------------------- 
    158         IResource* PluginLoader::createEmpty(const std::string& resourceType) 
     158        IResource* PluginLoader::createEmptyResource(const std::string& resourceType) 
    159159        { 
    160160                // create an instance of empty plugin 
  • nrEngine/src/Resource.cpp

    r1 r15  
    2929                mResIsEmpty = false; 
    3030                mResDataSize = sizeof(*this); 
    31                 mResLoader = NULL; 
     31                //mResLoader = NULL; 
    3232                setResourceType(resType); 
    3333        } 
     
    3737        { 
    3838                // check for valid loader 
    39                 if (mResLoader != NULL) 
     39                /*if (mResLoader != NULL) 
    4040                { 
    4141                        // notify the parent loader, that the resource object will be removed now 
    42                         mResLoader->unload(this); 
    43                         mResLoader->notifyRemoveResource(this); 
    44                 } 
     42                        mResLoader->remove(this); 
     43                }*/ 
     44                 
     45                // notify the manager, that this resource was  
    4546        } 
    4647 
     
    4849        Result IResource::unloadRes() 
    4950        { 
    50                 if (mResLoader) mResLoader->notifyUnloadResource(this); 
     51                //if (mResLoader) mResLoader->notifyUnloadResource(this); 
    5152                return OK; 
    5253        } 
    5354 
    54          
    5555        //---------------------------------------------------------------------------------- 
    5656        Result IResource::unloadResThroughLoader() 
     
    6363                        NR_EXCEPT(RES_LOADER_NOT_EXISTS, msg, "IResource::~IResource()"); 
    6464                } 
    65                 return mResLoader->unload(this); 
     65                return mResLoader->unload(getSharedPtrFromThis()); 
    6666        } 
    6767 
     
    7676                        NR_EXCEPT(RES_LOADER_NOT_EXISTS, msg, "IResource::~IResource()"); 
    7777                } 
    78                 return mResLoader->reload(this); 
     78                return mResLoader->reload(getSharedPtrFromThis()); 
    7979        } 
    8080 
     
    8989                        NR_EXCEPT(RES_LOADER_NOT_EXISTS, msg, "IResource::~IResource()"); 
    9090                } 
    91                 return mResLoader->remove(this); 
     91                return mResLoader->remove(getSharedPtrFromThis()); 
    9292        } 
    93  
    9493}; 
    9594 
  • nrEngine/src/ResourceLoader.cpp

    r1 r15  
    3333        { 
    3434                // copy the list in another list, so we can iterate and remove them 
    35                 std::vector<IResource*> lst; 
    36                 for (std::list<IResource*>::iterator it = mHandledResources.begin(); it != mHandledResources.end(); it ++) 
     35                std::vector<SharedPtr<IResource> > lst; 
     36                for (ResourceList::iterator it = mHandledResources.begin(); it != mHandledResources.end(); it ++) 
    3737                        lst.push_back(*it); 
    3838 
     
    4343 
    4444        //---------------------------------------------------------------------------------- 
    45         IResource* IResourceLoader::load(const std::string& name, const std::string& group, const std::string& fileName, const std::string& resourceType, PropertyList* param) 
     45        SharedPtr<IResource> IResourceLoader::load(const std::string& name, const std::string& group, const std::string& fileName, const std::string& resourceType, PropertyList* param) 
    4646        { 
    4747                // check if a such resource already registered by the manager 
     
    4949                { 
    5050                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourceLoader: You are trying to load resource %s which is already loaded.", name.c_str()); 
    51                         return NULL; 
     51                        return SharedPtr<IResource>(); 
    5252                } 
    5353                 
     
    7272                        { 
    7373                                NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourceLoader \"%s\" can not load file of type \".%s\", because the type is not supported", mName.c_str(), type.c_str()); 
    74                                 return NULL; 
     74                                return SharedPtr<IResource>(); 
    7575                        } 
    7676 
     
    7878                        if (!typeFound){ 
    7979                                NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourceLoader %s neither resource type nor valid file ending was found, give up!", mName.c_str()); 
    80                                 return NULL; 
     80                                return SharedPtr<IResource>(); 
    8181                        } 
    8282                } 
    8383                 
    8484                // ok the name is supported, so now create a instance 
    85                 IResource* res = NULL; 
     85                SharedPtr<IResource> res; 
    8686                if (resourceType.length() == 0){ 
    8787                        res = create(mapFileTypeToResourceType(type), param); 
     
    8989                        res = create(resourceType, param); 
    9090                } 
    91                 if (res == NULL) return NULL; 
     91                if (res.get() == NULL) return res; 
    9292                 
    9393                // setup some data on resource 
     
    9797 
    9898                // now call the implemented loading function 
    99                 if (loadImpl(res, fileName, param) != OK) 
     99                if (loadResourceImpl(res.get(), fileName, param) != OK) 
    100100                { 
    101101                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourceLoader %s can not load resource from file %s", mName.c_str(), fileName.c_str()); 
    102102                        remove(res); 
    103                         return NULL; 
     103                        return SharedPtr<IResource>(); 
    104104                } 
    105105                res->mResIsLoaded = true; 
    106106 
    107107                // now notify the resource manager, that a new resource was loaded 
    108                 Engine::sResourceManager()->notifyLoaded(res); 
     108                Engine::sResourceManager()->notifyLoaded(res.get()); 
    109109 
    110110                return res; 
     
    112112 
    113113        //---------------------------------------------------------------------------------- 
    114         IResource* IResourceLoader::create(const std::string& resourceType, PropertyList* params) 
     114        SharedPtr<IResource> IResourceLoader::create(const std::string& resourceType, PropertyList* params) 
    115115        { 
    116116                NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "ResourceLoader: Create resource of type %s", resourceType.c_str()); 
     
    120120                { 
    121121                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourceLoader %s does not support resources of type %s", mName.c_str(), resourceType.c_str()); 
    122                         return NULL; 
     122                        return SharedPtr<IResource>(); 
    123123                } 
    124124 
    125125                // now call the implemented function to create the resource 
    126                 IResource* res = (createImpl(resourceType, params)); 
     126                SharedPtr<IResource> res (createResourceImpl(resourceType, params), IResource::_deleter()); 
    127127 
    128128                // check if the result is valid, then add it into our database 
    129                 if (res == NULL) return NULL; 
     129                if (res.get() == NULL) return SharedPtr<IResource>(); 
    130130 
    131131                // now check if we have to create an empty resource for this type 
     
    134134                // if not created before, so create it and register by the manager 
    135135                if (empty == NULL){ 
    136                         empty.reset( createEmpty(resourceType) ); 
     136                        empty.reset( createEmptyResource(resourceType), IResource::_deleter() ); 
    137137                        empty->mResGroup = "_Empty_Resource_Group_"; 
    138138                        empty->mResName = "_Empty_" + resourceType; 
    139139                        empty->mResHandle = Engine::sResourceManager()->getNewHandle(); 
    140                         empty->mResLoader = this; 
    141140                        empty->mResIsEmpty = true; 
     141                        empty->mResLoader = getSharedPtrFromThis(); 
    142142                        empty->setResourceType(resourceType); 
    143143                } 
     
    149149                res->setResourceType(resourceType); 
    150150                res->mResHandle = Engine::sResourceManager()->getNewHandle(); 
    151                 res->mResLoader = this; 
    152151                res->mResIsEmpty = false; 
    153  
     152                res->mResLoader = getSharedPtrFromThis(); 
     153                 
    154154                // now set this resource in the list of handled resource objects 
    155155                mHandledResources.push_back(res); 
     
    160160 
    161161        //---------------------------------------------------------------------------------- 
    162         IResource* IResourceLoader::create(const std::string& name, const std::string& group, const std::string& resourceType, PropertyList* params) 
     162        SharedPtr<IResource> IResourceLoader::create(const std::string& name, const std::string& group, const std::string& resourceType, PropertyList* params) 
    163163        { 
    164164                // first check if this type of resource is supported 
     
    166166                { 
    167167                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourceLoader %s does not support resources of type %s", mName.c_str(), resourceType.c_str()); 
    168                         return NULL; 
     168                        return SharedPtr<IResource>(); 
    169169                } 
    170170 
     
    173173                if (!res.isNull()){ 
    174174                        NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "You are trying to create a resource %s of type %s which is already in the database", name.c_str(), resourceType.c_str()); 
    175                         return NULL; 
     175                        return SharedPtr<IResource>(); 
    176176                } 
    177177 
    178178                // ok now create the resource 
    179                 IResource* r = create(resourceType, params); 
    180                 if (r == NULL) return NULL; 
     179                SharedPtr<IResource> r = create(resourceType, params); 
     180                if (r.get() == NULL) return SharedPtr<IResource>(); 
    181181 
    182182                // setup values 
     
    185185                 
    186186                // now let manager know about the new resource 
    187                 Engine::sResourceManager()->notifyCreated(r); 
     187                Engine::sResourceManager()->notifyCreated(r.get()); 
    188188 
    189189                return r; 
     
    191191 
    192192        //---------------------------------------------------------------------------------- 
    193         Result IResourceLoader::unload(IResource* resource) 
     193        Result IResourceLoader::unload(SharedPtr<IResource> resource) 
    194194        { 
    195195                // empty resource could not be unloaded 
    196                 if (resource == NULL) return OK; 
     196                if (resource.get() == NULL) return OK; 
    197197 
    198198                // call the implementation of the unloader 
    199199                if (resource->mResIsLoaded){ 
    200200                         
    201                         Result ret = unloadImpl(resource); 
     201                        Result ret = unloadResourceImpl(resource.get()); 
    202202                        if (ret != OK) return ret; 
    203203                 
     
    206206                         
    207207                        // notify the resource manager about unloading the resource 
    208                         Engine::sResourceManager()->notifyUnloaded(resource); 
     208                        Engine::sResourceManager()->notifyUnloaded(resource.get()); 
    209209                } 
    210210                 
     
    213213 
    214214        //---------------------------------------------------------------------------------- 
    215         Result IResourceLoader::reload(IResource* resource) 
     215        Result IResourceLoader::reload(SharedPtr<IResource> resource) 
    216216        { 
    217217                // check if we are the handler for this resource 
     
    225225 
    226226                // now reload the resource and go back 
    227                 return reloadImpl(resource); 
    228         } 
    229  
    230         //---------------------------------------------------------------------------------- 
    231         Result IResourceLoader::remove(IResource* resource) 
     227                return reloadResourceImpl(resource.get()); 
     228        } 
     229 
     230        //---------------------------------------------------------------------------------- 
     231        Result IResourceLoader::remove(SharedPtr<IResource> resource) 
    232232        { 
    233233                // remove only valid resources 
    234                 if (resource == NULL) return OK; 
     234                if (resource.get() == NULL) return OK; 
    235235 
    236236                // emove only handled resources 
    237                 if (std::find(mHandledResources.begin(), mHandledResources.end(), resource) == mHandledResources.end()){ 
     237                if (std::find(mHandledResources.begin(), mHandledResources.end(), resource) == mHandledResources.end()) 
     238                { 
    238239                        NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "ResourceLoader: You are trying to remove resource %s not handled by this loader %s!", resource->getResName().c_str(), mName.c_str()); 
    239240                        return OK; 
     
    246247                notifyRemoveResource(resource); 
    247248 
    248                 // delete the resource object, so it get's removed 
    249                 delete resource; 
     249                // reset the resource, so it gets deleted, if it is not referenced elsewhere 
     250                resource.reset(); 
    250251 
    251252                return OK; 
     
    253254 
    254255        //---------------------------------------------------------------------------------- 
    255         void IResourceLoader::notifyRemoveResource(IResource* res) 
    256         { 
     256        void IResourceLoader::notifyRemoveResource(SharedPtr<IResource> res) 
     257        { 
     258                ResourceList::iterator resit = std::find(mHandledResources.begin(), mHandledResources.end(), res); 
     259                 
    257260                // check if such resource is loaded 
    258                 if (std::find(mHandledResources.begin(), mHandledResources.end(), res) != mHandledResources.end() ){ 
     261                if (resit != mHandledResources.end() ){ 
     262                 
    259263                        // ok remove the resource from the handled resources 
    260                         mHandledResources.erase(std::find(mHandledResources.begin(), mHandledResources.end(), res)); 
     264                        mHandledResources.erase(resit); 
    261265 
    262266                        // notify the manager about removing the resource 
    263                         Engine::sResourceManager()->notifyRemove(res); 
    264                 } 
    265         } 
    266  
    267         //---------------------------------------------------------------------------------- 
    268         void IResourceLoader::notifyUnloadResource(IResource* res) 
     267                        Engine::sResourceManager()->notifyRemove(res.get()); 
     268                } 
     269        } 
     270 
     271        //---------------------------------------------------------------------------------- 
     272        void IResourceLoader::notifyUnloadResource(SharedPtr<IResource> res) 
    269273        { 
    270274                if (res == NULL) return; 
    271275                if (std::find(mHandledResources.begin(), mHandledResources.end(), res) != mHandledResources.end() && res->mResIsLoaded){ 
    272                         Engine::sResourceManager()->notifyUnloaded(res); 
    273                 } 
    274         } 
    275  
    276         //---------------------------------------------------------------------------------- 
    277         Result IResourceLoader::unloadImpl(IResource* res) 
     276                        Engine::sResourceManager()->notifyUnloaded(res.get()); 
     277                } 
     278        } 
     279 
     280        //---------------------------------------------------------------------------------- 
     281        Result IResourceLoader::unloadResourceImpl(IResource* res) 
    278282        { 
    279283                if (res == NULL) return OK; 
    280                 if (res->mResIsLoaded)  
    281                         return res->unloadRes(); 
     284                if (res->mResIsLoaded) return res->unloadRes(); 
    282285                return OK; 
    283286        } 
    284287 
    285288        //---------------------------------------------------------------------------------- 
    286         Result IResourceLoader::reloadImpl(IResource* res) 
     289        Result IResourceLoader::reloadResourceImpl(IResource* res) 
    287290        { 
    288291                if (res == NULL) return OK; 
    289                 Result ret = loadImpl(res, res->getResFileName(), NULL); 
     292                Result ret = loadResourceImpl(res, res->getResFileName(), NULL); 
    290293                if (ret != OK){ 
    291294                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourceLoader %s can not load resource from file %s", mName.c_str(), res->getResFileName().c_str()); 
  • nrEngine/src/ResourceManager.cpp

    r1 r15  
    191191 
    192192                // get id of the loader 
    193                 loader_map::const_iterator jt = mLoader.find(name); 
     193                loader_map::iterator jt = mLoader.find(name); 
    194194                if (jt == mLoader.end()){ 
    195195                        return RES_LOADER_NOT_REGISTERED; 
     
    197197 
    198198                NR_Log(Log::LOG_ENGINE, "ResourceManager: Remove loader %s", name.c_str()); 
    199  
     199                 
    200200                mLoader.erase(name); 
    201201 
     
    271271 
    272272                // now call the loader to create a resource 
    273                 IResource* res (creator->create(name, group, resourceType, params)); 
    274                 if (res == NULL){ 
     273                SharedPtr<IResource> res (creator->create(name, group, resourceType, params)); 
     274                if (res.get() == NULL){ 
    275275                        NR_Log(Log::LOG_ENGINE, "ResourceManager: Can not create a resource %s of %s type", name.c_str(), resourceType.c_str()); 
    276276                        return IResourcePtr(); 
     
    328328                // now call the loader to create a resource 
    329329                // loader will notify the manager, manager will add it into database 
    330                 IResource* res = loader->load(name, group, fileName, resourceType, params); 
     330                SharedPtr<IResource> res = loader->load(name, group, fileName, resourceType, params); 
    331331                if (res == NULL) return IResourcePtr(); 
    332332                 
     
    348348 
    349349                lockPure(res); 
    350                         NR_Log(Log::LOG_ENGINE, "ResourceManager: Unload resource %s", 
    351                                 res->getResName().c_str(), res->getResHandle()); 
     350                        NR_Log(Log::LOG_ENGINE, "ResourceManager: Unload resource %s", res->getResName().c_str(), res->getResHandle()); 
    352351                        Result ret = res->unloadResThroughLoader(); 
    353352                unlockPure(res); 
  • nrEngine/src/ScriptLoader.cpp

    r1 r15  
    2525        ScriptLoader::ScriptLoader() : IResourceLoader("ScriptLoader") 
    2626        { 
    27                 initialize(); 
     27                initializeResourceLoader(); 
    2828        } 
    2929 
     
    3636 
    3737        //---------------------------------------------------------------------------------- 
    38         Result ScriptLoader::initialize(){ 
     38        Result ScriptLoader::initializeResourceLoader(){ 
    3939                // fill out supported resource types; 
    4040                declareSupportedResourceType("Script"); 
     
    5353 
    5454        //---------------------------------------------------------------------------------- 
    55         Result ScriptLoader::loadImpl(IResource* res, const std::string& fileName, PropertyList* param) 
     55        Result ScriptLoader::loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param) 
    5656        { 
    5757                // load a file so we use its content as a script 
     
    7878 
    7979        //---------------------------------------------------------------------------------- 
    80         IResource* ScriptLoader::createImpl(const std::string& resourceType, PropertyList* params) 
     80        IResource* ScriptLoader::createResourceImpl(const std::string& resourceType, PropertyList* params) 
    8181        { 
    8282                // check if we want to create just a script 
     
    9494 
    9595        //---------------------------------------------------------------------------------- 
    96         IResource* ScriptLoader::createEmpty(const ::std::string& resourceType) 
     96        IResource* ScriptLoader::createEmptyResource(const ::std::string& resourceType) 
    9797        { 
    9898                // create an instance of empty plugin 
Note: See TracChangeset for help on using the changeset viewer.