Changeset 35 for nrEngine


Ignore:
Timestamp:
04/16/07 17:04:29 (12 years ago)
Author:
art
Message:

Big changes in resource managment system. Interface functions were renamed.
Resource loading is now done throughthe resource and not through the loader.

Location:
nrEngine
Files:
25 edited

Legend:

Unmodified
Added
Removed
  • nrEngine/include/FileStream.h

    r33 r35  
    7272                * as the name of the underlying resource used for the file storing. 
    7373                **/ 
    74                 const std::string& getName()    const { return getResName(); } 
     74                const std::string& getName()    const { return getResourceName(); } 
    7575 
    7676                /** 
     
    120120                SharedPtr< std::ifstream > mStream; 
    121121 
    122                 Result unloadRes(); 
     122                Result unloadResource(); 
     123                Result reloadResource(PropertyList* params); 
    123124        }; 
    124125 
  • nrEngine/include/FileStreamLoader.h

    r15 r35  
    5252         
    5353                        /** 
    54                         * @see IResourceLoader::loadResourceImpl() 
     54                        * @see IResourceLoader::loadResource() 
    5555                        **/ 
    56                         Result loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param = NULL); 
     56                        Result loadResource(IResource* res, const std::string& fileName, PropertyList* param = NULL); 
    5757         
    5858                        /** 
    59                         * @see IResourceLoader::createResourceImpl() 
     59                        * @see IResourceLoader::createResource() 
    6060                        **/ 
    61                         IResource* createResourceImpl(const std::string& resourceType, PropertyList* params = NULL); 
     61                        IResource* createResource(const std::string& resourceType, PropertyList* params = NULL); 
    6262                                 
    6363                        /** 
  • nrEngine/include/IScript.h

    r34 r35  
    272272                         * class can overload them 
    273273                         **/ 
    274                         virtual Result unloadRes() {return OK;} 
     274                        virtual Result unloadResource() {return OK;} 
     275                        virtual Result reloadResource(PropertyList* params) {return OK;} 
    275276 
    276277                        //! Check if script should only run once 
     
    309310 
    310311                        typedef std::map<std::string, ArgumentList>             ArgumentDatabase; 
    311  
    312                         //! Notify if the resource was reloaded 
    313                         void notifyResReloaded(); 
    314312 
    315313                        //! Here we store the arguments for the script 
  • nrEngine/include/ITask.h

    r30 r35  
    252252                * Log-Files in simple way. 
    253253                **/ 
    254                 const char* getTaskName(){ return _taskName; } 
     254                const char* getTaskName(){ return _taskName.c_str(); } 
    255255 
    256256                /** 
     
    343343                 
    344344                bool            _orderChanged; 
    345                 char            _taskName[64]; 
     345                std::string     _taskName; 
    346346 
    347347                //! Used by the kernel 
  • nrEngine/include/Plugin.h

    r30 r35  
    212212                 * Derived function from IResource 
    213213                 **/ 
    214                 Result unloadRes(); 
    215                  
    216                                          
     214                virtual Result unloadResource(); 
     215                virtual Result reloadResource(PropertyList* params);                                     
     216 
     217                //! Get last plugin error message from the system 
     218                std::string getLastPluginError(); 
    217219 
    218220        }; 
     
    237239                 
    238240                //! Unload the empty resource 
    239                 Result unloadRes(); 
    240                  
     241                Result unloadResource(); 
     242                 
     243                //! Reload the empty resource 
     244                Result reloadResource(); 
    241245                 
    242246                //! Return always NULL 
  • nrEngine/include/PluginLoader.h

    r32 r35  
    6565                ~PluginLoader(); 
    6666 
    67                  
    6867        private: 
    6968         
     
    7574 
    7675                /** 
    77                  * @see IResourceLoader::loadImpl() 
     76                 * @see IResourceLoader::loadResource() 
    7877                 **/ 
    79                 Result loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param = NULL); 
     78                Result loadResource(IResource* res, const std::string& fileName, PropertyList* param = NULL); 
    8079 
    8180                /** 
    82                  * @see IResourceLoader::createImpl() 
     81                 * @see IResourceLoader::createResource() 
    8382                 **/ 
    84                 IResource* createResourceImpl(const std::string& resourceType, PropertyList* params = NULL); 
     83                IResource* createResource(const std::string& resourceType, PropertyList* params = NULL); 
    8584                         
    8685                /** 
    87                  * @see IResourceLoader::createEmpty() 
     86                 * @see IResourceLoader::createEmptyResource() 
    8887                 **/ 
    8988                IResource* createEmptyResource(const std::string& resourceType); 
    9089 
    91                 /** 
    92                  * Unload the given plugin resource 
    93                  **/ 
    94                 Result unloadResourceImpl(IResource*); 
    95  
    96                 /** 
    97                  * Returns the last error of the dynamic library 
    98                  **/ 
    99                 std::string getLastPluginError(); 
    100                  
    10190                /** 
    10291                 * @see IResourceLoader::getSuffix() 
  • nrEngine/include/Resource.h

    r32 r35  
    5353 
    5454                /** 
    55                 * Here the class should return cound of bytes reserved 
     55                * Here the class should return count of bytes reserved 
    5656                * by the resource. The size must not contain the size of the class itself. 
    5757                * For example: 32Bit Texture of 16x16 Pixel has the size: 16*16*4 = 1024 Bytes + 
    5858                * some more bytes which does class need to store himself in the memory. 
    5959                **/ 
    60                 NR_FORCEINLINE std::size_t getResDataSize(){return mResDataSize;} 
     60                NR_FORCEINLINE std::size_t getResourceDataSize(){return mResDataSize;} 
    6161 
    6262 
     
    6666                * E.g: "Texture", "Sound",  ... 
    6767                **/ 
    68                 NR_FORCEINLINE const std::string& getResType() const { return mResType; } 
     68                NR_FORCEINLINE const std::string& getResourceType() const { return mResType; } 
    6969 
    7070 
     
    7373                * so it contains in the memory and has it's full data there. 
    7474                **/ 
    75                 NR_FORCEINLINE bool                     isResLoaded() const {return mResIsLoaded;} 
     75                NR_FORCEINLINE bool                     isResourceLoaded() const {return mResIsLoaded;} 
    7676 
    7777                /** 
    7878                * Return handle of this resource 
    7979                **/ 
    80                 NR_FORCEINLINE ResourceHandle           getResHandle() const {return mResHandle;} 
     80                NR_FORCEINLINE ResourceHandle           getResourceHandle() const {return mResHandle;} 
    8181 
    8282                /** 
    8383                * Return group name to which one this resource belongs 
    8484                **/ 
    85                 NR_FORCEINLINE const std::string&       getResGroup() const {return mResGroup;} 
     85                NR_FORCEINLINE const std::string&       getResourceGroup() const {return mResGroup;} 
    8686 
    8787                /** 
    8888                * Get the name of the resource 
    8989                **/ 
    90                 NR_FORCEINLINE const std::string&       getResName() const {return mResName;} 
     90                NR_FORCEINLINE const std::string&       getResourceName() const {return mResName;} 
    9191 
    9292                /** 
    9393                * Get the file name from which one this resource can be restored or loaded 
    9494                **/ 
    95                 NR_FORCEINLINE const std::list<std::string>&    getResFilenameList() const {return mResFileNames;} 
     95                NR_FORCEINLINE const std::list<std::string>&    getResourceFilenameList() const {return mResFileNames;} 
    9696 
    9797                /** 
     
    9999                * to replace normal resources if they are unloaded. 
    100100                **/ 
    101                 NR_FORCEINLINE bool                             isResEmpty()    {return mResIsEmpty;} 
    102  
    103         protected: 
    104                  
    105                 /** 
    106                  * Create resource instance. 
    107                  **/ 
    108                 IResource(const std::string& resourceType); 
    109  
    110  
    111                 /** 
    112                  * As soon as this destructor is called, the according loader will be 
    113                  * notified about removing the resource from the memory. So the loader 
    114                  * will correct it's database and notify also the ResourceManager about this 
    115                  * event. 
    116                  * 
    117                  * You have to call the unloadRes() method if you have some specific unloading 
    118                  * routines for your resource object. We can not call this from here, because 
    119                  * calling of virtual functions from constructor/destructor cause in 
    120                  * undefined behaviour. However we call the appropriate resource loader 
    121                  * to notify him that this resource is getting unloaded now. 
    122                  **/ 
    123                 virtual ~IResource(); 
    124  
    125                 /** 
    126                  * Unload the resource. Each resource should know how to unload it from 
    127                  * the memory. Unloading does not remove the resource it just unload used 
    128                  * data from memory. To remove the resource from memory you have either 
    129                  * to use ResourceManager or the ResourceLoader. 
    130                  * 
    131                  * Do here resource specific stuff. The method will be called by the loader, 
    132                  * so you do not have to notify the loader about this event. 
    133                  **/ 
    134                 virtual Result unloadRes(); 
    135  
    136                 /** 
    137                  * Reload resource. Each resource object should be able to reload itself 
    138                  * from the disk or other media. It can use the assigned loader to load files 
    139                  * or to make it by itself. At the end the resource should be marked as loaded. 
    140                  * 
    141                  * Do here resource specific stuff. The method will be called by the loader, 
    142                  * so you do not have to notify the loader about this event. 
    143                  **/ 
    144                 virtual Result reloadRes(); 
    145                  
    146                 /** 
    147                  * Loader will notify the resource that it has been restored. 
    148                  * A resource is restored if it was reloaded by the manager or 
    149                  * loader. The loader will restore the data in the way like it 
    150                  * has done when loading the resource. After that the loader will 
    151                  * notify the resource that it has been restored, so resource has 
    152                  * to do some initialization on this data if needed. 
    153                  * 
    154                  * The default behaviour on this function is just not to do anything. 
    155                  * So overload this method with your own, if you need any specific behaviour 
    156                  * on the restored data. 
    157                  **/ 
    158                 //virtual void notifyResReloaded() { } 
    159                  
    160                 /** 
    161                  * Mark a resource as loaded. This method will not call the reloadRes() 
    162                  * method. Instead it will just mark this resource as it were loaded, 
    163                  * so you get access to real resource object through the pointers instead 
    164                  * of emtpy resource. Call this method if you create a resource by your 
    165                  * own without loading by loader. 
    166                  **/ 
    167                 NR_FORCEINLINE void markResLoaded() { mResIsLoaded = true; } 
    168                  
     101                NR_FORCEINLINE bool isResourceEmpty()   {return mResIsEmpty;} 
     102 
     103                /** 
     104                * Unload resource. The resource should overwrite the IResource::unloadResource() method 
     105                * which will be called. The resource should know how to unload itself. 
     106                * The resource owner (in this case loader) will be notified about unloading on success. 
     107                **/ 
     108                Result unload(); 
     109 
     110                /** 
     111                * Reload resource if this was previously unloaded. Each resource should overwrite 
     112                * IResource::reloadResource() method. Resource should know how to reload 
     113                * itself if it was previously unloaded. Resource owner (in this case loader) will be notified 
     114                * on success. 
     115                * @note If resource was not unloaded before, so the IResource::unload() method 
     116                * will be called before reloading. 
     117                **/ 
     118                Result reload(PropertyList* params = NULL); 
     119 
     120                /** 
     121                * Remove resource. Removing resource through this method, meanse to 
     122                * remove the resource from the loader and from the manager. After this method call 
     123                * all resource pointers associated within this resource will point to the empty 
     124                * resource. All shared instaces would also be removed. 
     125                * 
     126                * If you call this method through resource pointer, then nothing bad happens. If 
     127                * you call it directly (i.e. YourResource* res; res->remove()), hten you are 
     128                * responsible for deleting the pointer by yourself 
     129                **/ 
     130                Result remove(); 
     131 
    169132                /** 
    170133                 * Add resource file name. The filename is used to associated the resource with. 
    171134                 * If a resource is build upon of a multiple files, then all the files should 
    172135                 * be added through this method. 
    173                  * @param filename Filename of a file associated with the resource  
     136                 * @param filename Filename of a file associated with the resource 
    174137                 **/ 
    175138                 void addResourceFilename(const std::string& filename); 
     
    180143                  **/ 
    181144                 void addResourceFilename(const std::list<std::string>& flist); 
     145 
     146                /** 
     147                 * Set resource file name list. This method will replace the current 
     148                 * filename list with the given one. 
     149                 * @param flist List of filenames 
     150                 **/ 
     151                void setResourceFilename(const std::list<std::string>& flist); 
     152 
     153        protected: 
     154                 
     155                /** 
     156                 * Create resource instance. 
     157                 **/ 
     158                IResource(const std::string& resourceType); 
     159 
     160                /** 
     161                 * As soon as this destructor is called, the resource manager will be notified. 
     162                 * 
     163                 * You have to call the unloadResource() method if you have some specific unloading 
     164                 * routines for your resource object. We can not call this from here, because 
     165                 * calling of virtual functions from constructor/destructor cause in 
     166                 * undefined behaviour. 
     167                 **/ 
     168                virtual ~IResource(); 
     169 
     170                /** 
     171                 * Unload the resource. Each resource should know how to unload it from 
     172                 * the memory. Unloading does not remove the resource it just unload used 
     173                 * data from memory. To remove the resource from memory you have either 
     174                 * to use ResourceManager or the ResourceLoader. 
     175                 * 
     176                 **/ 
     177                virtual Result unloadResource() = 0; 
     178 
     179                /** 
     180                 * Reload resource. Each resource object should be able to reload itself 
     181                 * from the disk or other media. It can use the assigned loader to load files 
     182                 * or to make it by itself. At the end the resource should be marked as loaded. 
     183                 * 
     184                 **/ 
     185                virtual Result reloadResource(PropertyList* params = NULL) = 0; 
     186                 
     187                 
     188                /** 
     189                 * Mark a resource as loaded. This method will not call the reloadResource() 
     190                 * method. Instead it will just mark this resource as it were loaded, 
     191                 * so you get access to real resource object through the pointers instead 
     192                 * of emtpy resource. Call this method if you create a resource by your 
     193                 * own without loading by loader. 
     194                 **/ 
     195                NR_FORCEINLINE void markResourceLoaded() { mResIsLoaded = true; } 
     196                 
     197                /** 
     198                 * Mark the resource as unloaded. When you mark it, then empty resource 
     199                 * will be used instead. 
     200                 **/ 
     201                NR_FORCEINLINE void markResourceUnloaded() { mResIsLoaded = false; } 
     202                 
     203                 //! Get resource loader assigned with the resource 
     204                 NR_FORCEINLINE SharedPtr<IResourceLoader> getResourceLoader() { return mResLoader; } 
    182205                  
    183206        private: 
     
    224247                NR_FORCEINLINE void     setResourceType(const std::string& type) { mResType = type; } 
    225248 
     249#if 0 
    226250                /** 
    227251                 * If the unloading of resource is done through the resource manager, 
     
    239263                 **/ 
    240264                Result removeResThroughLoader(); 
    241  
     265#endif 
    242266                /** 
    243267                * Get shared pointer from this class 
     
    247271                        return shared_from_this(); 
    248272                } 
    249                  
     273 
    250274                class _deleter{ 
    251275                public: 
  • nrEngine/include/ResourceHolder.h

    r34 r35  
    102102                        * @note If the lock stack is full you are not able lock anymore 
    103103                        **/ 
    104                         bool lockPure(); 
     104                        bool lockResource(); 
    105105                         
    106106                        /** 
     
    113113                        *               do not affect anything. 
    114114                        **/ 
    115                         void unlockPure(); 
     115                        void unlockResource(); 
    116116                         
    117117                        /** 
     
    134134                        * Reset the stored resource to a new value 
    135135                        **/ 
    136                         void resetRes(IResource* res); 
     136                        void resetResource(IResource* res); 
    137137                 
    138138                        /** 
  • nrEngine/include/ResourceLoader.h

    r33 r35  
    2626 
    2727         
    28         //! Resource loader interface for loading different resources 
     28        //! Interface for loading/creating resources 
    2929        /** 
    3030        * This is an interface which has to be implemented by each resource loader. 
     
    3636        * image loading functions for different types. 
    3737        * 
    38         * Resource loader can be registered by the resource manager. After it is 
     38        * Resource loader should be registered by the resource manager. After it is 
    3939        * registered it will be automaticly used to load files of different types. 
    4040        * If there is no loader registered for that type, so file will not be loaded, 
     
    4646        * and with the empty resource. 
    4747        * 
    48         * If you have files that are also resources but are not supported by the nrEngine 
    49         * you can derive a loader class from this interface. Then register the object, 
    50         * created from this derived class, by the resource manager and this class will 
    51         * automaticly used for such kind of resources. This is something like a plugin 
    52         * system on compiling layer/level. 
    53         * 
    54         * The resource loader has also to support creating of resource instances. 
    55         * Because we are using only one resource manager for any 
    56         * kind of resources, we have somewhere to create the instance with 
    57         * <code>IResource* res = new Resource()</code>. We can not use templates 
    58         * in the resource manager, because nothing will be compiled into the finale 
    59         * library file. So you will not be able to use new resource types. 
    60         * This loader also helps us to solve this problem by creating an instance of 
    61         * such a resource object for our resource database. 
    62         * 
    63         * Each loader has a method which says to the manager what kind of resource types  
     48        * Each loader has a method which says to the manager what kind of resource types 
    6449        * it supports. By creating of a resource, you should specify the type of to be  
    6550        * created resource. Manager will look in the database, wich loader can create an instance 
     
    7257        * which does own own memory. 
    7358        *  
    74         * @note File types are case sensitive. So *.png and *.PNG are different file types. 
     59        * @note File types and resource types are case sensitive. So *.png and *.PNG are different file types. 
    7560        * 
    7661        * \ingroup resource 
     
    9984                        **/ 
    10085                        SharedPtr<IResource> load(const std::string& name, const std::string& group, const std::string& fileName, const std::string& resourceType = std::string(), PropertyList* param = NULL); 
    101                                          
     86 
    10287                        /** 
    10388                         * Create an instance of appropriate resource object. Like <code>new ResourceType()</code> 
    10489                         * 
     90                         * @param name Unique name of the resource 
     91                         * @param group Unique group name for the resource 
    10592                         * @param resourceType Unique name of the resource type to be created 
    10693                         * @param params Default is NULL, so no parameters. Specify here pairs of string that 
     
    11299                         * object will be created of this type. This will be automaticaly registered by the manager. 
    113100                         **/ 
    114                         SharedPtr<IResource> create(const std::string& resourceType, PropertyList* params = NULL); 
    115  
    116                         /** 
    117                          * Same as create() but here you can specify the name of the resource. If 
    118                          * the name is specified, so the resource will be automaticaly registered 
    119                          * by the resource manager. Also loader will check if such a resource 
    120                          * already exists. 
    121                          **/ 
    122101                        SharedPtr<IResource> create(const std::string& name, const std::string& group, const std::string& resourceType, PropertyList* params = NULL); 
    123102 
     
    153132                        bool supportFileType(const std::string& fileType) const ; 
    154133 
     134#if 0 
    155135                        /** 
    156136                         * Unload the given resource. Unloading of a resource does not mean that the 
     
    165145 
    166146                        /** 
    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                         /** 
    174147                         * Reload a certain resource again. A resource object has to be created before. 
    175148                         * If the resource object is loaded, so it will be unloaded and loaded again. Also 
     
    178151                         **/ 
    179152                        Result reload(SharedPtr<IResource> resource); 
    180  
     153#endif 
     154                        /** 
     155                         * Remove the resource from the memory. This method will be called 
     156                         * by the resource manager, so the loader can do the stuff needed 
     157                         * to remove the resource. 
     158                         **/ 
     159                        Result remove(SharedPtr<IResource> resource); 
    181160 
    182161                protected: 
    183  
     162#if 0 
    184163                        /** 
    185164                         * Unload a certain resource from the memory. 
     
    205184                         **/ 
    206185                        virtual Result reloadResourceImpl(IResource* res); 
    207                          
     186#endif                   
    208187                        /** 
    209188                         * Derived classes must overload this function. This method 
     
    214193                         * @param param Specific parameters specified by the user 
    215194                         **/ 
    216                         virtual Result loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param = NULL) = 0; 
     195                        virtual Result loadResource(IResource* res, const std::string& fileName, PropertyList* param = NULL) = 0; 
    217196 
    218197                        /** 
     
    222201                         * method can only be called from the base class, which does already 
    223202                         * have checked this. 
    224                          *  
    225                          **/ 
    226                         virtual IResource* createResourceImpl(const std::string& resourceType, PropertyList* params = NULL) = 0; 
     203                         * @param resourceType Type of the resource 
     204                         * @param params Parameter list which can be passed for creating 
     205                         **/ 
     206                        virtual IResource* createResource(const std::string& resourceType, PropertyList* params = NULL) = 0; 
    227207                         
    228208                        /** 
     
    245225                         
    246226                        /** 
    247                          *  
     227                         * Create instance of the resource loader. 
     228                         * @param name Unique name of the loader 
    248229                         **/ 
    249230                        IResourceLoader(const std::string& name); 
     
    294275                        } 
    295276                         
     277#if 0 
    296278                        /** 
    297279                         * This method will return back a proper suffix according to the resource type. 
     
    301283                         **/ 
    302284                        virtual std::string getSuffix(const std::string& resType){return std::string();} 
    303                          
     285#endif 
     286                        /** 
     287                         * Notify the resource loader that a certain resource object 
     288                         * will be now removed from the memory. The method should be called, 
     289                         * by the resource manager, to notify the loader. 
     290                         **/ 
     291                        void notifyRemoveResource(SharedPtr<IResource>); 
     292 
     293#if 0 
     294                        /** 
     295                        * Resource will notify the loader that it has been reloaded through 
     296                        * this method. Resource loader should 
     297                         **/ 
     298                        void notifyUnloadResource(SharedPtr<IResource>); 
     299#endif 
    304300 
    305301                private: 
     302 
     303                        //! Resource manager can access the methods here 
     304                        friend class ResourceManager; 
    306305                         
    307306                        //! List of supported resource types 
     
    321320                        //! List of resources managed by this loader 
    322321                        ResourceList mHandledResources; 
     322 
     323                                         
     324                        /** 
     325                         * Create an instance of appropriate resource object.  
     326                         **/ 
     327                        SharedPtr<IResource> create(const std::string& resourceType, PropertyList* params = NULL); 
    323328 
    324329                        /** 
     
    330335                        } 
    331336 
    332                         /** 
    333                          * Notify the resource loader that a certain resource object 
    334                          * will be removed from the memory now. 
    335                          **/ 
    336                         void notifyRemoveResource(SharedPtr<IResource>); 
    337  
     337#if 0 
    338338                        /** 
    339339                         * Notify unload resource. The method can be called either 
     
    341341                         **/ 
    342342                        void notifyUnloadResource(SharedPtr<IResource>); 
    343                          
     343#endif 
    344344        }; 
    345345 
  • nrEngine/include/ResourceManager.h

    r34 r35  
    4242        * working without using a whole library behind. 
    4343        * 
    44         * The member functions createEmptyResource(), loadResource() are build by templates 
    45         * that allows us to create new kind of resource by storing it under standrd nrIResourcePtr. 
    46         * For example if you have a class A derived from nrCResource and this class is don't known 
    47         * by our engine, so you can just load the resource object of this class by calling: 
    48         * <code>nrResource.loadResource<A>(...)</code>. This allows us to create/load resources 
    49         * of specified types and not just to create standard nrCResource object which do not always 
    50         * can be casted to derived objects. 
    5144        * 
    5245        * <b>-</b> Meaning of resource groups: 
     
    232225                        Result          add(IResource* res, const std::string& name, const std::string& group = ""); 
    233226#endif 
    234          
     227 
    235228                        /** 
    236229                        * This method is used to lock the resource with the given name for using. 
     
    250243                        * Affect to empty resource, because the resource is unloaded.<br> 
    251244                        * <code> 
    252                         *       ResourceMgr.lockPure("resource");<br> 
     245                        *       ResourceMgr.lockResource("resource");<br> 
    253246                        *       resource->setPropertyOne(...);<br> 
    254                         *       ResourceMgr.unlockPure("resource");<br> 
     247                        *       ResourceMgr.unlockResource("resource");<br> 
    255248                        * </code> 
    256249                        * Affect to the resource you probably means. You will set the property of the real 
     
    265258                        *       - ReadOnly by textures : getting of a ID, drawing, ... 
    266259                        *       - Write by texture: set new size, get name (it has also to be locked, because empty texture will return 
    267                         *               a name acoording to empty texture), load, ... 
    268                         **/ 
    269                         virtual Result          lockPure(const std::string& name); 
     260                        *               a name according to empty texture), load, ... 
     261                        **/ 
     262                        virtual Result          lockResource(const std::string& name); 
    270263         
    271264                        /** 
     
    273266                        * @param res Pointer to the resource 
    274267                        **/ 
    275                         virtual Result          lockPure(IResourcePtr& res); 
     268                        virtual Result          lockResource(IResourcePtr& res); 
    276269         
    277270                        /** 
     
    279272                        * @param handle Unique handle of the resource 
    280273                        **/ 
    281                         virtual Result          lockPure(ResourceHandle& handle); 
    282          
    283                         /** 
    284                         * This function is complement to the lockPure(...) methods. This will unlock the 
     274                        virtual Result          lockResource(ResourceHandle& handle); 
     275         
     276                        /** 
     277                        * This function is complement to the lockResource(...) methods. This will unlock the 
    285278                        * real resource from using 
    286279                        * @param name Unique name of the resource to be unlocked 
    287280                        **/ 
    288                         virtual Result          unlockPure(const std::string& name); 
     281                        virtual Result          unlockResource(const std::string& name); 
    289282         
    290283                        /** 
     
    292285                        * @param res Pointer to the resource 
    293286                        **/ 
    294                         virtual Result          unlockPure(IResourcePtr& res); 
     287                        virtual Result          unlockResource(IResourcePtr& res); 
    295288         
    296289                        /** 
     
    298291                        * @param handle Unique handle of the resource 
    299292                        **/ 
    300                         virtual Result          unlockPure(ResourceHandle& handle); 
    301          
    302          
     293                        virtual Result          unlockResource(ResourceHandle& handle); 
     294 
    303295                        /** 
    304296                        * Unload the resource from the memory. 
    305                         * The registered resource loader will be used to unload the 
    306                         * resource. After this call all the resource pointers 
     297                        * After this call all the resource pointers assigned within the resource 
    307298                        * will point to an empty resource. 
    308299                        * 
     
    329320                        * @return either OK or error code: 
    330321                        *               - RES_NOT_FOUND 
    331                         * 
    332                         * @note Reloading of resource will cost time. The resource will 
    333                         *                try to access to it's file through the loader with which 
    334                         *                one it was created. So try to implement very intellegent 
    335                         *                algorithm to prevent reloading/unloading as much as possible 
    336322                        **/ 
    337323                        Result          reload(const std::string& name); 
     
    410396                         
    411397                         
     398                        //! Typedef for the resource map returned by the getResourceMap() method 
     399                        typedef std::map< std::string, std::list<ResourceHandle> > ResourceGroupMap; 
     400                         
     401                        /** 
     402                         * Return the map containing group names and according resource list. 
     403                         **/ 
     404                        const ResourceGroupMap& getResourceMap() { return mResourceGroup; } 
     405                         
     406                private: 
     407                 
    412408                        /** 
    413409                        * Release all resources. This will unload and then remove all  
     
    421417                        void removeAllLoaders(); 
    422418         
    423                         //! Typedef for the resource map returned by the getResourceMap() method  
    424                         typedef std::map< std::string, std::list<ResourceHandle> > ResourceGroupMap; 
    425                          
    426                         /** 
    427                          * Return the map containing group names and according resource list. 
    428                          **/ 
    429                         const ResourceGroupMap& getResourceMap() { return mResourceGroup; } 
    430                          
    431                 protected: 
    432419         
    433420                        //! Only engine can create the instance 
     
    523510                        //! Resource loader have access to certain functions 
    524511                        friend class IResourceLoader; 
     512 
     513                        //! Resource object hast got access to certain objects 
     514                        friend class IResource; 
    525515                         
    526516                        /** 
  • nrEngine/include/ResourcePtr.h

    r34 r35  
    2222#include "Prerequisities.h" 
    2323#include "Exception.h" 
     24#include "Log.h" 
    2425 
    2526namespace nrEngine{ 
     
    9495                        * Check whenever this pointer is NULL - does not contain data 
    9596                        **/ 
    96                         inline bool isNull()const { 
     97                        NR_FORCEINLINE bool isNull()const { 
    9798                                return (mHolder.get() == NULL); 
    9899                        } 
     
    102103                         * if opossite to isNull() 
    103104                         **/ 
    104                         inline bool valid()const { 
     105                        NR_FORCEINLINE bool valid()const { 
    105106                                return (mHolder.get() != NULL); 
    106107                        } 
     
    115116                        *       - RES_LOCK_STATE_STACK_IS_FULL if we are not able to lock anymore 
    116117                        **/ 
    117                         Result lockPure(); 
     118                        Result lockResource(); 
    118119 
    119120 
     
    124125                        * @return either OK or RES_PTR_IS_NULL if this pointer is null 
    125126                        **/ 
    126                         Result unlockPure(); 
     127                        Result unlockResource(); 
    127128 
    128129 
     
    236237                        { 
    237238                                ResType* ptr = dynamic_cast<ResType*>(IResourcePtr::getBase()); 
    238                                 NR_ASSERT(ptr != NULL && "The resource has wrong type"); 
     239                                if (ptr == NULL) 
     240                                { 
     241                                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourcePtr<%s> cannot cast from IResource", getBase()->getResourceName().c_str()); 
     242                                        NR_ASSERT(ptr != NULL && "The resource has wrong type"); 
     243                                } 
    239244                                return ptr; 
    240245                        } 
     246 
    241247 
    242248                        /** 
     
    256262                        NR_FORCEINLINE ResType& operator*() const 
    257263                        { 
    258                                 ResType* ptr = dynamic_cast<ResType*>(IResourcePtr::getBase()); 
    259                                 NR_ASSERT(ptr != NULL && "The resource has wrong type"); 
    260                                 return *ptr; 
     264                                return *(operator->()); 
    261265                        } 
    262266        }; 
  • nrEngine/include/ScriptLoader.h

    r32 r35  
    6161                        * so you have to worry about the adding the script into the kernel . 
    6262                        **/ 
    63                         Result loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param = NULL); 
     63                        Result loadResource(IResource* res, const std::string& fileName, PropertyList* param = NULL); 
    6464         
    6565                        /** 
     
    7575                        * @see IResourceLoader::createResourceImpl() 
    7676                        **/ 
    77                         IResource* createResourceImpl(const std::string& resourceType, PropertyList* params = NULL); 
     77                        IResource* createResource(const std::string& resourceType, PropertyList* params = NULL); 
    7878                         
    79                         /** 
    80                         * @see IResourceLoader::getSuffix() 
    81                         **/ 
    82                         std::string getSuffix(const std::string& resType); 
    83  
    8479        }; 
    8580 
  • nrEngine/src/FileStream.cpp

    r30 r35  
    2828        FileStream::~FileStream() 
    2929        { 
    30                 unloadRes(); 
    31         } 
    32  
    33         //---------------------------------------------------------------------------------- 
    34         Result FileStream::unloadRes() 
     30                unloadResource(); 
     31        } 
     32 
     33        //---------------------------------------------------------------------------------- 
     34        Result FileStream::unloadResource() 
    3535        { 
    3636                close(); 
     
    3939        } 
    4040 
     41        //---------------------------------------------------------------------------------- 
     42        Result FileStream::reloadResource(PropertyList* params) 
     43        { 
     44                return open(getResourceFilenameList().front()); 
     45        } 
     46         
    4147        //---------------------------------------------------------------------------------- 
    4248        Result FileStream::open (const std::string& fileName) 
  • nrEngine/src/FileStreamLoader.cpp

    r15 r35  
    3434 
    3535        //---------------------------------------------------------------------------------- 
    36         Result FileStreamLoader::initializeResourceLoader(){ 
     36        Result FileStreamLoader::initializeResourceLoader() 
     37        { 
    3738                 
    3839                // fill out supported resource types; 
     
    4344         
    4445        //---------------------------------------------------------------------------------- 
    45         Result FileStreamLoader::loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param) 
     46        Result FileStreamLoader::loadResource(IResource* res, const std::string& fileName, PropertyList* param) 
    4647        { 
    4748                // create a pointer to the stream object and open the file 
     
    5253 
    5354        //---------------------------------------------------------------------------------- 
    54         IResource* FileStreamLoader::createResourceImpl(const std::string& resourceType, PropertyList* params) 
     55        IResource* FileStreamLoader::createResource(const std::string& resourceType, PropertyList* params) 
    5556        { 
    5657                // create an plugin instance 
  • nrEngine/src/IScript.cpp

    r34 r35  
    2323 
    2424        //-------------------------------------------------------------------- 
    25         void IScript::notifyResReloaded() 
    26         { 
    27                 // if we reload a resource, so we set the task name to the resource name 
    28                 setTaskName(std::string("Script_") + getResName()); 
    29         } 
    30  
    31         //-------------------------------------------------------------------- 
    3225        void IScript::notifyLoaded() 
    3326        { 
    34                 markResLoaded(); 
     27                markResourceLoaded(); 
    3528        } 
    3629 
  • nrEngine/src/ITask.cpp

    r30 r35  
    2626 
    2727        //-------------------------------------------------------------------- 
    28         ITask::ITask(const std::string& name) : IThread(){ 
     28        ITask::ITask(const std::string& name) : IThread(), _taskName(name) 
     29        { 
    2930                init(); 
    30                 setTaskName(_taskName); 
    3131        } 
    3232 
     
    4141                _taskGraphColor = 0; 
    4242                _taskProperty = TASK_NONE; 
    43                 setTaskName(""); 
    4443        } 
    4544         
     
    106105        //-------------------------------------------------------------------- 
    107106        void ITask::setTaskName(const std::string& name){ 
    108                 strncpy(_taskName, name.c_str(), 63); 
     107                _taskName = name; 
    109108        } 
    110109 
  • nrEngine/src/Plugin.cpp

    r30 r35  
    3131        Plugin::~Plugin() 
    3232        { 
    33                 unloadRes(); 
     33                unloadResource(); 
    3434        } 
    3535 
     
    6767 
    6868                // log something 
    69                 NR_Log(Log::LOG_PLUGIN, "Initialize plugin %s", getResName().c_str()); 
     69                NR_Log(Log::LOG_PLUGIN, "Initialize plugin %s", getResourceName().c_str()); 
    7070 
    7171#define GET_SYMBOL(var, type)\ 
     
    121121 
    122122        //---------------------------------------------------------------------------------- 
    123         Result Plugin::unloadRes() 
     123        Result Plugin::unloadResource() 
    124124        { 
    125125                // only unload, if we are loaded 
    126                 if (isResLoaded()){ 
    127  
     126                if (isResourceLoaded()) 
     127                { 
    128128                        // call the release function of the plugin 
    129129                        m_plgRelease(); 
     
    135135                        m_plgError = NULL; 
    136136                        m_plgRelease = NULL; 
     137 
     138                        // now unload the plugin handle from memory 
     139                        if (NR_PLUGIN_UNLOAD(mPluginHandle)) 
     140                        { 
     141                                NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, 
     142                                        "Could not unload plugin %s. System Msg: %s", 
     143                                        getResourceName().c_str(), getLastPluginError().c_str()); 
     144                                return PLG_UNLOAD_ERROR; 
     145                        } 
     146         
     147                        // set the handle to 0 
     148                        mPluginHandle = NULL; 
     149                        markResourceUnloaded(); 
    137150                } 
    138151 
     
    141154        } 
    142155 
     156        //---------------------------------------------------------------------------------- 
     157        Result Plugin::reloadResource(PropertyList* params) 
     158        { 
     159                if (!isResourceLoaded()) 
     160                { 
     161                        // get filename 
     162                        const std::string& name = getResourceFilenameList().front(); 
     163                         
     164                        // now load the library 
     165                        mPluginHandle = (PluginHandle)NR_PLUGIN_LOAD(name.c_str()); 
     166 
     167                        // check whenever the library could be loaded 
     168                        if (mPluginHandle == NULL) 
     169                        { 
     170                                NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, 
     171                                        "Plugin %s could not be loaded! System Msg: %s", 
     172                                        getResourceName().c_str(), getLastPluginError().c_str()); 
     173                                return PLG_COULD_NOT_LOAD; 
     174                        } 
     175 
     176                        // force the plugin resource object to initialize itself after loading 
     177                        return initialize(params); 
     178                } 
     179                return OK; 
     180        } 
     181 
     182        //----------------------------------------------------------------------- 
     183        std::string Plugin::getLastPluginError() 
     184        { 
     185#if NR_PLATFORM == NR_PLATFORM_WIN32 
     186                LPVOID lpMsgBuf;  
     187                FormatMessage(  
     188                        FORMAT_MESSAGE_ALLOCATE_BUFFER |  
     189                        FORMAT_MESSAGE_FROM_SYSTEM |  
     190                        FORMAT_MESSAGE_IGNORE_INSERTS,  
     191                        NULL,  
     192                        GetLastError(),  
     193                        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),  
     194                        (LPTSTR) &lpMsgBuf,  
     195                        0,  
     196                        NULL  
     197                        );  
     198                std::string ret = (char*)lpMsgBuf; 
     199                 
     200                // Free the buffer. 
     201                LocalFree( lpMsgBuf ); 
     202                return ret; 
     203#elif NR_PLATFORM == NR_PLATFORM_LINUX 
     204                return std::string(dlerror()); 
     205#elif NR_PLATFORM == NR_PLATFORM_APPLE 
     206                return std::string(mac_errorBundle()); 
     207#else 
     208                return std::string(""); 
     209#endif 
     210        } 
    143211 
    144212        //---------------------------------------------------------------------------------- 
     
    155223 
    156224        //---------------------------------------------------------------------------------- 
    157         Result EmptyPlugin::unloadRes() 
     225        Result EmptyPlugin::unloadResource() 
     226        { 
     227                return OK; 
     228        } 
     229        //---------------------------------------------------------------------------------- 
     230        Result EmptyPlugin::reloadResource() 
    158231        { 
    159232                return OK; 
  • nrEngine/src/PluginLoader.cpp

    r32 r35  
    4343                // register some new functions by the scripting engine 
    4444                Engine::sScriptEngine()->add("loadPlugin", loadPlugin); 
    45                  
    4645        } 
    4746 
     
    5554         
    5655        //---------------------------------------------------------------------------------- 
    57         Result PluginLoader::initializeResourceLoader(){ 
     56        Result PluginLoader::initializeResourceLoader() 
     57        { 
    5858 
    5959                // fill out supported resource types; 
     
    8383 
    8484        //---------------------------------------------------------------------------------- 
    85         Result PluginLoader::loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param) 
     85        Result PluginLoader::loadResource(IResource* res, const std::string& fileName, PropertyList* param) 
    8686        { 
    8787 
     
    109109#endif 
    110110 
    111                 // cast to plugin type 
    112                 Plugin* plugin = dynamic_cast<Plugin*>(res); 
    113                 NR_ASSERT(plugin != NULL); 
     111                // set filename to the extended one 
     112                std::list<std::string> flist; 
     113                flist.push_back(name); 
     114                res->setResourceFilename(flist); 
    114115 
    115                 // now load the library 
    116                 plugin->mPluginHandle = (PluginHandle)NR_PLUGIN_LOAD(name.c_str()); 
    117  
    118                 // check whenever the library could be loaded 
    119                 if (plugin->mPluginHandle == NULL) 
    120                 { 
    121                         NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, 
    122                                 "Plugin %s could not be loaded! System Msg: %s", 
    123                                 plugin->getResName().c_str(), getLastPluginError().c_str()); 
    124                         return PLG_COULD_NOT_LOAD; 
    125                 } 
    126  
    127                 // force the plugin resource object to initialize itself after loading 
    128                 return  plugin->initialize(param); 
     116                // call reloading method in resource, so it get loaded 
     117                return res->reload(param);               
    129118        } 
    130119         
    131          
    132120        //---------------------------------------------------------------------------------- 
    133         Result PluginLoader::unloadResourceImpl(IResource* resource) 
    134         { 
    135  
    136                 // now unload the library from the memory 
    137                 Plugin* plugin = dynamic_cast<Plugin*>(resource); 
    138                 if (plugin) 
    139                 { 
    140                         plugin->unloadRes(); 
    141                                          
    142                         if (NR_PLUGIN_UNLOAD(plugin->mPluginHandle)) 
    143                         { 
    144                                 NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, 
    145                                         "Could not unload plugin %s. System Msg: %s", 
    146                                         plugin->getResName().c_str(), getLastPluginError().c_str()); 
    147                                 return PLG_UNLOAD_ERROR; 
    148                         } 
    149          
    150                         // set the handle to 0 
    151                         plugin->mPluginHandle = NULL; 
    152                 } 
    153                  
    154                 // OK 
    155                 return OK;               
    156         } 
    157          
    158          
    159         //---------------------------------------------------------------------------------- 
    160         IResource* PluginLoader::createResourceImpl(const std::string& resourceType, PropertyList* params) 
     121        IResource* PluginLoader::createResource(const std::string& resourceType, PropertyList* params) 
    161122        {        
    162123                // create an plugin instance 
     
    173134         
    174135         
    175         //----------------------------------------------------------------------- 
    176         std::string PluginLoader::getLastPluginError()  
    177         { 
    178 #if NR_PLATFORM == NR_PLATFORM_WIN32 
    179                 LPVOID lpMsgBuf;  
    180                 FormatMessage(  
    181                         FORMAT_MESSAGE_ALLOCATE_BUFFER |  
    182                         FORMAT_MESSAGE_FROM_SYSTEM |  
    183                         FORMAT_MESSAGE_IGNORE_INSERTS,  
    184                         NULL,  
    185                         GetLastError(),  
    186                         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),  
    187                         (LPTSTR) &lpMsgBuf,  
    188                         0,  
    189                         NULL  
    190                         );  
    191                 std::string ret = (char*)lpMsgBuf; 
    192                  
    193                 // Free the buffer. 
    194                 LocalFree( lpMsgBuf ); 
    195                 return ret; 
    196 #elif NR_PLATFORM == NR_PLATFORM_LINUX 
    197                 return std::string(dlerror()); 
    198 #elif NR_PLATFORM == NR_PLATFORM_APPLE 
    199                 return std::string(mac_errorBundle()); 
    200 #else 
    201                 return std::string(""); 
    202 #endif 
    203         } 
    204  
    205136}; 
    206137 
  • nrEngine/src/Resource.cpp

    r32 r35  
    2929                mResIsEmpty = false; 
    3030                mResDataSize = sizeof(*this); 
    31                 //mResLoader = NULL; 
    3231                setResourceType(resType); 
    3332        } 
     
    3635        IResource::~IResource() 
    3736        { 
    38                 // check for valid loader 
    39                 /*if (mResLoader != NULL) 
    40                 { 
    41                         // notify the parent loader, that the resource object will be removed now 
    42                         mResLoader->remove(this); 
    43                 }*/ 
    44                  
    45                 // notify the manager, that this resource was  
     37         
    4638        } 
    4739 
    4840        //---------------------------------------------------------------------------------- 
    49         Result IResource::unloadRes() 
     41        Result IResource::unload() 
    5042        { 
    51                 //if (mResLoader) mResLoader->notifyUnloadResource(this); 
     43                // check if resource is loaded 
     44                if (isResourceLoaded()) 
     45                { 
     46                        // unload resource 
     47                        Result ret = unloadResource(); 
     48 
     49                        // if ok, then inform resource manager, that we are unloaded now 
     50                        if (ret == OK) 
     51                                Engine::sResourceManager()->notifyUnloaded(this); 
     52                        else 
     53                                return ret; 
     54                } 
    5255                return OK; 
    5356        } 
    5457         
    5558        //---------------------------------------------------------------------------------- 
    56         Result IResource::reloadRes() 
     59        Result IResource::reload(PropertyList* params) 
    5760        { 
    58                 //if (mResLoader) mResLoader->notifyUnloadResource(this); 
     61                // if resource is loaded, then unload it first 
     62                if (isResourceLoaded()) 
     63                { 
     64                        Result ret = unload(); 
     65                        if (ret != OK) return ret; 
     66                } 
     67                         
     68                // check if resource is loaded 
     69                if (!isResourceLoaded()) 
     70                { 
     71                        // unload resource 
     72                        Result ret = reloadResource(params); 
     73 
     74                        // if ok, then inform resource manager, that we are reloaded now 
     75                        if (ret == OK) 
     76                                Engine::sResourceManager()->notifyLoaded(this); 
     77                        else 
     78                                return ret; 
     79                } 
    5980                return OK; 
    6081        } 
     82         
     83        //---------------------------------------------------------------------------------- 
     84        Result IResource::remove() 
     85        { 
     86                // unload resource first 
     87                unload(); 
    6188 
     89                // remove resource in the loader 
     90                return mResLoader->remove(getSharedPtrFromThis()); 
     91        } 
     92 
     93#if 0 
    6294        //---------------------------------------------------------------------------------- 
    6395        Result IResource::unloadResThroughLoader() 
     
    85117                return mResLoader->reload(getSharedPtrFromThis()); 
    86118        } 
    87  
     119         
    88120        //---------------------------------------------------------------------------------- 
    89121        Result IResource::removeResThroughLoader() 
     
    98130                return mResLoader->remove(getSharedPtrFromThis()); 
    99131        } 
    100          
     132#endif   
    101133        //---------------------------------------------------------------------------------- 
    102134        void IResource::addResourceFilename(const std::string& filename) 
     
    116148        } 
    117149 
     150        //---------------------------------------------------------------------------------- 
     151        void IResource::setResourceFilename(const std::list<std::string>& flist) 
     152        { 
     153                mResFileNames = flist; 
     154        } 
     155 
    118156}; 
    119157 
  • nrEngine/src/ResourceHolder.cpp

    r34 r35  
    4444                 
    4545        //---------------------------------------------------------------------------------- 
    46         bool ResourceHolder::lockPure() 
     46        bool ResourceHolder::lockResource() 
    4747        { 
    4848                // check if resource is already locked 
    4949                if (isEmptyLocked() && mResource) 
    50                         NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "You are trying to lock real resource while empty resource is locked. Empty stay locked for %s", mResource->getResName().c_str()); 
     50                        NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "You are trying to lock real resource while empty resource is locked. Empty stay locked for %s", mResource->getResourceName().c_str()); 
    5151                else if (isEmptyLocked() && !mResource) 
    5252                        NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "You are trying to lock real resource while empty resource is locked. Empty stay locked"); 
     
    5656                        if (mResource){ 
    5757                                NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG,  
    58                                         "Can not lock %s anymore. Lock state stack is full!", mResource->getResName().c_str());  
     58                                        "Can not lock %s anymore. Lock state stack is full!", mResource->getResourceName().c_str()); 
    5959                        }else{ 
    6060                                NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG,  
     
    7272                 
    7373        //---------------------------------------------------------------------------------- 
    74         void ResourceHolder::unlockPure() 
     74        void ResourceHolder::unlockResource() 
    7575        { 
    7676                // check whenever we've got right top position 
     
    8686                // check if resource is already locked 
    8787                if (isLocked() && mResource) 
    88                         NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "You are trying to lock empty resource while real resource is locked. Empty will be used for %s", mResource->getResName().c_str()); 
     88                        NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "You are trying to lock empty resource while real resource is locked. Empty will be used for %s", mResource->getResourceName().c_str()); 
    8989                else if (isLocked() && !mResource) 
    9090                        NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "You are trying to lock empty resource while real resource is locked. Empty will be used"); 
     
    9696                        { 
    9797                                NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG,  
    98                                         "Can not lock %s anymore. Lock state stack is full!", mResource->getResName().c_str());  
     98                                        "Can not lock %s anymore. Lock state stack is full!", mResource->getResourceName().c_str()); 
    9999                        }else{ 
    100100                                NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG,  
     
    121121 
    122122        //---------------------------------------------------------------------------------- 
    123         void ResourceHolder::resetRes(IResource* res) 
     123        void ResourceHolder::resetResource(IResource* res) 
    124124        { 
    125125                mResource = (res); 
     
    155155                { 
    156156                        // check if we have locked to an empty resource 
    157                         if (mResource->isResLoaded() || isLocked()){ 
     157                        if (mResource->isResourceLoaded() || isLocked()){ 
    158158                                return mResource; 
    159159                        } 
  • nrEngine/src/ResourceLoader.cpp

    r32 r35  
    7777                        } 
    7878 
     79                        #if 0 
    7980                        // if no type foud, then check if suffix is defined 
    8081                        if (!typeFound && resourceType.length() > 0) 
     
    8788                                } 
    8889                        } 
    89                          
     90                        #endif 
     91                                                 
    9092                        // if no type was specified so give up 
    9193                        if (!typeFound) 
     
    111113 
    112114                // now call the implemented loading function 
    113                 if (loadResourceImpl(res.get(), newFileName, param) != OK) 
     115                if (loadResource(res.get(), newFileName, param) != OK) 
    114116                { 
    115117                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourceLoader %s can not load resource from file %s", mName.c_str(), newFileName.c_str()); 
     
    138140 
    139141                // now call the implemented function to create the resource 
    140                 SharedPtr<IResource> res (createResourceImpl(resourceType, params), IResource::_deleter()); 
     142                SharedPtr<IResource> res (createResource(resourceType, params), IResource::_deleter()); 
    141143 
    142144                // check if the result is valid, then add it into our database 
     
    149151                if (empty == NULL) 
    150152                { 
     153                        // create empty resource and fill default properties 
    151154                        empty.reset( createEmptyResource(resourceType), IResource::_deleter() ); 
    152155                        empty->mResGroup = "_Empty_Resource_Group_"; 
     
    156159                        empty->mResLoader = getSharedPtrFromThis(); 
    157160                        empty->setResourceType(resourceType); 
    158                 } 
    159  
    160                 // set the resource in the manager 
    161                 Engine::sResourceManager()->setEmpty(resourceType, empty); 
     161                         
     162                        // set the resource in the manager 
     163                        Engine::sResourceManager()->setEmpty(resourceType, empty); 
     164                } 
    162165 
    163166                // setup default resource data 
     
    166169                res->mResIsEmpty = false; 
    167170                res->mResLoader = getSharedPtrFromThis(); 
    168  
     171                 
    169172                // now set this resource in the list of handled resource objects 
    170173                mHandledResources.push_back(res); 
     
    204207                return r; 
    205208        } 
    206  
     209#if 0 
    207210        //---------------------------------------------------------------------------------- 
    208211        Result IResourceLoader::unload(SharedPtr<IResource> resource) 
     
    255258                return OK; 
    256259        } 
    257  
     260#endif 
    258261        //---------------------------------------------------------------------------------- 
    259262        Result IResourceLoader::remove(SharedPtr<IResource> resource) 
     
    265268                if (std::find(mHandledResources.begin(), mHandledResources.end(), resource) == mHandledResources.end()) 
    266269                { 
    267                         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()); 
     270                        NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "ResourceLoader: You are trying to remove resource %s not handled by this loader %s!", resource->getResourceName().c_str(), mName.c_str()); 
    268271                        return OK; 
    269272                } 
    270273 
    271                 // unload 
    272                 unload(resource); 
     274                // unload resource 
     275                resource->unload(); 
    273276 
    274277                // notify to remove the resource 
     
    287290 
    288291                // check if such resource is loaded 
    289                 if (resit != mHandledResources.end() ){ 
    290  
     292                if (resit != mHandledResources.end() ) 
     293                { 
    291294                        // ok remove the resource from the handled resources 
    292295                        mHandledResources.erase(resit); 
     
    296299                } 
    297300        } 
     301 
     302#if 0 
    298303 
    299304        //---------------------------------------------------------------------------------- 
     
    331336                return OK; 
    332337        } 
    333  
     338#endif 
    334339        //---------------------------------------------------------------------------------- 
    335340        bool IResourceLoader::supportResourceType(const std::string& resourceType) const { 
  • nrEngine/src/ResourceManager.cpp

    r31 r35  
    8989 
    9090        //---------------------------------------------------------------------------------- 
    91         void ResourceManager::removeAllRes(){ 
     91        void ResourceManager::removeAllRes() 
     92        { 
    9293 
    9394                // iterate through each resource and remove it 
     
    107108                        SharedPtr<IResource>& res = jt->second; 
    108109 
    109                         NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "ResourceManager: Remove empty resource of type %s", res->getResType().c_str()); 
     110                        NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "ResourceManager: Remove empty resource of type %s", res->getResourceType().c_str()); 
    110111                        res.reset(); 
    111112                        mEmptyResource.erase(jt); 
     
    254255        IResourcePtr ResourceManager::createResource (const std::string& name, const std::string& group, const std::string& resourceType, PropertyList* params) 
    255256        { 
    256                 NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "ResourceManager: Create resource %s of type %s in group %s", name.c_str(), resourceType.c_str(), group.c_str()); 
    257  
    258257                // check if such a resource already exists 
    259258                IResourcePtr pRes = getByName(name); 
     
    277276                        return IResourcePtr(); 
    278277                } 
     278 
     279                NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "ResourceManager: Create resource %s of type %s in group %s", name.c_str(), resourceType.c_str(), group.c_str()); 
    279280 
    280281                // get the holder for this resource, it must be there 
     
    348349                } 
    349350 
    350                 lockPure(res); 
    351                         NR_Log(Log::LOG_ENGINE, "ResourceManager: Unload resource %s", res->getResName().c_str(), res->getResHandle()); 
    352                         Result ret = res->unloadResThroughLoader(); 
    353                 unlockPure(res); 
     351                lockResource(res); 
     352                        NR_Log(Log::LOG_ENGINE, "ResourceManager: Unload resource %s", res->getResourceName().c_str(), res->getResourceHandle()); 
     353                        Result ret = res->unload(); 
     354                unlockResource(res); 
    354355 
    355356                return ret; 
     
    363364                } 
    364365 
    365                 lockPure(res); 
     366                lockResource(res); 
    366367                        NR_Log(Log::LOG_ENGINE, "ResourceManager: Unload resource %s", 
    367                                 res.getBase()->getResName().c_str(), res.getBase()->getResHandle()); 
    368                         Result ret = res.getBase()->unloadResThroughLoader(); 
    369                 unlockPure(res); 
     368                                res.getBase()->getResourceName().c_str(), res.getBase()->getResourceHandle()); 
     369                        Result ret = res.getBase()->unload(); 
     370                unlockResource(res); 
    370371 
    371372                return ret; 
     
    381382                } 
    382383 
    383                 lockPure(res); 
     384                lockResource(res); 
    384385                        NR_Log(Log::LOG_ENGINE, "ResourceManager: Unload resource %s", 
    385                                 res->getResName().c_str(), res->getResHandle()); 
    386                         Result ret = res->unloadResThroughLoader(); 
    387                 unlockPure(res); 
     386                                res->getResourceName().c_str(), res->getResourceHandle()); 
     387                        Result ret = res->unload(); 
     388                unlockResource(res); 
    388389 
    389390                return ret; 
     
    399400                } 
    400401 
    401                 lockPure(res); 
     402                lockResource(res); 
    402403                        NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "ResourceManager: Reload resource %s", 
    403                                 res->getResName().c_str(), res->getResHandle()); 
    404                         Result ret = res->reloadResThroughLoader(); 
    405                 unlockPure(res); 
     404                                res->getResourceName().c_str(), res->getResourceHandle()); 
     405                        Result ret = res->reload(); 
     406                unlockResource(res); 
    406407 
    407408                return ret; 
     
    417418                } 
    418419 
    419                 lockPure(res); 
     420                lockResource(res); 
    420421                        NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "ResourceManager: Reload resource %s", 
    421                                 res->getResName().c_str(), res->getResHandle()); 
    422                         Result ret = res->reloadResThroughLoader(); 
    423                 unlockPure(res); 
     422                                res->getResourceName().c_str(), res->getResourceHandle()); 
     423                        Result ret = res->reload(); 
     424                unlockResource(res); 
    424425 
    425426                return ret; 
     
    433434                } 
    434435 
    435                 lockPure(res); 
     436                lockResource(res); 
    436437                        NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "ResourceManager: Reload resource %s", 
    437                                 res.getBase()->getResName().c_str(), res.getBase()->getResHandle()); 
    438                         Result ret = res.getBase()->reloadResThroughLoader(); 
    439                 unlockPure(res); 
     438                                res.getBase()->getResourceName().c_str(), res.getBase()->getResourceHandle()); 
     439                        Result ret = res.getBase()->reload(); 
     440                unlockResource(res); 
    440441 
    441442                return ret; 
     
    448449 
    449450                // we need to lock the resource, because we need the real resource object not empty 
    450                 lockPure(resPtr); 
     451                lockResource(resPtr); 
    451452 
    452453                        ResourcePtr<IResource> ptr = resPtr; 
    453                         ResourceHandle hdl = ptr->getResHandle(); 
    454                         std::string name = ptr->getResName(); 
    455                         std::string grp = ptr->getResGroup(); 
     454                        ResourceHandle hdl = ptr->getResourceHandle(); 
     455                        std::string name = ptr->getResourceName(); 
     456                        std::string grp = ptr->getResourceGroup(); 
    456457 
    457458                        if (hdl == 0){ 
     
    482483 
    483484                // unlock it back 
    484                 unlockPure(resPtr); 
     485                unlockResource(resPtr); 
    485486 
    486487                // clear the database 
     
    502503                } 
    503504 
    504                 lockPure(ptr); 
    505                         Result ret = ptr.getBase()->removeResThroughLoader(); 
    506                 unlockPure(ptr); 
     505                lockResource(ptr); 
     506                        Result ret = ptr.getBase()->remove(); 
     507                unlockResource(ptr); 
    507508 
    508509                return ret; 
     
    520521                } 
    521522 
    522                 lockPure(ptr); 
    523                         Result ret = ptr.getBase()->removeResThroughLoader(); 
    524                 unlockPure(ptr); 
     523                lockResource(ptr); 
     524                        Result ret = ptr.getBase()->remove(); 
     525                unlockResource(ptr); 
    525526 
    526527                return ret; 
     
    532533                // check whenever such a resource exists 
    533534                if (!ptr.isNull()){ 
    534                         lockPure(ptr); 
    535                                 Result ret = ptr.getBase()->removeResThroughLoader(); 
    536                         unlockPure(ptr); 
     535                        lockResource(ptr); 
     536                                Result ret = ptr.getBase()->remove(); 
     537                        unlockResource(ptr); 
    537538 
    538539                        return ret; 
     
    607608                // check now if a empty resource of that type already exists and load it if not 
    608609                SharedPtr<IResource> empty; 
    609                 checkEmptyResource(res->getResType(), empty, res->mResLoader); 
     610                checkEmptyResource(res->getResourceType(), empty, res->mResLoader); 
    610611 
    611612                // create a holder for that resource 
     
    639640 
    640641        //---------------------------------------------------------------------------------- 
    641         Result ResourceManager::lockPure(const std::string& name){ 
     642        Result ResourceManager::lockResource(const std::string& name){ 
    642643 
    643644                // get appropriate pointer 
     
    647648                if (ptr.isNull()) return RES_NOT_FOUND; 
    648649 
    649                 return ptr.lockPure(); 
    650         } 
    651  
    652         //---------------------------------------------------------------------------------- 
    653         Result ResourceManager::lockPure(ResourceHandle& handle){ 
     650                return ptr.lockResource(); 
     651        } 
     652 
     653        //---------------------------------------------------------------------------------- 
     654        Result ResourceManager::lockResource(ResourceHandle& handle){ 
    654655 
    655656                // get appropriate pointer 
     
    659660                if (ptr.isNull()) return RES_NOT_FOUND; 
    660661 
    661                 return ptr.lockPure(); 
    662  
    663         } 
    664  
    665         //---------------------------------------------------------------------------------- 
    666         Result ResourceManager::lockPure(IResourcePtr& res){ 
     662                return ptr.lockResource(); 
     663 
     664        } 
     665 
     666        //---------------------------------------------------------------------------------- 
     667        Result ResourceManager::lockResource(IResourcePtr& res){ 
    667668 
    668669                // lock through the pointer 
    669                 return res.lockPure(); 
    670  
    671         } 
    672  
    673         //---------------------------------------------------------------------------------- 
    674         Result ResourceManager::unlockPure(const std::string& name){ 
     670                return res.lockResource(); 
     671 
     672        } 
     673 
     674        //---------------------------------------------------------------------------------- 
     675        Result ResourceManager::unlockResource(const std::string& name){ 
    675676 
    676677                // get appropriate holder 
     
    679680                if (holder != NULL){ 
    680681                        // lock the resource through the holder 
    681                         (*holder)->unlockPure(); 
     682                        (*holder)->unlockResource(); 
    682683                }else{ 
    683684                        return RES_NOT_FOUND; 
     
    689690 
    690691        //---------------------------------------------------------------------------------- 
    691         Result ResourceManager::unlockPure(ResourceHandle& handle){ 
     692        Result ResourceManager::unlockResource(ResourceHandle& handle){ 
    692693 
    693694                // get appropriate holder 
     
    696697                if (holder != NULL){ 
    697698                        // lock the resource through the holder 
    698                         (*holder)->unlockPure(); 
     699                        (*holder)->unlockResource(); 
    699700                }else{ 
    700701                        return RES_NOT_FOUND; 
     
    706707 
    707708        //---------------------------------------------------------------------------------- 
    708         Result ResourceManager::unlockPure(IResourcePtr& res){ 
     709        Result ResourceManager::unlockResource(IResourcePtr& res){ 
    709710 
    710711                // if pointer does not pointing anywhere 
     
    714715 
    715716                // lock through the holder 
    716                 res.getResourceHolder()->unlockPure(); 
     717                res.getResourceHolder()->unlockResource(); 
    717718 
    718719                return OK; 
     
    842843 
    843844                // check if such a resource is already in the database 
    844                 if (isResourceRegistered(res->getResName())) return; 
     845                if (isResourceRegistered(res->getResourceName())) return; 
    845846 
    846847                // get some data from the resource 
    847                 const std::string& group = res->getResGroup(); 
    848                 const std::string& name = res->getResName(); 
    849                 const ResourceHandle& handle = res->getResHandle(); 
    850                 const std::string& type = res->getResType(); 
     848                const std::string& group = res->getResourceGroup(); 
     849                const std::string& name = res->getResourceName(); 
     850                const ResourceHandle& handle = res->getResourceHandle(); 
     851                const std::string& type = res->getResourceType(); 
    851852 
    852853                // get according empty resource object and give exception if no such exists 
     
    867868                mResourceName[name] = handle; 
    868869 
    869                 //printf("LOADED: %s\n", holder->getResource()->getResName().c_str()); 
     870                //printf("LOADED: %s\n", holder->getResource()->getResourceName().c_str()); 
    870871        } 
    871872 
     
    888889 
    889890                // check if such a resource is already in the database 
    890                 if (!isResourceRegistered(res->getResName())) return; 
     891                if (!isResourceRegistered(res->getResourceName())) return; 
    891892 
    892893                // get some data from the resource 
    893                 const std::string& group = res->getResGroup(); 
    894                 const std::string& name = res->getResName(); 
    895                 const ResourceHandle& handle = res->getResHandle(); 
     894                const std::string& group = res->getResourceGroup(); 
     895                const std::string& name = res->getResourceName(); 
     896                const ResourceHandle& handle = res->getResourceHandle(); 
    896897 
    897898                NR_Log(Log::LOG_ENGINE, "ResourceManager: Remove resource %s (%s)", name.c_str(), group.c_str()); 
     
    923924                        return; 
    924925                } 
    925                 holder->resetRes(NULL); 
     926                holder->resetResource(NULL); 
    926927 
    927928                // clear the database 
  • nrEngine/src/ResourcePtr.cpp

    r34 r35  
    4242                 
    4343                // At this point, both holders cannot be NULL 
    44                 if (A->getResource()->isResEmpty() || B->getResource()->isResEmpty()) return false; 
     44                if (A->getResource()->isResourceEmpty() || B->getResource()->isResourceEmpty()) return false; 
    4545                if (A->getResource() == B->getResource()) return true; 
    4646                 
     
    7070         
    7171        //---------------------------------------------------------------------------------- 
    72         Result IResourcePtr::lockPure() 
     72        Result IResourcePtr::lockResource() 
    7373        { 
    7474                if (!isNull()) 
    75                         if (!getResourceHolder()->lockPure()) 
     75                        if (!getResourceHolder()->lockResource()) 
    7676                                return RES_LOCK_STATE_STACK_IS_FULL; 
    7777                else 
     
    8282 
    8383        //---------------------------------------------------------------------------------- 
    84         Result IResourcePtr::unlockPure() 
     84        Result IResourcePtr::unlockResource() 
    8585        { 
    8686                if (!isNull()) 
    87                         getResourceHolder()->unlockPure(); 
     87                        getResourceHolder()->unlockResource(); 
    8888                else 
    8989                        return RES_PTR_IS_NULL; 
     
    120120                return mHolder->getResource(); 
    121121        } 
     122 
    122123}; 
    123124 
  • nrEngine/src/Script.cpp

    r28 r35  
    4040        Script::~Script() 
    4141        { 
    42                 unloadRes(); 
     42                unloadResource(); 
    4343        } 
    4444 
     
    4848        { 
    4949                // set task name as resource name 
    50                 setTaskName(getResName() + "_ScriptTask"); 
     50                setTaskName(getResourceName() + "_ScriptTask"); 
    5151 
    5252                // setup content 
     
    133133                                // create name for the new subscript 
    134134                                std::stringstream subscriptName; 
    135                                 subscriptName << getResName() << std::string("_sub_") << count ; 
     135                                subscriptName << getResourceName() << std::string("_sub_") << count ; 
    136136 
    137137                                // current top element is a new script, so create it 
    138                                 ResourcePtr<IScript> scr = Engine::sResourceManager()->createResource(subscriptName.str(), getResName(), "Script"); 
     138                                ResourcePtr<IScript> scr = Engine::sResourceManager()->createResource(subscriptName.str(), getResourceName(), "Script"); 
    139139 
    140140                                // if script could be created, so fill it and store, to execute later 
    141141                                if (scr.valid()) 
    142142                                { 
    143                                         scr.lockPure(); 
     143                                        scr.lockResource(); 
    144144                                                scr->loadFromString(sub); 
    145                                         scr.unlockPure(); 
     145                                        scr.unlockResource(); 
    146146                                        mSubscripts.push_back(scr); 
    147147                                }else{ 
    148                                         NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Script (%s): Subscript could not be created. Maybe no proper loader exists. Script will not run.\n", getResName().c_str()); 
     148                                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Script (%s): Subscript could not be created. Maybe no proper loader exists. Script will not run.\n", getResourceName().c_str()); 
    149149                                        return std::string(""); 
    150150                                } 
     
    166166                if (depth != 0 || curdepth != 0) 
    167167                { 
    168                         NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Script (%s): Subscript-brackets were not used properly. Depth is %d/%d, must be 0/0. Script disabled!", getResName().c_str(), depth, curdepth); 
     168                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Script (%s): Subscript-brackets were not used properly. Depth is %d/%d, must be 0/0. Script disabled!", getResourceName().c_str(), depth, curdepth); 
    169169                        return std::string(""); 
    170170                } 
    171171 
    172                 //printf("\n%s\n%s\n\n", getResName().c_str(), main.c_str()); 
     172                //printf("\n%s\n%s\n\n", getResourceName().c_str(), main.c_str()); 
    173173                 
    174174                return main; 
     
    194194                                        // create name for the new subscript 
    195195                                        std::stringstream subscriptName; 
    196                                         subscriptName << getResName() << std::string("_sub_") << count << std::string("_") << depth; 
     196                                        subscriptName << getResourceName() << std::string("_sub_") << count << std::string("_") << depth; 
    197197 
    198198                                        // current top element is a new script, so create it 
    199                                         ResourcePtr<IScript> scr = Engine::sResourceManager()->createResource(subscriptName.str(), getResName(), "Script"); 
     199                                        ResourcePtr<IScript> scr = Engine::sResourceManager()->createResource(subscriptName.str(), getResourceName(), "Script"); 
    200200 
    201201                                        // if script could be created, so fill it and store, to execute later 
    202202                                        if (scr.isNull()) 
    203203                                        { 
    204                                                 NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Script (%s): Subscript could not be created. Maybe no proper loader exists. Script will not run.\n", getResName().c_str()); 
     204                                                NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Script (%s): Subscript could not be created. Maybe no proper loader exists. Script will not run.\n", getResourceName().c_str()); 
    205205                                                return std::string(""); 
    206206                                        }else{ 
    207                                                 scr.lockPure(); 
     207                                                scr.lockResource(); 
    208208                                                        scr->loadFromString(*top); 
    209                                                 scr.unlockPure(); 
     209                                                scr.unlockResource(); 
    210210                                                mSubscripts.push_back(scr); 
    211211                                        } 
     
    223223                if (depth != 0) 
    224224                { 
    225                         NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "Script (%s): Subscript-brackets were not used properly. Depth is %d, must be 0. Script could not run as expected!", getResName().c_str(), depth); 
     225                        NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "Script (%s): Subscript-brackets were not used properly. Depth is %d, must be 0. Script could not run as expected!", getResourceName().c_str(), depth); 
    226226                } 
    227227 
     
    238238                if (script.length() == 0 || !str.good()) return OK; 
    239239 
    240                 //printf("%s: \n%s\n---\n\n", getResName().c_str(),str.str().c_str()); 
     240                //printf("%s: \n%s\n---\n\n", getResourceName().c_str(),str.str().c_str()); 
    241241                // get linewise 
    242242                char buf[1024]; 
     
    371371                                else throw boost::bad_lexical_cast(); 
    372372                        }catch(boost::bad_lexical_cast &){ 
    373                                 NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "Script: %s - not a valid value for \"start_at\" parameter specified", getResName().c_str());                   
     373                                NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "Script: %s - not a valid value for \"start_at\" parameter specified", getResourceName().c_str()); 
    374374                        } 
    375375                else 
     
    421421                mTime = mTimer->getTime(); 
    422422                 
    423                 //printf("%s (%f - %f)\n", getResName().c_str(), mTime, mScriptStartTime); 
     423                //printf("%s (%f - %f)\n", getResourceName().c_str(), mTime, mScriptStartTime); 
    424424 
    425425                // do execute the script only if start time was passed 
     
    527527                if (!warned && mLoop & LOOP_COMMAND){ 
    528528                        warned = true; 
    529                         NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "Script: %s - you are executing a looped script!!! Check this!!!", getResName().c_str()); 
     529                        NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "Script: %s - you are executing a looped script!!! Check this!!!", getResourceName().c_str()); 
    530530                } 
    531531 
  • nrEngine/src/ScriptLoader.cpp

    r32 r35  
    5757         
    5858        //---------------------------------------------------------------------------------- 
    59         std::string ScriptLoader::getSuffix(const std::string& resType) 
    60         { 
    61                 if (resType == "nrScript") 
    62                         return "nrscript"; 
    63                 else if (resType == "Script") 
    64                         return "script"; 
    65                 else if (resType == "Config") 
    66                         return "cfg"; 
    67                  
    68                 return std::string(); 
    69         } 
    70  
    71         //---------------------------------------------------------------------------------- 
    72         Result ScriptLoader::loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param) 
     59        Result ScriptLoader::loadResource(IResource* res, const std::string& fileName, PropertyList* param) 
    7360        { 
    7461                // load a file so we use its content as a script 
     
    9582 
    9683        //---------------------------------------------------------------------------------- 
    97         IResource* ScriptLoader::createResourceImpl(const std::string& resourceType, PropertyList* params) 
     84        IResource* ScriptLoader::createResource(const std::string& resourceType, PropertyList* params) 
    9885        { 
    9986                // check if we want to create just a script 
Note: See TracChangeset for help on using the changeset viewer.