Changeset 15 for nrEngine/src


Ignore:
Timestamp:
12/23/06 20:44:49 (14 years ago)
Author:
art
Message:
 
Location:
nrEngine/src
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • nrEngine/src/EventActor.cpp

    r1 r15  
    5050        }*/ 
    5151         
     52        //------------------------------------------------------------------------ 
     53        Result EventActor::emit(SharedPtr<Event> event) 
     54        { 
     55                // iterate through channels and emit messages 
     56                std::list<std::string>::iterator it = mChannel.begin(); 
     57                for (; it != mChannel.end(); it++) 
     58                { 
     59                        Result res = Engine::sEventManager()->emit(*it, event); 
     60                        if (res != OK)  
     61                        { 
     62                                NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "EventActor: Cannot emit message to '%s'", it->c_str()); 
     63                                return res; 
     64                        } 
     65                } 
     66                return OK; 
     67        } 
     68 
    5269        //------------------------------------------------------------------------ 
    5370        Result EventActor::connect (const std::string& name) 
  • nrEngine/src/FileStreamLoader.cpp

    r1 r15  
    2323        FileStreamLoader::FileStreamLoader() : IResourceLoader("FileStreamLoader") 
    2424        { 
    25                 initialize(); 
     25                initializeResourceLoader(); 
    2626        } 
    2727 
     
    3434 
    3535        //---------------------------------------------------------------------------------- 
    36         Result FileStreamLoader::initialize(){ 
     36        Result FileStreamLoader::initializeResourceLoader(){ 
    3737                 
    3838                // fill out supported resource types; 
     
    4343         
    4444        //---------------------------------------------------------------------------------- 
    45         Result FileStreamLoader::loadImpl(IResource* res, const std::string& fileName, PropertyList* param) 
     45        Result FileStreamLoader::loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param) 
    4646        { 
    4747                // create a pointer to the stream object and open the file 
     
    5252 
    5353        //---------------------------------------------------------------------------------- 
    54         IResource* FileStreamLoader::createImpl(const std::string& resourceType, PropertyList* params) 
     54        IResource* FileStreamLoader::createResourceImpl(const std::string& resourceType, PropertyList* params) 
    5555        { 
    5656                // create an plugin instance 
     
    6060 
    6161        //---------------------------------------------------------------------------------- 
    62         IResource* FileStreamLoader::createEmpty(const std::string& resourceType) 
     62        IResource* FileStreamLoader::createEmptyResource(const std::string& resourceType) 
    6363        { 
    6464                // create an instance of empty plugin 
  • nrEngine/src/Makefile

    r13 r15  
    5454TARGET=  libnrEngine.so 
    5555INCPATH += -I../include 
    56 CFLAGS += -fPIC 
     56CFLAGS += -fPIC -g 
    5757LIBS += -ldl 
    5858 
  • nrEngine/src/PluginLoader.cpp

    r1 r15  
    3939        PluginLoader::PluginLoader() : IResourceLoader("PluginLoader") 
    4040        { 
    41                 initialize(); 
     41                initializeResourceLoader(); 
    4242                 
    4343                // register some new functions by the scripting engine 
     
    5555         
    5656        //---------------------------------------------------------------------------------- 
    57         Result PluginLoader::initialize(){ 
     57        Result PluginLoader::initializeResourceLoader(){ 
    5858 
    5959                // fill out supported resource types; 
     
    7373                 
    7474        //---------------------------------------------------------------------------------- 
    75         Result PluginLoader::loadImpl(IResource* res, const std::string& fileName, PropertyList* param) 
     75        Result PluginLoader::loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param) 
    7676        { 
    7777 
     
    121121         
    122122        //---------------------------------------------------------------------------------- 
    123         Result PluginLoader::unloadImpl(IResource* resource) 
     123        Result PluginLoader::unloadResourceImpl(IResource* resource) 
    124124        { 
    125125 
     
    148148         
    149149        //---------------------------------------------------------------------------------- 
    150         IResource* PluginLoader::createImpl(const std::string& resourceType, PropertyList* params) 
     150        IResource* PluginLoader::createResourceImpl(const std::string& resourceType, PropertyList* params) 
    151151        {        
    152152                // create an plugin instance 
     
    156156         
    157157        //---------------------------------------------------------------------------------- 
    158         IResource* PluginLoader::createEmpty(const std::string& resourceType) 
     158        IResource* PluginLoader::createEmptyResource(const std::string& resourceType) 
    159159        { 
    160160                // create an instance of empty plugin 
  • nrEngine/src/Resource.cpp

    r1 r15  
    2929                mResIsEmpty = false; 
    3030                mResDataSize = sizeof(*this); 
    31                 mResLoader = NULL; 
     31                //mResLoader = NULL; 
    3232                setResourceType(resType); 
    3333        } 
     
    3737        { 
    3838                // check for valid loader 
    39                 if (mResLoader != NULL) 
     39                /*if (mResLoader != NULL) 
    4040                { 
    4141                        // notify the parent loader, that the resource object will be removed now 
    42                         mResLoader->unload(this); 
    43                         mResLoader->notifyRemoveResource(this); 
    44                 } 
     42                        mResLoader->remove(this); 
     43                }*/ 
     44                 
     45                // notify the manager, that this resource was  
    4546        } 
    4647 
     
    4849        Result IResource::unloadRes() 
    4950        { 
    50                 if (mResLoader) mResLoader->notifyUnloadResource(this); 
     51                //if (mResLoader) mResLoader->notifyUnloadResource(this); 
    5152                return OK; 
    5253        } 
    5354 
    54          
    5555        //---------------------------------------------------------------------------------- 
    5656        Result IResource::unloadResThroughLoader() 
     
    6363                        NR_EXCEPT(RES_LOADER_NOT_EXISTS, msg, "IResource::~IResource()"); 
    6464                } 
    65                 return mResLoader->unload(this); 
     65                return mResLoader->unload(getSharedPtrFromThis()); 
    6666        } 
    6767 
     
    7676                        NR_EXCEPT(RES_LOADER_NOT_EXISTS, msg, "IResource::~IResource()"); 
    7777                } 
    78                 return mResLoader->reload(this); 
     78                return mResLoader->reload(getSharedPtrFromThis()); 
    7979        } 
    8080 
     
    8989                        NR_EXCEPT(RES_LOADER_NOT_EXISTS, msg, "IResource::~IResource()"); 
    9090                } 
    91                 return mResLoader->remove(this); 
     91                return mResLoader->remove(getSharedPtrFromThis()); 
    9292        } 
    93  
    9493}; 
    9594 
  • 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()); 
  • nrEngine/src/ResourceManager.cpp

    r1 r15  
    191191 
    192192                // get id of the loader 
    193                 loader_map::const_iterator jt = mLoader.find(name); 
     193                loader_map::iterator jt = mLoader.find(name); 
    194194                if (jt == mLoader.end()){ 
    195195                        return RES_LOADER_NOT_REGISTERED; 
     
    197197 
    198198                NR_Log(Log::LOG_ENGINE, "ResourceManager: Remove loader %s", name.c_str()); 
    199  
     199                 
    200200                mLoader.erase(name); 
    201201 
     
    271271 
    272272                // now call the loader to create a resource 
    273                 IResource* res (creator->create(name, group, resourceType, params)); 
    274                 if (res == NULL){ 
     273                SharedPtr<IResource> res (creator->create(name, group, resourceType, params)); 
     274                if (res.get() == NULL){ 
    275275                        NR_Log(Log::LOG_ENGINE, "ResourceManager: Can not create a resource %s of %s type", name.c_str(), resourceType.c_str()); 
    276276                        return IResourcePtr(); 
     
    328328                // now call the loader to create a resource 
    329329                // loader will notify the manager, manager will add it into database 
    330                 IResource* res = loader->load(name, group, fileName, resourceType, params); 
     330                SharedPtr<IResource> res = loader->load(name, group, fileName, resourceType, params); 
    331331                if (res == NULL) return IResourcePtr(); 
    332332                 
     
    348348 
    349349                lockPure(res); 
    350                         NR_Log(Log::LOG_ENGINE, "ResourceManager: Unload resource %s", 
    351                                 res->getResName().c_str(), res->getResHandle()); 
     350                        NR_Log(Log::LOG_ENGINE, "ResourceManager: Unload resource %s", res->getResName().c_str(), res->getResHandle()); 
    352351                        Result ret = res->unloadResThroughLoader(); 
    353352                unlockPure(res); 
  • nrEngine/src/ScriptLoader.cpp

    r1 r15  
    2525        ScriptLoader::ScriptLoader() : IResourceLoader("ScriptLoader") 
    2626        { 
    27                 initialize(); 
     27                initializeResourceLoader(); 
    2828        } 
    2929 
     
    3636 
    3737        //---------------------------------------------------------------------------------- 
    38         Result ScriptLoader::initialize(){ 
     38        Result ScriptLoader::initializeResourceLoader(){ 
    3939                // fill out supported resource types; 
    4040                declareSupportedResourceType("Script"); 
     
    5353 
    5454        //---------------------------------------------------------------------------------- 
    55         Result ScriptLoader::loadImpl(IResource* res, const std::string& fileName, PropertyList* param) 
     55        Result ScriptLoader::loadResourceImpl(IResource* res, const std::string& fileName, PropertyList* param) 
    5656        { 
    5757                // load a file so we use its content as a script 
     
    7878 
    7979        //---------------------------------------------------------------------------------- 
    80         IResource* ScriptLoader::createImpl(const std::string& resourceType, PropertyList* params) 
     80        IResource* ScriptLoader::createResourceImpl(const std::string& resourceType, PropertyList* params) 
    8181        { 
    8282                // check if we want to create just a script 
     
    9494 
    9595        //---------------------------------------------------------------------------------- 
    96         IResource* ScriptLoader::createEmpty(const ::std::string& resourceType) 
     96        IResource* ScriptLoader::createEmptyResource(const ::std::string& resourceType) 
    9797        { 
    9898                // create an instance of empty plugin 
Note: See TracChangeset for help on using the changeset viewer.