Changeset 34


Ignore:
Timestamp:
04/12/07 16:01:33 (12 years ago)
Author:
art
Message:
 
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • Plugins/dynamicResources/Monitor.cpp

    r32 r34  
    7070        { 
    7171                mInotify.reset(new Inotify()); 
    72                 //mInotify->SetNonBlock(true); 
     72                mInotify->SetNonBlock(true); 
    7373        }catch(InotifyException& e) 
    7474        { 
     
    132132                try 
    133133                { 
    134                         // create watcher 
    135                         SharedPtr<InotifyWatch> watch(new InotifyWatch(file, IN_MODIFY)); 
     134                        // first check if such a watcher already exists 
     135                        InotifyWatch* watch = mInotify->FindWatch(file); 
     136                         
     137                        if (watch == NULL) 
     138                        { 
     139                                watch = new InotifyWatch(file, IN_MODIFY); 
     140                                mInotify->Add(watch); 
     141                        } 
    136142                         
    137143                        // add new watcher 
     
    143149                        data.watcher = watch; 
    144150                        data.resourceName = res.getBase()->getResName(); 
    145                         mWatchMap[watch->GetDescriptor()] = data; 
    146                          
    147                         // add the new watch  
    148                         mInotify->Add(watch.get()); 
     151                        mWatchMap[watch->GetDescriptor()].push_back(data); 
    149152                         
    150153                }catch(InotifyException& e) 
     
    177180        if (!mInotify) return OK; 
    178181         
    179         printf("update\n"); 
     182        //printf("update\n"); 
    180183        // wait for inotify events 
    181184        try{ 
    182                 mInotify->WaitForEvents(); 
     185                mInotify->WaitForEvents(true); 
    183186        }catch(InotifyException& e) 
    184187        { 
     
    187190                return OK; 
    188191        } 
    189         printf("ok\n"); 
     192        //printf("ok\n"); 
    190193         
    191194        // now extract events until there are no more of them  
     
    196199                try 
    197200                { 
     201                        // get event 
    198202                        mInotify->GetEvent(&event); 
    199                         WatchData& data = mWatchMap[event.GetDescriptor()]; 
    200                          
    201                         if (data.resource.valid()) 
     203                        std::list<WatchData>& data = mWatchMap[event.GetDescriptor()]; 
     204                         
     205                        // go through a list and update all resource combined with them 
     206                        std::list<WatchData>::iterator it = data.begin(); 
     207                        for (; it != data.end(); it++) 
    202208                        { 
    203                                 data.resource.lockPure(); 
    204                                         printf("modified: %s\n", data.resource.getBase()->getResName().c_str()); 
    205                                 data.resource.unlockPure(); 
    206                         }else{ 
    207                                 NR_Log(Log::LOG_PLUGIN, Log::LL_WARNING, "dynamicResources: Monitored %s resource is not valid!", data.resourceName.c_str()); 
     209                                if (it->resource.valid()) 
     210                                { 
     211                                        // do only reloading on non-empty resources 
     212                                        it->resource.lockPure(); 
     213                                                mRoot->sResourceManager()->reload(it->resource); 
     214                                                NR_Log(Log::LOG_PLUGIN, Log::LL_CHATTY, "dynamicResources: Monitored %s resource was modified, so reload it!", it->resourceName.c_str()); 
     215                                        it->resource.unlockPure(); 
     216                                }else{ 
     217                                        NR_Log(Log::LOG_PLUGIN, Log::LL_WARNING, "dynamicResources: Monitored %s resource is not valid!", it->resourceName.c_str()); 
     218                                } 
     219                         
    208220                        } 
    209221                } 
  • Plugins/dynamicResources/Monitor.h

    r32 r34  
    7777                        { 
    7878                                IResourcePtr resource; 
    79                                 SharedPtr<InotifyWatch> watcher; 
     79                                InotifyWatch* watcher; 
    8080                                std::string resourceName; 
    8181                        } WatchData; 
    8282                         
    8383                        //! Define map type for appropriate storing of watch descriptors 
    84                         typedef std::map<int, WatchData > WatcherMap; 
     84                        typedef std::map<int, std::list<WatchData> > WatcherMap; 
    8585                         
    8686                        //! Here we store the watching descriptors for the files 
  • Plugins/luaScripting/Script.cpp

    r27 r34  
    6767Result LuaScript::loadFromString(const std::string& str) 
    6868{ 
    69         static bool loaded = false; 
     69        bool loaded = false; 
    7070 
    7171        // load lua from string 
     
    116116Result LuaScript::unloadRes() 
    117117{ 
    118         if (isResLoaded()) 
     118        /*if (isResLoaded()) 
    119119        { 
    120120                luaL_unref(State, LUA_REGISTRYINDEX, mFuncRef); 
    121121                mFuncRef = LUA_NOREF; 
    122         } 
    123  
     122        }*/ 
     123 
     124        return OK; 
     125} 
     126 
     127//---------------------------------------------------------------------------------- 
     128Result LuaScript::reloadRes() 
     129{ 
     130        /*if (!isResLoaded()) 
     131        { 
     132                return loadFromString(mContent); 
     133        }*/ 
    124134        return OK; 
    125135} 
  • Plugins/luaScripting/Script.h

    r23 r34  
    8080                Result unloadRes(); 
    8181                 
     82                /** 
     83                 * Reload the Script 
     84                 **/ 
     85                Result reloadRes(); 
     86                 
    8287                //! Does always return false, because lua scripts are running completely once  
    8388                bool hasCommands() { return false; } 
  • nrEngine/include/IScript.h

    r27 r34  
    338338                //! Executing of empty script does return immideately 
    339339                Result run(); 
    340  
    341340        private: 
    342341                bool hasCommands() { return false; } 
  • nrEngine/include/ResourceHolder.h

    r33 r34  
    8989                        int32           mLockStackTop; 
    9090                         
     91                        //! Empty lock status 
     92                        bool mEmptyLockStack[NR_RESOURCE_LOCK_STACK]; 
     93                         
     94                        //! Position in empty locking state  
     95                        int32 mEmptyLockStackTop; 
     96                         
    9197                        /** 
    9298                        * Lock real resource for using. Locking has the effect that the getResource() method 
     
    110116                         
    111117                        /** 
     118                         * Lock an empty resource to be used even if a real resource is loaded. 
     119                         * This method can be used to temporary point all pointers to  
     120                         * an empty resource instead of a real one. 
     121                         * 
     122                         * If you lock an empty and pure/real resource at the same time, 
     123                         * so warning will be generated and an empty resource will be given 
     124                         * @see lockPure(); 
     125                         **/ 
     126                        bool lockEmpty(); 
     127                         
     128                        /** 
     129                        * Unlock from an empty resource and switch to the case before the lock was done 
     130                        **/ 
     131                        void unlockEmpty(); 
     132                         
     133                        /** 
    112134                        * Reset the stored resource to a new value 
    113135                        **/ 
     
    143165                                if (mLockStackTop > 0)  
    144166                                        return mLockStack[mLockStackTop - 1]; 
     167                                else 
     168                                        return false; 
     169                        } 
     170                         
     171                        /** 
     172                        * Check whenever the resource is currently locked to an empty resource 
     173                        **/ 
     174                        NR_FORCEINLINE bool isEmptyLocked() 
     175                        { 
     176                                if (mEmptyLockStackTop > 0)  
     177                                        return mEmptyLockStack[mEmptyLockStackTop - 1]; 
    145178                                else 
    146179                                        return false; 
  • nrEngine/include/ResourceManager.h

    r33 r34  
    363363                        //! @see remove(name) 
    364364                        Result          remove(ResourceHandle& handle); 
    365          
    366          
     365                 
    367366                        /** 
    368367                        * Get the pointer to a resource by it's name. 
  • nrEngine/include/ResourcePtr.h

    r32 r34  
    115115                        *       - RES_LOCK_STATE_STACK_IS_FULL if we are not able to lock anymore 
    116116                        **/ 
    117                         virtual Result lockPure(); 
     117                        Result lockPure(); 
    118118 
    119119 
     
    124124                        * @return either OK or RES_PTR_IS_NULL if this pointer is null 
    125125                        **/ 
    126                         virtual Result unlockPure(); 
    127  
    128  
    129                         /** 
    130                         * Access to the resource to which one this pointer points. This access need 
    131                         * 1 static_cast, 3 function calls until it returns the resource. 
    132                         * So this function is running in O(1) and is pretty efficient 
    133                         **/ 
    134                         virtual IResource* getBase() const; 
     126                        Result unlockPure(); 
     127 
     128 
     129                        /** 
     130                        * Lock an empty resource, so that even if resource is loaded, empty resource will 
     131                        * be used. 
     132                        * @see lockPure() 
     133                        **/ 
     134                        Result lockEmpty(); 
     135                         
     136                        /** 
     137                        * Unlock empty resource 
     138                        **/ 
     139                        Result unlockEmpty(); 
     140                         
     141                        /** 
     142                        * Access to the resource to which one this pointer points. This access need 
     143                        * 1 static_cast, 3 function calls until it returns the resource. 
     144                        * So this function is running in O(1) and is pretty efficient 
     145                        **/ 
     146                        IResource* getBase() const; 
    135147 
    136148 
  • nrEngine/src/IScript.cpp

    r27 r34  
    159159        Result IScript::callfunc(const std::string& funcName, ScriptResult& result) 
    160160        { 
    161                 // remove all parameters from the stack 
    162                 std::string type, value; 
    163                 while (popArgument(funcName, type, value) > 0){} 
    164  
    165                 // return ok 
    166161                return OK; 
    167162        } 
     
    210205        } 
    211206 
     207 
    212208}; // end namespace 
    213209 
  • nrEngine/src/ResourceHolder.cpp

    r33 r34  
    3535                         
    3636                // empty the lock stack 
    37                 for (int32 i=0; i < NR_RESOURCE_LOCK_STACK; i++) 
    38                         mLockStack[i] = false; 
    39                          
     37                for (int32 i=0; i < NR_RESOURCE_LOCK_STACK; i++) mLockStack[i] = false; 
    4038                mLockStackTop = 0; 
    4139         
     40                // empty the lock stack 
     41                for (int32 i=0; i < NR_RESOURCE_LOCK_STACK; i++) mEmptyLockStack[i] = false; 
     42                mEmptyLockStackTop = 0; 
    4243        } 
    4344                 
     
    4546        bool ResourceHolder::lockPure() 
    4647        { 
     48                // check if resource is already locked 
     49                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()); 
     51                else if (isEmptyLocked() && !mResource) 
     52                        NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "You are trying to lock real resource while empty resource is locked. Empty stay locked"); 
     53         
    4754                // check whenever we've got the maximum, so do not lock 
    4855                if (mLockStackTop >= NR_RESOURCE_LOCK_STACK){ 
     
    7380                } 
    7481        } 
     82 
     83        //---------------------------------------------------------------------------------- 
     84        bool ResourceHolder::lockEmpty() 
     85        { 
     86                // check if resource is already locked 
     87                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()); 
     89                else if (isLocked() && !mResource) 
     90                        NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "You are trying to lock empty resource while real resource is locked. Empty will be used"); 
     91                  
     92                // check whenever we've got the maximum, so do not lock 
     93                if (mEmptyLockStackTop >= NR_RESOURCE_LOCK_STACK) 
     94                { 
     95                        if (mResource) 
     96                        { 
     97                                NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG,  
     98                                        "Can not lock %s anymore. Lock state stack is full!", mResource->getResName().c_str());  
     99                        }else{ 
     100                                NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG,  
     101                                        "Can not lock anymore. Lock state stack is full!"); 
     102                        } 
     103                        return false; 
     104                }else{ 
     105                        // lock it 
     106                        mEmptyLockStack[mEmptyLockStackTop++] = true; 
     107                } 
     108                 
     109                return true; 
     110        }        
    75111                 
    76112        //---------------------------------------------------------------------------------- 
    77         void ResourceHolder::resetRes(IResource* res){ 
     113        void ResourceHolder::unlockEmpty() 
     114        { 
     115                // check whenever we've got right top position 
     116                if (mEmptyLockStackTop > 0){ 
     117                        // unlock it 
     118                        mEmptyLockStack[--mEmptyLockStackTop] = false; 
     119                } 
     120        } 
     121 
     122        //---------------------------------------------------------------------------------- 
     123        void ResourceHolder::resetRes(IResource* res) 
     124        { 
    78125                mResource = (res); 
    79126        } 
     
    81128         
    82129        //---------------------------------------------------------------------------------- 
    83         void ResourceHolder::setEmptyResource(IResource* res){ 
     130        void ResourceHolder::setEmptyResource(IResource* res) 
     131        { 
    84132                mEmptyResource = (res); 
    85133        } 
    86          
     134                 
    87135        //---------------------------------------------------------------------------------- 
    88         /*void ResourceHolder::setEmptyResource(SharedPtr<IResource> res){ 
    89                 mEmptyResource = res; 
    90         }*/ 
    91  
    92          
    93         //---------------------------------------------------------------------------------- 
    94         IResource* ResourceHolder::getEmpty(){ 
     136        IResource* ResourceHolder::getEmpty() 
     137        { 
    95138                return mEmptyResource; 
    96139        } 
     
    98141                 
    99142        //---------------------------------------------------------------------------------- 
    100         IResource* ResourceHolder::getResource(){ 
     143        IResource* ResourceHolder::getResource() 
     144        { 
     145                NR_ASSERT(getEmpty() != NULL && "Empty resource must be defined"); 
    101146                 
    102147                // touch the resource 
    103148                touchResource(); 
    104149 
     150                // check if empty is locked, then return empty resource 
     151                if (isEmptyLocked()) return getEmpty(); 
     152                 
    105153                // get resource only if it is exists and loaded or if it exists and locked 
    106                 if (mResource!=NULL){ 
     154                if (mResource!=NULL) 
     155                { 
     156                        // check if we have locked to an empty resource 
    107157                        if (mResource->isResLoaded() || isLocked()){ 
    108158                                return mResource; 
    109159                        } 
    110160                } 
    111  
    112                 NR_ASSERT(getEmpty() != NULL && "Empty resource must be defined"); 
    113161 
    114162                return getEmpty(); 
  • nrEngine/src/ResourcePtr.cpp

    r1 r34  
    7070         
    7171        //---------------------------------------------------------------------------------- 
    72         Result IResourcePtr::lockPure(){ 
     72        Result IResourcePtr::lockPure() 
     73        { 
    7374                if (!isNull()) 
    7475                        if (!getResourceHolder()->lockPure()) 
     
    8182 
    8283        //---------------------------------------------------------------------------------- 
    83         Result IResourcePtr::unlockPure(){ 
     84        Result IResourcePtr::unlockPure() 
     85        { 
    8486                if (!isNull()) 
    8587                        getResourceHolder()->unlockPure(); 
     88                else 
     89                        return RES_PTR_IS_NULL; 
     90                 
     91                return OK; 
     92        } 
     93         
     94        //---------------------------------------------------------------------------------- 
     95        Result IResourcePtr::lockEmpty() 
     96        { 
     97                if (!isNull()) 
     98                        if (!getResourceHolder()->lockEmpty()) 
     99                                return RES_LOCK_STATE_STACK_IS_FULL; 
     100                else 
     101                        return RES_PTR_IS_NULL; 
     102                         
     103                return OK; 
     104        } 
     105 
     106        //---------------------------------------------------------------------------------- 
     107        Result IResourcePtr::unlockEmpty() 
     108        { 
     109                if (!isNull()) 
     110                        getResourceHolder()->unlockEmpty(); 
    86111                else 
    87112                        return RES_PTR_IS_NULL; 
     
    95120                return mHolder->getResource(); 
    96121        } 
    97  
    98         //---------------------------------------------------------------------------------- 
    99         /*IResource& IResourcePtr::operator*() const{ 
    100                 NR_ASSERT(mHolder.get() != NULL && "Holder does not contain valid data"); 
    101                 return *mHolder->getResource(); 
    102         }*/ 
    103  
    104                  
    105122}; 
    106123 
Note: See TracChangeset for help on using the changeset viewer.