Changeset 28 for nrEngine


Ignore:
Timestamp:
04/04/07 18:39:17 (12 years ago)
Author:
art
Message:
  • nrEngines scripting language support now subscripts
  • start_at parameter to scripts added (define starting time of a script/subscript)
  • subscripts inherit some paraemters from their parent scripts
Location:
nrEngine
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • nrEngine/include/ITimeObserver.h

    r23 r28  
    4040                 
    4141                // constructor & destructor 
    42                 ITimeObserver(){_observerID = 0;} 
     42                ITimeObserver() : _observerID(0) {} 
    4343                virtual ~ITimeObserver(){} 
    4444                 
  • nrEngine/include/ResourcePtr.h

    r17 r28  
    9090                        } 
    9191                 
    92                  
     92                        inline bool valid() const { 
     93                                return (mHolder.get() != NULL); 
     94                        } 
     95                         
    9396                        /** 
    9497                        * Lock the resource to which one this pointer points, to prevent using 
     
    209212                        ResourcePtr(const IResourcePtr& res) : IResourcePtr(res){} 
    210213                         
    211                                          
    212214                        /** 
    213215                        * Access to the resource to which one this pointer points. This access need 
  • nrEngine/include/Script.h

    r27 r28  
    141141 
    142142                        //! Set certain parameter from the script 
    143                         bool setParameter(const std::string& param); 
     143                        bool setParameter(const std::string& param, const std::vector<std::string>& args); 
    144144 
    145145                        //! Reset the sequentiall command fifo 
     
    147147 
    148148                        //! Reset the timed command fifo 
    149                         void resetTimedCommandFifo(); 
     149                        void resetTimedCommandFifo(bool firstReset = false); 
    150150 
    151151                        //! Tokenize the given line into command and arguments 
     
    163163                        //! Subscripts which belongs to this one 
    164164                        std::vector<ResourcePtr<IScript> > mSubscripts; 
    165  
    166                         //! Current running time of the script 
    167                         //float32 mRunningTime; 
    168165 
    169166                        //! Time script have to stop after this duration 
     
    221218                        //! Current time of the script 
    222219                        float32 mTime; 
    223  
     220                         
     221                        //! Does script run to the first time 
     222                        bool mFirstRunTimed; 
     223                         
     224                        //! Timer used by the script (usefull for timed commands) 
     225                        SharedPtr<Timer> mTimer; 
     226                         
     227                        //! Specified script starting time (ala absolute time start) 
     228                        float32 mScriptStartTime; 
     229                         
    224230                        //! Run only one step from the script 
    225231                        Result step(); 
  • nrEngine/include/TimeSource.h

    r22 r28  
    8585                * You do not have to call this method, clock will do it automaticaly, if 
    8686                * it is needed. 
     87                * @param startValue This value will be added to the default start value, which is normally 
     88                *  0. So specifying the startValue parameter modifies the time to which the source should reset. 
    8789                **/ 
    88                 virtual void reset(); 
     90                virtual void reset(float64 startValue = 0.0); 
    8991 
    9092                /** 
     
    117119                float64 _syncTime; 
    118120                 
     121                //! This is the reset value. The value is used to store time of reset point  
     122                float64 _resetTime; 
    119123        }; 
    120124         
  • nrEngine/include/TimeSourceVirtual.h

    r22 r28  
    5050                float64 getTime(); 
    5151 
     52                /** 
     53                 * Reset the time source. This will force the time source to coutn from 0. 
     54                 * Specify the startValue parameter to set the starting value of the time counter 
     55                 **/ 
     56                void reset(float64 startValue); 
     57                 
     58                 
    5259                void notifyNextFrame(); 
    5360                 
  • nrEngine/src/Clock.cpp

    r25 r28  
    3131                if (args.size() < 1) 
    3232                { 
    33                         return ScriptResult(std::string("resetClock([timeToReset = 0, [reset_all_timers = 0]]) - Not valid parameter count!")); 
     33                        return ScriptResult(std::string("resetClock([timeToReset = 0, [reset_all_timers = 1]]) - Not valid parameter count!")); 
    3434                } 
    3535 
     
    4747                 
    4848                // get parameters 
    49                 bool shouldResetTimers = false; 
     49                bool shouldResetTimers = true; 
    5050                float64 timeToReset = 0; 
    5151                if (args.size() > 1) timeToReset = boost::lexical_cast<float64>(args[1]); 
     
    100100                if (resetAllObservers) 
    101101                { 
     102                        NR_Log(Log::LOG_ENGINE, "Clock: Reset time observers"); 
    102103                        ObserverList::iterator it = observers.begin(); 
    103                         for (; it != observers.end(); it++) 
    104                                 (*it)->resetObserver(resetToTime); 
     104                        for (; it != observers.end(); it++) (*it)->resetObserver(resetToTime); 
    105105                } 
    106106                 
     
    109109                currentTime = resetToTime; 
    110110                frameTime = frameDefaultTime; 
    111                 frameNumber = 0; 
     111                //frameNumber = 0; 
    112112                realFrameTime = frameDefaultTime; 
    113                 nextSyncTime = 0; 
     113                nextSyncTime = lastCurrentTime + static_cast<float64>(syncInterval) / 1000.0; 
    114114                 
    115115                // reset time source 
    116116                setTimeSource(timeSource); 
     117                if (timeSource != NULL) timeSource->reset(resetToTime); 
    117118                 
    118119                // reset the frame history 
     
    124125        //------------------------------------------------------------------------       
    125126        void Clock::setTimeSource(SharedPtr<TimeSource> timeSource) 
    126         {                
     127        { 
    127128                this->timeSource = timeSource; 
    128129         
    129130                if (timeSource != NULL){ 
    130                         timeSource->reset(); 
    131131                        sourceStartValue = timeSource->getTime(); 
    132132                        sourceLastValue = sourceStartValue; 
     
    160160                // set the id of the timer 
    161161                timer->_observerID = id; 
     162                NR_Log(Log::LOG_ENGINE, Log::LL_DEBUG, "Clock::createTimer(): New timer created (id=%d)", id); 
    162163                 
    163164                // return created timer 
  • nrEngine/src/Script.cpp

    r27 r28  
    3333                mStopTime = 0; 
    3434                mRunningTimeLength = 0; 
     35                mFirstRunTimed = true; 
     36                mScriptStartTime = 0; 
    3537        } 
    3638 
     
    104106        { 
    105107                // vars 
    106                 int depth = 0, count = 0; 
     108                int depth = 0, count = 0, curdepth = 0; 
    107109 
    108110                // for parsing we are using stack-algorithm 
    109                 std::vector<std::string> stack; 
    110                 stack.push_back(std::string("")); 
    111                 std::string* top = &stack[stack.size()-1]; 
     111                //std::vector<std::string> stack; 
     112                //stack.push_back(std::string("")); 
     113                //stack.push_back(std::string("")); 
     114 
     115                std::string main;// = &stack[0]; 
     116                std::string sub;//  = &stack[1]; 
     117                std::string* cur  = &main; 
     118                 
     119                for (unsigned int i=0; i < script.length(); i++) 
     120                { 
     121                        if (script.at(i) == '{') curdepth ++; 
     122                         
     123                        if (script.at(i) == '{' && cur == &main && curdepth == 1) 
     124                        { 
     125                                cur = &sub; 
     126                                depth ++; 
     127                        } 
     128                        else if (script.at(i) == '}' && cur == &sub && curdepth == 1) 
     129                        { 
     130                                count ++; 
     131                                depth --; 
     132                                 
     133                                // create name for the new subscript 
     134                                std::stringstream subscriptName; 
     135                                subscriptName << getResName() << std::string("_sub_") << count ; 
     136 
     137                                // current top element is a new script, so create it 
     138                                ResourcePtr<IScript> scr = Engine::sResourceManager()->createResource(subscriptName.str(), getResName(), "Script"); 
     139 
     140                                // if script could be created, so fill it and store, to execute later 
     141                                if (scr.valid()) 
     142                                { 
     143                                        scr.lockPure(); 
     144                                                scr->loadFromString(sub); 
     145                                        scr.unlockPure(); 
     146                                        mSubscripts.push_back(scr); 
     147                                }else{ 
     148                                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Script (%s): Subscript could not be created. Maybe no proper loader exists. Script will not run.\n", getResName().c_str()); 
     149                                        return std::string(""); 
     150                                } 
     151                                 
     152                                // reset pointer back to main script and empty the subscript string 
     153                                cur = &main; 
     154                                sub = std::string(""); 
     155                        } 
     156                        else 
     157                        { 
     158                                // write character into valid script 
     159                                *cur += script.at(i); 
     160                        } 
     161                         
     162                        if (script.at(i) == '}') curdepth --; 
     163                } 
     164                 
     165                // check if closing brackets were complete 
     166                if (depth != 0 || curdepth != 0) 
     167                { 
     168                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Script (%s): Subscript-brackets were not used properly. Depth is %d/%d, must be 0/0. Script disabled!", getResName().c_str(), depth, curdepth); 
     169                        return std::string(""); 
     170                } 
     171 
     172                //printf("\n%s\n%s\n\n", getResName().c_str(), main.c_str()); 
     173                 
     174                return main; 
     175                 
     176                /*std::string* top = &stack[stack.size()-1]; 
    112177 
    113178                // go through the given script 
     
    162227 
    163228                // return mainscript back 
    164                 return cleanScript(stack[0]); 
     229                return cleanScript(stack[0]);*/ 
    165230        } 
    166231 
     
    189254                        if (pos != std::string::npos) 
    190255                        { 
    191                                 std::string param = boost::algorithm::trim(line.substr(pos+1)); 
    192                                 if (!setParameter(param)){ 
     256                                // get parameter 
     257                                std::string sparam = line.substr(pos+1); 
     258                                boost::algorithm::trim(sparam); 
     259                                 
     260                                // now tokenize parameter, to get special argument values for the parameters 
     261                                std::vector<std::string> args; 
     262                                std::string param; 
     263                                tokenize(sparam, param, args);  
     264                                 
     265                                // set parameters 
     266                                if (!setParameter(param, args)) 
     267                                { 
    193268                                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Script: Unknown local parameter %s in line \"%s\"", param.c_str(), line.c_str()); 
    194269                                        return SCRIPT_PARSE_ERROR; 
     
    207282                        { 
    208283                                // retrieve the timestamp and the command and store it into the command buffer 
    209                                 std::string time = boost::algorithm::trim(line.substr(0,pos)); 
     284                                std::string time = line.substr(0,pos); 
     285                                boost::algorithm::trim(time); 
    210286                                std::string command = line.substr(pos+1); 
    211287 
     
    238314 
    239315                resetCommandFifo(); 
    240                 resetTimedCommandFifo(); 
    241316 
    242317                // if we got any command so we are valid 
     
    279354 
    280355        //------------------------------------------------------------------------------ 
    281         bool Script::setParameter(const std::string& param){ 
     356        bool Script::setParameter(const std::string& param, const std::vector<std::string>& args){ 
    282357 
    283358                if (param == "loop") 
     
    289364                else if (param == "runcomplete") 
    290365                        bRunStepwise = false; 
    291                 else if (param == "runonce") 
    292                         setRunOnce(true); 
     366                //else if (param == "runonce") 
     367                //      setRunOnce(true); 
     368                else if (param == "start_at") 
     369                        try{ 
     370                                if (args.size() > 1) mScriptStartTime = boost::lexical_cast<float32>(args[1]); 
     371                                else throw boost::bad_lexical_cast(); 
     372                        }catch(boost::bad_lexical_cast &){ 
     373                                NR_Log(Log::LOG_ENGINE, Log::LL_WARNING, "Script: %s - not a valid value for \"start_at\" parameter specified", getResName().c_str());                   
     374                        } 
    293375                else 
    294376                        return false; 
     
    309391 
    310392        //------------------------------------------------------------------------------ 
    311         void Script::resetTimedCommandFifo() 
    312         { 
     393        void Script::resetTimedCommandFifo(bool firstReset) 
     394        { 
     395                if (firstReset) mTimedCommandFifo.clear(); 
     396 
     397                // timed commands could only be resetted when they 
     398                // are already executed 
     399                 
    313400                // the timed commands are also setted in the fifo 
    314401                // the estimated end time is also computed 
    315                 mTimedCommandFifo.clear(); 
    316                 for (uint32 i=0; i < mTimedCommand.size(); i++) 
    317                 { 
    318                         mTimedCommandFifo.push_front(i); 
    319                         mTimedCommand[i].estimatedStart = Engine::sClock()->getTime() + mTimedCommand[i].timestamp; 
     402                for (int32 i=0; i < (int32)mTimedCommand.size(); i++) 
     403                { 
     404                        // check whenever fifo does not contain this command  
     405                        std::list< int32 >::iterator it = std::find(mTimedCommandFifo.begin(), mTimedCommandFifo.end(), i); 
     406                         
     407                        // if such command not exists, then reset it 
     408                        if (it == mTimedCommandFifo.end() || firstReset) 
     409                        { 
     410                                mTimedCommandFifo.push_front(i); 
     411                                mTimedCommand[i].estimatedStart = mTimer->getTime() + mTimedCommand[i].timestamp; 
     412                        } 
    320413                } 
    321414        } 
     
    325418        { 
    326419                // update time 
    327                 mTime = Engine::sClock()->getTime(); 
    328                 if (mStopTime == 0 && mRunningTimeLength > 0) 
    329                         mStopTime = mTime + mRunningTimeLength; 
    330  
     420                mTimer->setPause(false); 
     421                mTime = mTimer->getTime(); 
     422                 
     423                //printf("%s (%f - %f)\n", getResName().c_str(), mTime, mScriptStartTime); 
     424 
     425                // do execute the script only if start time was passed 
     426                if (mScriptStartTime > mTime) 
     427                { 
     428                        // if the script is waiting for the start, then it runs in a loop mode  
     429                        setRunOnce(false); 
     430                         
     431                        // do nothing at now 
     432                        return OK; 
     433                } 
     434                 
     435                // if the script running first time, then do reset on timed commands 
     436                if (mFirstRunTimed) 
     437                { 
     438                        // initialize timed commands 
     439                        mFirstRunTimed = false; 
     440                        resetTimedCommandFifo(true); 
     441                        setRunOnce(true); 
     442                } 
     443                 
     444                // compute stop time, when to stop the script if such defined 
     445                if (mStopTime == 0 && mRunningTimeLength > 0) mStopTime = mTime + mRunningTimeLength; 
     446                 
    331447                // ----- timed commands (quasi parallel execution) ----- 
    332448                // scan through the command fifo 
     
    336452                        int32 id = *it; 
    337453                        mTimedCommand[id].time = mTime; 
    338  
    339                         //printf("%s: %f %f\n", mTimedCommand[id].cmd.c_str(), mTimedCommand[id].estimatedStart, mTimedCommand[id].time); 
     454                         
     455                        //std::string msg; 
     456                        //for (unsigned int i=1; i < mTimedCommand[id].args.size(); i++) msg += std::string(" ") + mTimedCommand[id].args[i]; 
     457                        //printf("%s (%s): %f %f\n", mTimedCommand[id].cmd.c_str(), msg.c_str(), mTimedCommand[id].estimatedStart, mTimedCommand[id].time); 
    340458 
    341459                        // if the estimated start time is reeached, so start the command and remove it from the queue 
     
    365483                                Engine::sKernel()->RemoveTask(this->getTaskID()); 
    366484                        } 
    367                         // check for time reset command 
    368                         if (mCommand[id].cmd != std::string("_reset_script_time_")) 
    369                         { 
    370                                 resetTimedCommandFifo(); 
    371                         } 
    372485                } 
    373486 
     
    378491                if (mTime > mStopTime && mStopTime > 0) 
    379492                { 
    380                                 Engine::sKernel()->RemoveTask(this->getTaskID()); 
    381                 } 
    382  
     493                        Engine::sKernel()->RemoveTask(this->getTaskID()); 
     494                } 
     495 
     496                //printf("\n\n"); 
     497                 
    383498                return OK; 
    384499        } 
     
    443558                // do run all subscripts specified in this script 
    444559                for (unsigned int i = 0; i < mSubscripts.size(); i++) 
    445                         mSubscripts[i]->execute(); 
    446  
     560                { 
     561                        // cast subscripts to script objects 
     562                        Script* subscript = dynamic_cast<Script*>(mSubscripts[i].get()); 
     563                        if (subscript) 
     564                        { 
     565                                // first set starting time of subscripts relative to the main script  
     566                                subscript->mScriptStartTime += mScriptStartTime; 
     567                                 
     568                                // now execute the script  
     569                                subscript->execute(); 
     570                        } 
     571                         
     572                } 
     573                 
     574                // intialize the timer and pause it 
     575                mTimer = Engine::sClock()->createTimer(); 
     576                mTimer->setPause(true); 
     577                 
    447578                // reset the script, so it can run 
    448579                resetCommandFifo(); 
    449                 resetTimedCommandFifo(); 
     580                resetTimedCommandFifo(true); 
     581                mFirstRunTimed = true; 
    450582        } 
    451583 
     
    456588                        resetCommandFifo(); 
    457589                }else if (mTimedCommandFifo.size() == 0 && (mLoop & LOOP_TIMED_COMMAND)){ 
    458                         resetTimedCommandFifo(); 
     590                        resetTimedCommandFifo(false); 
    459591                } 
    460592                return true; 
  • nrEngine/src/TimeSource.cpp

    r22 r28  
    2727        TimeSource::TimeSource() : _currentTime(0), _syncTime(0) 
    2828        { 
    29          
     29                reset(); 
    3030        } 
    3131 
     
    4646                float64 a = static_cast<float64>(now.tv_sec) * static_cast<float64>(1000.0); 
    4747                float64 b = static_cast<float64>(now.tv_usec)/ static_cast<float64>(1000.0); 
    48                                                  
     48 
    4949                // clculate the time in seconds 
    5050                return  static_cast<float64>(0.001) * (a+b); 
     
    6262                float64 a =  static_cast<float64>(now.tv_sec - _startTime.tv_sec) *  static_cast<float64>(1000.0); 
    6363                float64 b =  static_cast<float64>(now.tv_usec- _startTime.tv_usec)/  static_cast<float64>(1000.0); 
    64                                          
     64         
    6565                // clculate the time in seconds 
    66                 _currentTime =  static_cast<float64>(0.001) * (a+b) + _syncTime; 
     66                _currentTime =  static_cast<float64>(0.001) * (a+b) + _resetTime + _syncTime; 
    6767                 
    6868                // return it back 
     
    7171 
    7272        //------------------------------------------------------------------------ 
    73         void TimeSource::reset() 
     73        void TimeSource::reset(float64 startValue) 
    7474        { 
    7575                gettimeofday(&_startTime, NULL); 
     76                _resetTime = startValue; 
    7677        } 
    7778 
  • nrEngine/src/TimeSourceVirtual.cpp

    r22 r28  
    4646        } 
    4747 
     48        //------------------------------------------------------------------------ 
     49        void TimeSourceVirtual::reset(float64 startValue) 
     50        { 
     51                _currentTime = startValue; 
     52        } 
     53         
    4854}; // end namespace      
    4955 
  • nrEngine/src/Timer.cpp

    r1 r28  
    3030                _currentTime = 0; 
    3131                _frameTime = 0; 
    32                          
     32                 
    3333        } 
    3434                 
Note: See TracChangeset for help on using the changeset viewer.