Changeset 34 for nrEngine/src


Ignore:
Timestamp:
04/12/07 16:01:33 (13 years ago)
Author:
art
Message:
 
Location:
nrEngine/src
Files:
3 edited

Legend:

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