Changeset 32


Ignore:
Timestamp:
04/10/07 23:05:42 (12 years ago)
Author:
art
Message:
 
Files:
2 added
19 edited

Legend:

Unmodified
Added
Removed
  • Make/Makedefs

    r13 r32  
     1#----------------------------------------------- 
     2# Find out the platform 
     3#----------------------------------------------- 
     4SHELL = /bin/sh 
     5OS := $(shell uname) 
     6 
     7## IRIX ? 
     8ifeq ($(findstring IRIX,$(OS)),IRIX) 
     9OS := IRIX 
     10endif 
     11 
     12## Make CYGWIN_XXXX CYGWIN so it's "Windows cross platform" :) 
     13ifeq ($(findstring CYGWIN,$(OS)),CYGWIN) 
     14OS := CYGWIN 
     15endif 
     16 
     17## Make MINGW_XXXX MINGW so it's "Windows cross platform" :) 
     18ifeq ($(findstring MINGW,$(OS)),MINGW) 
     19OS := MINGW 
     20endif 
     21 
    122#----------------------------------------------- 
    223# Paths where to find includes and libraries 
     
    2344# Define macros with compiler options 
    2445#----------------------------------------------- 
    25 SHELL = /bin/sh 
    2646CC = g++ 
    27 CFLAGS =-O2 -Wall -Werror $(INCPATH) 
     47CFLAGS = -pthread -O2 -Wall -Werror $(INCPATH) 
    2848LIBS =  
    2949LDFLAGS = -shared $(LIBPATH) $(LIBS) 
  • Plugins/dynamicResources/Makefile

    r31 r32  
    1111CPPFILES = Plugin.cpp\ 
    1212          Monitor.cpp 
     13 
     14# if we are on linux system, then add this 
     15ifeq ($(OS), Linux) 
     16        CPPFILES += inotify-cxx.cpp 
     17endif 
     18 
    1319                         
    1420# some definitions 
  • Plugins/dynamicResources/Monitor.cpp

    r31 r32  
    2121{ 
    2222        setTaskName("DynamicResourceMonitor"); 
    23          
    24         #ifdef USE_INOTIFY 
    25         mFileDescriptor = 0; 
    26         #endif 
    2723} 
    2824 
     
    3531 
    3632//---------------------------------------------------------------------------------- 
    37 Result Monitor::onAddTask() 
    38 { 
     33Result Monitor::onStartTask() 
     34{ 
     35        Result res = UNKNOWN_ERROR; 
     36         
    3937        // use inotify if supported 
    4038        #ifdef USE_INOTIFY 
    41                 return initInotify(); 
     39                res = initInotify(); 
    4240        #endif 
    4341 
     42        init(); 
    4443         
    4544        // nothing supported, so return an error 
    46         return UNKNOWN_ERROR; 
     45        return res; 
    4746} 
    4847 
     
    5251        // if we support inotify, then do 
    5352        #ifdef USE_INOTIFY 
    54         close(mFileDescriptor); 
    55         NR_Log(Log::LOG_PLUGIN, "dynamicResources: Close inotify subsystem"); 
     53                mInotify->Close(); 
     54                NR_Log(Log::LOG_PLUGIN, "dynamicResources: Close inotify subsystem"); 
    5655        #endif 
    5756         
     
    6867        NR_Log(Log::LOG_PLUGIN, "dynamicResources: Use inotify interface for file monitoring"); 
    6968         
    70         mFileDescriptor = inotify_init(); 
    71         if (mFileDescriptor < 0) 
    72         { 
    73                 NR_Log(Log::LOG_PLUGIN, "dynamicResources: There was an error by initilizing the inotify interafce"); 
     69        try 
     70        { 
     71                mInotify.reset(new Inotify()); 
     72                //mInotify->SetNonBlock(true); 
     73        }catch(InotifyException& e) 
     74        { 
     75                NR_Log(Log::LOG_PLUGIN, Log::LL_ERROR, "dynamicResources: There was an error by initilizing the inotify interafce"); 
     76                NR_Log(Log::LOG_PLUGIN, Log::LL_ERROR, "dynamicResources: %s", e.GetMessage().c_str()); 
    7477                return UNKNOWN_ERROR; 
    7578        } 
    7679         
     80        return OK; 
     81} 
     82#endif 
     83 
     84//---------------------------------------------------------------------------------- 
     85void Monitor::init() 
     86{ 
    7787        // now scan through all resources, which are already loaded 
    7888        const ResourceManager::ResourceGroupMap& res = mRoot->sResourceManager()->getResourceMap(); 
     
    8797                        IResourcePtr pr = mRoot->sResourceManager()->getByHandle(*jt); 
    8898                         
     99                        // resource is valid, so do 
    89100                        if (pr.valid()) 
    90101                        { 
    91102                                // now get the file name associated with the resource  
    92103                                pr.lockPure(); 
    93                                 const std::string& fileName = pr.getBase()->getResFileName(); 
    94                                 printf("found %s - %s\n", pr.getBase()->getResName().c_str(), fileName.c_str()); 
     104                                        const std::list<std::string>& files = pr.getBase()->getResFilenameList(); 
     105                                        std::list<std::string>::const_iterator kt = files.begin(); 
     106                                         
     107                                        // for each filename add a monitor  
     108                                        for (; kt != files.end(); kt ++) 
     109                                        { 
     110                                                addMonitor(pr, *kt); 
     111                                        } 
    95112                                pr.unlockPure(); 
    96                                  
    97113                        }else{ 
    98                                 printf("warning\n"); 
     114                                NR_Log(Log::LOG_PLUGIN, Log::LL_WARNING, "dynamicResources: Resource %s seems to be NULL", pr.getBase()->getResName().c_str()); 
    99115                        } 
    100116                         
    101117                } 
    102118        } 
    103          
    104          
    105         // ok 
    106         return OK; 
    107 } 
     119} 
     120 
     121#ifdef USE_INOTIFY 
     122//---------------------------------------------------------------------------------- 
     123void Monitor::addMonitor(IResourcePtr res, const std::string& file) 
     124{ 
     125        // do only add a watcher if inotify already initialized 
     126        if (!mInotify || !res.valid() || file.length() < 1) return; 
     127         
     128        // we monitor only non-empty resources 
     129        res.lockPure(); 
     130        { 
     131                // create a watch descriptor 
     132                try 
     133                { 
     134                        // create watcher 
     135                        SharedPtr<InotifyWatch> watch(new InotifyWatch(file, IN_MODIFY)); 
     136                         
     137                        // add new watcher 
     138                        NR_Log(Log::LOG_PLUGIN, Log::LL_DEBUG, "dynamicResources: Monitor %s --> %s", res.getBase()->getResName().c_str(), file.c_str()); 
     139                         
     140                        // add the watcher into the map 
     141                        WatchData data; 
     142                        data.resource = res; 
     143                        data.watcher = watch; 
     144                        data.resourceName = res.getBase()->getResName(); 
     145                        mWatchMap[watch->GetDescriptor()] = data; 
     146                         
     147                        // add the new watch  
     148                        mInotify->Add(watch.get()); 
     149                         
     150                }catch(InotifyException& e) 
     151                { 
     152                        NR_Log(Log::LOG_PLUGIN, Log::LL_ERROR, "dynamicResources: Cannot add a monitor %s --> %s", res.getBase()->getResName().c_str(), file.c_str()); 
     153                        NR_Log(Log::LOG_PLUGIN, Log::LL_ERROR, "dynamicResources: %s", e.GetMessage().c_str()); 
     154                        return; 
     155                } 
     156                 
     157        } 
     158        res.unlockPure(); 
     159} 
     160 
     161#else 
     162 
     163//---------------------------------------------------------------------------------- 
     164void Monitor::addMonitor(IResourcePtr res, const std::string& file) 
     165{ 
     166        NR_Log(Log::LOG_PLUGIN, Log::LL_WARNING, "dynamicResources: Not valid monitor interface used to monitor %s --> %s", res.getBase()->getResName().c_str(), file.c_str()); 
     167} 
     168 
    108169#endif 
    109170 
    110 //---------------------------------------------------------------------------------- 
    111 Result Monitor::updateTask() 
    112 { 
    113  
    114         return OK; 
    115 } 
     171 
     172 
     173#ifdef USE_INOTIFY 
     174//---------------------------------------------------------------------------------- 
     175Result Monitor::update() 
     176{ 
     177        if (!mInotify) return OK; 
     178         
     179        printf("update\n"); 
     180        // wait for inotify events 
     181        try{ 
     182                mInotify->WaitForEvents(); 
     183        }catch(InotifyException& e) 
     184        { 
     185                NR_Log(Log::LOG_PLUGIN, Log::LL_ERROR, "dynamicResources: INotify Monitor cannot get events!"); 
     186                NR_Log(Log::LOG_PLUGIN, Log::LL_ERROR, "dynamicResources: %s", e.GetMessage().c_str()); 
     187                return OK; 
     188        } 
     189        printf("ok\n"); 
     190         
     191        // now extract events until there are no more of them  
     192        InotifyEvent event; 
     193        while(mInotify->GetEventCount() > 0) 
     194        { 
     195                // get event 
     196                try 
     197                { 
     198                        mInotify->GetEvent(&event); 
     199                        WatchData& data = mWatchMap[event.GetDescriptor()]; 
     200                         
     201                        if (data.resource.valid()) 
     202                        { 
     203                                data.resource.lockPure(); 
     204                                        printf("modified: %s\n", data.resource.getBase()->getResName().c_str()); 
     205                                data.resource.unlockPure(); 
     206                        }else{ 
     207                                NR_Log(Log::LOG_PLUGIN, Log::LL_WARNING, "dynamicResources: Monitored %s resource is not valid!", data.resourceName.c_str()); 
     208                        } 
     209                } 
     210                catch(InotifyException& e) 
     211                { 
     212                        NR_Log(Log::LOG_PLUGIN, Log::LL_ERROR, "dynamicResources: Cannot retrieve INotify-Event !"); 
     213                        NR_Log(Log::LOG_PLUGIN, Log::LL_ERROR, "dynamicResources: %s", e.GetMessage().c_str()); 
     214                        return OK; 
     215                } 
     216                 
     217        } 
     218 
     219         
     220        return OK; 
     221} 
     222 
     223 
     224#else 
     225//---------------------------------------------------------------------------------- 
     226Result Monitor::update() 
     227{ 
     228        return OK; 
     229} 
     230 
     231#endif 
     232 
     233 
  • Plugins/dynamicResources/Monitor.h

    r31 r32  
    2424 
    2525#if NR_PLATFORM == NR_PLATFORM_LINUX 
    26         #include "inotify.h" 
    27         #include "inotify-syscalls.h" 
     26        #include "inotify-cxx.h" 
    2827        #define USE_INOTIFY 
    2928#endif 
     
    4847                 
    4948                //! Initialize the task, cause ti was added to the kernel 
    50                 Result onAddTask(); 
     49                Result onStartTask(); 
    5150                 
    5251                //! Update the task 
    53                 Result updateTask(); 
     52                Result updateTask() { return update();} 
    5453 
    5554 
     
    5958                Engine* mRoot; 
    6059                 
     60                //! Initialize the monitor  
     61                void init(); 
     62                 
     63                //! Update the monitoring interface 
     64                Result update(); 
     65                 
     66                //! Add new file and associated resource to watch on 
     67                void addMonitor (IResourcePtr res, const std::string& file); 
     68 
    6169                // We are using inotify interface 
    6270                #ifdef USE_INOTIFY 
    6371                 
    64                 //! file descriptor 
    65                 int mFileDescriptor; 
     72                        //! file descriptor 
     73                        SharedPtr<Inotify> mInotify; 
     74                         
     75                        //! To watch we use this structures 
     76                        typedef struct _WatchData 
     77                        { 
     78                                IResourcePtr resource; 
     79                                SharedPtr<InotifyWatch> watcher; 
     80                                std::string resourceName; 
     81                        } WatchData; 
     82                         
     83                        //! Define map type for appropriate storing of watch descriptors 
     84                        typedef std::map<int, WatchData > WatcherMap; 
     85                         
     86                        //! Here we store the watching descriptors for the files 
     87                        WatcherMap mWatchMap; 
     88                         
     89                        //! Initialize inotify interface 
     90                        Result initInotify(); 
     91                #endif 
    6692                 
    67                 //! Initialize inotify interface 
    68                 Result initInotify(); 
    69                  
    70                 #endif 
    7193}; 
    7294 
  • Plugins/dynamicResources/Plugin.cpp

    r31 r32  
    1616//--------------------------------------------------------- 
    1717Engine*  mRoot = NULL; 
    18 bool     mThreaded = false; 
     18bool     mThreaded = true; 
    1919SharedPtr<Monitor>  mTask; 
    2020TaskId   mTaskId = 0; 
     
    3838        if (args) 
    3939        { 
    40                 if (args->exists("threaded")) 
     40                if (args->exists("isThreade")) 
    4141                { 
    42                         Property& prop = (*args)["threaded"]; 
    43                         NR_Log(Log::LOG_PLUGIN, "dynamicResources: Parameter 'threaded' is given, use it!"); 
     42                        Property& prop = (*args)["isThreaded"]; 
     43                        NR_Log(Log::LOG_PLUGIN, "dynamicResources: Parameter 'isThreaded' is given, use it!"); 
    4444                        try{ 
    4545                                mThreaded = prop.get<bool>(); 
     
    4848                                if (!prop.hasUserData()) 
    4949                                { 
    50                                         NR_Log(Log::LOG_PLUGIN, "dynamicResources: Parameter 'threaded' does not contain valid value nor user data!"); 
     50                                        NR_Log(Log::LOG_PLUGIN, "dynamicResources: Parameter 'isThreaded' does not contain valid value nor user data!"); 
    5151                                }else 
    5252                                        mThreaded = *(static_cast<bool*>(prop.getUserData())); 
  • Plugins/luaScripting/ScriptLoader.h

    r15 r32  
    6767        IResource* createResourceImpl(const std::string& resourceType, PropertyList* params = NULL); 
    6868 
     69        /** 
     70        * @see IResourceLoader::getSuffix() 
     71        **/ 
     72        std::string getSuffix(const std::string& resType) { return "lua"; } 
     73 
    6974}; 
    7075 
  • nrEngine/include/IThread.h

    r14 r32  
    2020#include "Prerequisities.h" 
    2121 
    22 //#include <pthread.h> 
    23                  
     22#include <boost/thread/thread.hpp> 
     23 
    2424namespace nrEngine{ 
    2525 
     
    131131                         * will be updated and managed as a thread. 
    132132                         **/ 
    133                         static void* run(void* mythread); 
     133                        static void run(void* mythread); 
    134134 
    135135                        //! Kernel is a friend class 
     
    190190 
    191191                        // Mutex to lock the data before use 
    192                         // pthread_mutex_t mMutex; 
     192                        //pthread_mutex_t mMutex; 
    193193 
    194194                        //! Store here the thread instance 
    195                         //pthread_t     mThread; 
     195                        SharedPtr<boost::thread> mThread; 
    196196 
    197197                        //! Thread attributes 
    198198                        //pthread_attr_t mThreadAttr; 
    199199                         
     200                         
    200201                        //! Change a thread to new state, use mutex to lock the state 
    201202                        void changeState(ThreadState newState); 
  • nrEngine/include/PluginLoader.h

    r15 r32  
    9898                 **/ 
    9999                std::string getLastPluginError(); 
    100                                  
     100                 
     101                /** 
     102                 * @see IResourceLoader::getSuffix() 
     103                 **/ 
     104                std::string getSuffix(const std::string& resType); 
     105 
    101106 
    102107                //! New scripting function to allow loading of plugins 
  • nrEngine/include/Resource.h

    r31 r32  
    9393                * Get the file name from which one this resource can be restored or loaded 
    9494                **/ 
    95                 NR_FORCEINLINE const std::string&       getResFileName() const {return mResFileName;} 
     95                NR_FORCEINLINE const std::list<std::string>&    getResFilenameList() const {return mResFileNames;} 
    9696 
    9797                /** 
     
    168168                 
    169169                /** 
    170                  * Set resource file name  
    171                  * @param filename Filename for the file associated with the resource  
    172                  **/ 
    173                  void setResourceFilename(const std::string& filename) { mResFileName = filename; } 
     170                 * Add resource file name. The filename is used to associated the resource with. 
     171                 * If a resource is build upon of a multiple files, then all the files should 
     172                 * be added through this method. 
     173                 * @param filename Filename of a file associated with the resource  
     174                 **/ 
     175                 void addResourceFilename(const std::string& filename); 
     176                  
     177                 /** 
     178                  * @see addResourceFilename(const std::string& filename) 
     179                  * @param flist List of filenames to add  
     180                  **/ 
     181                 void addResourceFilename(const std::list<std::string>& flist); 
    174182                  
    175183        private: 
     
    193201                ResourceHandle  mResHandle; 
    194202 
    195                 //! Filename from which one this resource can be reloaded/loaded 
    196                 std::string     mResFileName; 
     203                //! File associated with the resource 
     204                std::list<std::string>  mResFileNames; 
    197205 
    198206                //! Count of bytes that this resource is occupies in the memory 
    199                 std::size_t             mResDataSize; 
     207                std::size_t     mResDataSize; 
    200208 
    201209                //! Name of the resource type 
    202                 std::string             mResType; 
     210                std::string     mResType; 
    203211                 
    204212                //! Group name to which one this resource own 
  • nrEngine/include/ResourceLoader.h

    r15 r32  
    293293                        } 
    294294                         
     295                        /** 
     296                         * This method will return back a proper suffix according to the resource type. 
     297                         * Derived classes should overwrite this method, because they know which suffix  
     298                         * are proper to use. The suffix does not contain dot. Empty suffixes are possible. 
     299                         * @param resType Resource type for which one suffix is generated 
     300                         **/ 
     301                        virtual std::string getSuffix(const std::string& resType){return std::string();} 
     302                         
     303 
    295304                private: 
    296305                         
  • nrEngine/include/ResourcePtr.h

    r30 r32  
    4646 
    4747                        /** 
     48                        * Create an empty resource pointer, that do not point to anywhere 
     49                        **/ 
     50                        IResourcePtr() 
     51                        { 
     52                                mHolder.reset(); 
     53                        } 
     54 
     55                        /** 
    4856                        * Virtual destructor 
    4957                        **/ 
     
    163171                        } 
    164172 
    165                         /** 
    166                         * Simple constructor that is declared as protected/private, so that this 
    167                         * pointer con not be created outside as from the resource management system 
    168                         **/ 
    169                         IResourcePtr() 
    170                         { 
    171                                 mHolder.reset(); 
    172                         } 
    173173 
    174174        }; 
  • nrEngine/include/Result.h

    r27 r32  
    6161                NOT_VALID_DATOR         = 1 << 2, 
    6262 
    63  
     63                //! Generic time out error  
     64                TIME_OUT                = 1 << 3, 
     65                 
    6466                //------------------------------------------------------------------------------ 
    6567 
  • nrEngine/include/ScriptLoader.h

    r15 r32  
    7777                        IResource* createResourceImpl(const std::string& resourceType, PropertyList* params = NULL); 
    7878                         
     79                        /** 
     80                        * @see IResourceLoader::getSuffix() 
     81                        **/ 
     82                        std::string getSuffix(const std::string& resType); 
    7983 
    8084        }; 
  • nrEngine/src/IThread.cpp

    r14 r32  
    3333        { 
    3434                // delete the thread object if it is not empty 
    35                 //if (mThread){ 
    36                         //delete mThread; 
     35                //if (mThread) 
     36                //{ 
     37                //      delete mThread; 
    3738                //} 
    3839        } 
     
    4243        { 
    4344                // Check if we have already a thread created 
    44                 /*if (mThread) 
     45                if (mThread) 
    4546                { 
    4647                        NR_Log(Log::LOG_KERNEL, Log::LL_WARNING, "IThread: the appropriate thread is already running!"); 
    4748                        return; 
    48                 }*/ 
     49                } 
    4950                NR_Log(Log::LOG_KERNEL, "IThread: Create thread and start it"); 
    5051 
     
    5960                 
    6061                // now create a thread and let it run 
    61                 mThreadState = THREAD_RUNNING; 
    6262                int res = pthread_create(&mThread, &mThreadAttr, IThread::run, (void *)this); 
    6363                if (res){ 
     
    6666                }*/ 
    6767    
     68                mThreadState = THREAD_RUNNING; 
     69                mThread.reset(new boost::thread(boost::bind(IThread::run, this))); 
     70                 
    6871        } 
    6972 
     
    8184                        return; 
    8285                }*/ 
     86                mThread->join(); 
    8387        } 
    8488 
     
    117121                // use pthread to yield the timeslice 
    118122                //pthread_yield(); 
     123                boost::thread::yield(); 
    119124        } 
    120125 
    121126        //-------------------------------------------------------------------- 
    122         void* IThread::run(void* _mythread) 
     127        void IThread::run(void* _mythread) 
    123128        { 
    124129                // try to cast the given parameter to IThread pointer 
     
    127132                { 
    128133                        NR_Log(Log::LOG_KERNEL, Log::LL_ERROR, "IThread: not valid parameter was specified for IThread::run(void*) method"); 
    129                         return NULL; 
     134                        return; 
    130135                } 
    131136                 
     
    166171 
    167172                // exit the thread 
    168                 pthread_exit(NULL); 
     173                //return NULL; 
    169174        } 
    170175 
  • nrEngine/src/Makefile

    r22 r32  
    5757INCPATH += -I../include 
    5858CFLAGS += -fPIC 
    59 LIBS += -ldl 
     59LIBS += -ldl -lboost_thread 
    6060 
    6161# define files for installation 
  • nrEngine/src/PluginLoader.cpp

    r15 r32  
    7171                return OK; 
    7272        } 
    73                  
     73 
     74        //---------------------------------------------------------------------------------- 
     75        std::string PluginLoader::getSuffix(const std::string& resType) 
     76        { 
     77#if NR_PLATFORM == NR_PLATFORM_WIN32 
     78                return std::string("dll"); 
     79#elif NR_PLATFORM == NR_PLATFORM_LINUX 
     80                return std::string("so"); 
     81#endif 
     82        } 
     83 
    7484        //---------------------------------------------------------------------------------- 
    7585        Result PluginLoader::loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param) 
  • nrEngine/src/Resource.cpp

    r25 r32  
    9898                return mResLoader->remove(getSharedPtrFromThis()); 
    9999        } 
     100         
     101        //---------------------------------------------------------------------------------- 
     102        void IResource::addResourceFilename(const std::string& filename) 
     103        { 
     104                // first check if such a filename already exists 
     105                std::list<std::string>::iterator it = std::find(mResFileNames.begin(), mResFileNames.end(), filename); 
     106                if (it == mResFileNames.end()) 
     107                        mResFileNames.push_back(filename); 
     108        } 
     109         
     110        //---------------------------------------------------------------------------------- 
     111        void IResource::addResourceFilename(const std::list<std::string>& flist) 
     112        { 
     113                std::list<std::string>::const_iterator it = flist.begin(); 
     114                for (; it != flist.end(); it++) 
     115                        addResourceFilename(*it); 
     116        } 
     117 
    100118}; 
    101119 
  • nrEngine/src/ResourceLoader.cpp

    r27 r32  
    5454                bool typeFound = false; 
    5555                std::string type; 
    56  
     56                std::string newFileName = fileName; 
     57                 
    5758                // we search for the type if no type is specified 
    58                 if (resourceType.length() == 0){ 
     59                if (resourceType.length() == 0) 
     60                { 
    5961                        NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "ResourceLoader \"%s\" try to find according resource type by filename \"%s\"", mName.c_str(), fileName.c_str(), fileName.c_str()); 
    6062 
     
    7577                        } 
    7678 
     79                        // if no type foud, then check if suffix is defined 
     80                        if (!typeFound && resourceType.length() > 0) 
     81                        { 
     82                                type = getSuffix(resourceType); 
     83                                if (type.length() > 0) 
     84                                {        
     85                                        typeFound = true; 
     86                                        newFileName = fileName + std::string(".") + type; 
     87                                } 
     88                        } 
     89                         
    7790                        // if no type was specified so give up 
    78                         if (!typeFound){ 
    79                                 NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourceLoader %s neither resource type nor valid file ending was found, give up!", mName.c_str()); 
     91                        if (!typeFound) 
     92                        { 
     93                                NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourceLoader %s: neither resource type nor valid file ending was found, give up!", mName.c_str()); 
    8094                                return SharedPtr<IResource>(); 
    8195                        } 
     
    92106 
    93107                // setup some data on resource 
    94                 res->mResFileName = fileName; 
     108                res->addResourceFilename(newFileName); 
    95109                res->mResName = name; 
    96110                res->mResGroup = group; 
    97111 
    98112                // now call the implemented loading function 
    99                 if (loadResourceImpl(res.get(), fileName, param) != OK) 
    100                 { 
    101                         NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourceLoader %s can not load resource from file %s", mName.c_str(), fileName.c_str()); 
     113                if (loadResourceImpl(res.get(), newFileName, param) != OK) 
     114                { 
     115                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourceLoader %s can not load resource from file %s", mName.c_str(), newFileName.c_str()); 
    102116                        remove(res); 
    103117                        return SharedPtr<IResource>(); 
  • nrEngine/src/ScriptLoader.cpp

    r30 r32  
    5555                return OK; 
    5656        } 
     57         
     58        //---------------------------------------------------------------------------------- 
     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        } 
    5770 
    5871        //---------------------------------------------------------------------------------- 
Note: See TracChangeset for help on using the changeset viewer.