Changeset 25


Ignore:
Timestamp:
03/22/07 18:15:54 (12 years ago)
Author:
art
Message:
 
Location:
nrEngine
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • nrEngine/include/Clock.h

    r23 r25  
    270270                // time source 
    271271                SharedPtr<TimeSource>   timeSource; 
     272                SharedPtr<TimeSource>   realTimeSource; 
    272273                float64         currentTime; 
    273274                float64         frameTime; 
     
    292293                float64 sourceStartValue; 
    293294                float64 sourceLastValue; 
    294          
     295                float64 sourceLastRealValue; 
     296                 
    295297                // Next time when the clock has to be synced with system time 
    296298                float64 nextSyncTime; 
  • nrEngine/include/Resource.h

    r15 r25  
    7373                * so it contains in the memory and has it's full data there. 
    7474                **/ 
    75                 NR_FORCEINLINE bool                             isResLoaded() const {return mResIsLoaded;} 
     75                NR_FORCEINLINE bool                     isResLoaded() const {return mResIsLoaded;} 
    7676 
    7777                /** 
     
    134134                virtual Result unloadRes(); 
    135135 
     136                /** 
     137                 * Reload resource. Each resource object should be able to reload itself 
     138                 * from the disk or other media. It can use the assigned loader to load files 
     139                 * or to make it by itself. At the end the resource should be marked as loaded. 
     140                 * 
     141                 * Do here resource specific stuff. The method will be called by the loader, 
     142                 * so you do not have to notify the loader about this event. 
     143                 **/ 
     144                virtual Result reloadRes(); 
     145                 
    136146                /** 
    137147                 * Loader will notify the resource that it has been restored. 
  • nrEngine/include/Script.h

    r24 r25  
    148148                        int32 mLastLine; 
    149149 
     150                        //! Current running time of the script 
     151                        //float32 mRunningTime; 
     152                         
     153                        //! Time script have to stop after this duration 
     154                        float32 mRunningTimeLength; 
     155                         
     156                        //! Time when script started  
     157                        float32 mStopTime; 
     158                         
    150159                        //! Run teh script stepwise 
    151160                        bool bRunStepwise; 
     
    196205                        //! Current time of the script 
    197206                        float32 mTime; 
    198  
    199                         //! This is our reset time, used to start time counting from beginning 
    200                         float32 mResetTime; 
    201207                         
    202208                        //! Run only one step from the script 
  • nrEngine/src/Clock.cpp

    r23 r25  
    6868                sourceStartValue = 0; 
    6969                sourceLastValue = 0; 
     70                sourceLastRealValue = 0; 
    7071                 
    7172                useFixRate = false; 
     
    8081                 
    8182                timeSource.reset(); 
    82  
     83                realTimeSource.reset(new TimeSource()); 
     84                 
    8385                // setup some other values 
    8486                nextSyncTime = 0; 
     
    362364                 
    363365                float64 sourceTime = timeSource->getTime(); 
    364                 realFrameTime = sourceTime - sourceLastValue; 
     366                float64 sourceRealTime = realTimeSource->getTime(); 
     367                 
     368                realFrameTime = sourceRealTime - sourceLastRealValue; 
     369                 
    365370                sourceLastValue = sourceTime; 
     371                sourceLastRealValue = sourceRealTime; 
    366372                 
    367373                /*if (frameDuration > 0.200){ 
  • nrEngine/src/Resource.cpp

    r15 r25  
    5252                return OK; 
    5353        } 
     54         
     55        //---------------------------------------------------------------------------------- 
     56        Result IResource::reloadRes() 
     57        { 
     58                //if (mResLoader) mResLoader->notifyUnloadResource(this); 
     59                return OK; 
     60        } 
    5461 
    5562        //---------------------------------------------------------------------------------- 
  • nrEngine/src/ResourceLoader.cpp

    r15 r25  
    223223                // unload the resource 
    224224                unload(resource); 
    225  
    226                 // now reload the resource and go back 
    227                 return reloadResourceImpl(resource.get()); 
     225                 
     226                // call the implementation of the unloader 
     227                if (resource->mResIsLoaded == false) 
     228                { 
     229                         
     230                        Result ret = reloadResourceImpl(resource.get()); 
     231                        if (ret != OK) return ret; 
     232                 
     233                        // now mark the resource that it has been unloaded 
     234                        resource->mResIsLoaded = true; 
     235                         
     236                        // notify the resource manager about unloading the resource 
     237                        Engine::sResourceManager()->notifyLoaded(resource.get()); 
     238                } 
     239 
     240                return OK; 
    228241        } 
    229242 
     
    290303        { 
    291304                if (res == NULL) return OK; 
    292                 Result ret = loadResourceImpl(res, res->getResFileName(), NULL); 
     305                /*Result ret = loadResourceImpl(res, res->getResFileName(), NULL); 
    293306                if (ret != OK){ 
    294307                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "ResourceLoader %s can not load resource from file %s", mName.c_str(), res->getResFileName().c_str()); 
    295308                        return ret; 
    296                 } 
    297                 res->mResIsLoaded = true; 
     309                }*/ 
     310                if (res->mResIsLoaded == false) res->reloadRes(); 
     311                //res->mResIsLoaded = true; 
    298312 
    299313                // now notify the resource manager, that a new resource was loaded 
    300                 Engine::sResourceManager()->notifyLoaded(res); 
    301                                  
    302                 return ret; 
     314                //Engine::sResourceManager()->notifyLoaded(res); 
     315                 
     316                return OK; 
    303317        } 
    304318         
  • nrEngine/src/ResourceManager.cpp

    r16 r25  
    847847                const ResourceHandle& handle = res->getResHandle(); 
    848848                const std::string& type = res->getResType(); 
    849                                  
     849                  
    850850                // get according empty resource object and give exception if no such exists 
    851851                IResource* empty = getEmpty(type).get(); 
  • nrEngine/src/Script.cpp

    r24 r25  
    3030                mTime = 0; 
    3131                bRunStepwise = true; 
    32                 mResetTime = 0; 
     32                mStopTime = 0; 
     33                mRunningTimeLength = 0; 
    3334        } 
    3435 
     
    117118                                        if (cmd.args.size() > 0 && cmd.args[0].length() > 0) 
    118119                                        { 
    119                                                 mTimedCommand.push_back(cmd); 
     120                                                if (cmd.cmd == std::string("_stop_")) 
     121                                                { 
     122                                                        mRunningTimeLength = cmd.timestamp; 
     123                                                }else 
     124                                                        mTimedCommand.push_back(cmd); 
    120125                                        } 
    121126                                }catch(...){ 
     
    211216                // the estimated end time is also computed 
    212217                mTimedCommandFifo.clear(); 
    213                 for (uint32 i=0; i < mTimedCommand.size(); i++){ 
     218                for (uint32 i=0; i < mTimedCommand.size(); i++) 
     219                { 
    214220                        mTimedCommandFifo.push_front(i); 
    215221                        mTimedCommand[i].estimatedStart = Engine::sClock()->getTime() + mTimedCommand[i].timestamp; 
     
    222228                // update time 
    223229                mTime = Engine::sClock()->getTime(); 
    224  
     230                if (mStopTime == 0 && mRunningTimeLength > 0) 
     231                        mStopTime = mTime + mRunningTimeLength; 
     232                         
    225233                // ----- timed commands (quasi parallel execution) ----- 
    226234                // scan through the command fifo 
     
    239247                                it = mTimedCommandFifo.erase(it); 
    240248 
    241                                 // check if we have a stop commando 
    242                                 if (mTimedCommand[id].cmd != std::string("_stop_")) 
    243                                 { 
    244                                         Engine::sScriptEngine()->call(mTimedCommand[id].cmd, mTimedCommand[id].args); 
    245                                 }else{ 
    246                                         Engine::sKernel()->RemoveTask(this->getTaskID()); 
    247                                 } 
    248  
     249                                // call the commando 
     250                                Engine::sScriptEngine()->call(mTimedCommand[id].cmd, mTimedCommand[id].args); 
    249251                        }else 
    250252                                it ++; 
    251  
    252253                } 
    253254                 
     
    275276                // reset the command list 
    276277                reset(); 
     278 
     279                // check whenever execution time of the script exceeds 
     280                if (mTime > mStopTime && mStopTime > 0) 
     281                { 
     282                                Engine::sKernel()->RemoveTask(this->getTaskID()); 
     283                } 
    277284 
    278285                return OK; 
  • nrEngine/src/ScriptEngine.cpp

    r23 r25  
    226226                        return ScriptResult(); 
    227227                } 
    228                 NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "ScriptEngine: Call \"%s\" function!", name.c_str()); 
     228                 
     229                // debug information  
     230                std::string msg; 
     231                for (unsigned int i=1; i < args.size(); i++) msg += std::string(" ") + args[i]; 
     232                NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "ScriptEngine: Call \"%s (%s)\" function!", name.c_str(), msg.c_str()); 
    229233 
    230234                // call the function 
Note: See TracChangeset for help on using the changeset viewer.