Ignore:
Timestamp:
03/30/2007 11:52:31 PM (12 years ago)
Author:
art
Message:

nrScript: using of subscripts is now possible

File:
1 edited

Legend:

Unmodified
Added
Removed
  • nrEngine/src/ResourceManager.cpp

    r25 r27  
    3131                std::string type; 
    3232                if (args.size() == 5 ) type = args[4]; 
    33                  
     33 
    3434                // load a resource with the given name in a group from a file 
    3535                if (Engine::sResourceManager()->loadResource(args[1], args[2], args[3], type).isNull()) 
     
    3939                        return ScriptResult(std::string(msg)); 
    4040                } 
    41                  
     41 
    4242                return ScriptResult(); 
    4343        } 
     
    5858                        return ScriptResult(std::string(msg)); 
    5959                } 
    60                  
     60 
    6161                return ScriptResult(); 
    6262        } 
     
    6969                Engine::sScriptEngine()->add("loadResource", scriptLoadResource); 
    7070                Engine::sScriptEngine()->add("unloadResource", scriptUnloadResource); 
    71                  
     71 
    7272        } 
    7373 
     
    7979                Engine::sScriptEngine()->del("loadResource"); 
    8080                Engine::sScriptEngine()->del("unloadResource"); 
    81                  
     81 
    8282                // unload all resources 
    8383                removeAllRes(); 
     
    197197 
    198198                NR_Log(Log::LOG_ENGINE, "ResourceManager: Remove loader %s", name.c_str()); 
    199                  
     199 
    200200                mLoader.erase(name); 
    201201 
     
    207207 
    208208                if (fileType.length() == 0) return ResourceLoader(); 
    209                  
     209 
    210210                // scan through all loaders and ask them if they do support this kind of file type 
    211211                loader_map::const_iterator it; 
     
    255255        { 
    256256                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                  
     257 
    258258                // check if such a resource already exists 
    259259                IResourcePtr pRes = getByName(name); 
     
    262262                        return pRes; 
    263263                } 
    264                  
     264 
    265265                // Get appropriate loader/creator 
    266266                ResourceLoader creator = getLoaderByResource(resourceType); 
     
    272272                // now call the loader to create a resource 
    273273                SharedPtr<IResource> res (creator->create(name, group, resourceType, params)); 
    274                 if (res.get() == NULL){ 
     274                if (res.get() == NULL) 
     275                { 
    275276                        NR_Log(Log::LOG_ENGINE, "ResourceManager: Can not create a resource %s of %s type", name.c_str(), resourceType.c_str()); 
    276277                        return IResourcePtr(); 
     
    280281                SharedPtr<ResourceHolder>& holder = *getHolderByName(name); 
    281282                NR_ASSERT(holder != NULL && "Holder must be valid here!"); 
    282                  
     283 
    283284                return IResourcePtr(holder); 
    284285        } 
    285          
     286 
    286287 
    287288        //---------------------------------------------------------------------------------- 
     
    330331                SharedPtr<IResource> res = loader->load(name, group, fileName, resourceType, params); 
    331332                if (res == NULL) return IResourcePtr(); 
    332                  
     333 
    333334                // get the holder for this resource, it must be there 
    334335                SharedPtr<ResourceHolder>& holder = *getHolderByName(name); 
    335336                NR_ASSERT(holder.get() != NULL && "Holder must be valid here!"); 
    336                  
    337                 return IResourcePtr(holder);     
    338         } 
    339          
     337 
     338                return IResourcePtr(holder); 
     339        } 
     340 
    340341        //---------------------------------------------------------------------------------- 
    341342        Result ResourceManager::unload(const ::std::string& name){ 
     
    635636        } 
    636637*/ 
    637          
     638 
    638639        //---------------------------------------------------------------------------------- 
    639640        Result ResourceManager::lockPure(const ::std::string& name){ 
     
    796797                // check if such a group exists 
    797798                res_grp_map::const_iterator it = mResourceGroup.find(name); 
    798                  
    799                 // return the empty list  
     799 
     800                // return the empty list 
    800801                if (it == mResourceGroup.end()) 
    801802                        return mEmptyResourceGroupHandleList; 
    802                          
    803                 // return the group to this name  
     803 
     804                // return the group to this name 
    804805                return it->second; 
    805806        } 
    806          
     807 
    807808        //---------------------------------------------------------------------------------- 
    808809        SharedPtr<IResource> ResourceManager::getEmpty(const std::string& type) 
     
    816817                return it->second; 
    817818        } 
    818                  
     819 
    819820        //---------------------------------------------------------------------------------- 
    820821        void ResourceManager::setEmpty(const std::string& type, SharedPtr<IResource> empty) 
     
    822823                // check if empty is valid 
    823824                if (empty == NULL) return; 
    824                  
     825 
    825826                // setup some default data on it 
    826827                mEmptyResource[type] = empty; 
     
    847848                const ResourceHandle& handle = res->getResHandle(); 
    848849                const std::string& type = res->getResType(); 
    849                   
     850 
    850851                // get according empty resource object and give exception if no such exists 
    851852                IResource* empty = getEmpty(type).get(); 
    852                 if (empty == NULL){ 
     853                if (empty == NULL) 
     854                { 
    853855                        char msg[128]; 
    854856                        sprintf(msg, "There was no empty resource created for the type %s", type.c_str()); 
    855857                        NR_EXCEPT(RES_NO_EMPTY_RES_FOUND, std::string(msg), "ResourceManager::notifyLoaded()"); 
    856858                } 
    857                  
     859 
    858860                // get name of the resource and create a holder for this 
    859861                SharedPtr<ResourceHolder> holder(new ResourceHolder(res, empty)); 
     
    864866                mResourceName[name] = handle; 
    865867 
    866                 //printf("LOADED: %s\n", holder->getResource()->getResName().c_str());           
     868                //printf("LOADED: %s\n", holder->getResource()->getResName().c_str()); 
    867869        } 
    868870 
     
    926928                mResource.erase(handle); 
    927929        } 
    928          
     930 
    929931}; 
    930932 
Note: See TracChangeset for help on using the changeset viewer.