Changeset 35 for nrEngine/src


Ignore:
Timestamp:
04/16/07 17:04:29 (13 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/src
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • 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.