Ignore:
Timestamp:
12/23/06 20:44:49 (12 years ago)
Author:
art
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed
  • nrEngine/src/ResourceLoader.cpp

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