Changeset 23


Ignore:
Timestamp:
01/21/2007 11:02:48 AM (13 years ago)
Author:
art
Message:
 
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • Plugins/luaScripting/Script.h

    r1 r23  
    8080                Result unloadRes(); 
    8181                 
     82                //! Does always return false, because lua scripts are running completely once  
     83                bool hasCommands() { return false; } 
    8284}; 
    8385 
  • Plugins/luaScripting/ScriptConnector.cpp

    r19 r23  
    116116 
    117117        // read out the whole stack 
    118         while (lua_gettop(L) > 0){ 
     118        while (lua_gettop(L) > 0) 
     119        { 
    119120                const char* str = lua_popstring(L); 
    120121                values.push_back(std::string(str)); 
  • nrEngine/include/Clock.h

    r22 r23  
    2525#include "ITask.h" 
    2626#include "TimeSourceVirtual.h" 
     27#include "ScriptEngine.h" 
    2728 
    2829namespace nrEngine{ 
     
    7677                SharedPtr<TimeSource> getTimeSource() { return timeSource; } 
    7778                 
    78                  
     79                /** 
     80                 * This method will be called by the kernel to start the clock. It is called 
     81                 * when clock is added to the kernel pipeline. 
     82                 **/ 
     83                Result onStartTask(); 
     84 
    7985                /** 
    8086                * Updates the clock task by getting time values and calculating of 
     
    221227                void setSyncInterval(uint32 milliseconds); 
    222228                 
     229                /** 
     230                 * Reset the clock. The clock time will be resetted to the given time. 
     231                 * @param resetToTime Reset the clock to the given time value 
     232                 * @param resetAllObservers if true all registered obseervers would be also resetted 
     233                 **/ 
     234                void reset(float64 resetToTime = 0.0f, bool resetAllObservers = false); 
     235                 
     236                /** 
     237                 * Script-Function to reset the clock. You can specify in parameters if all timers, which were 
     238                 * created before should be also reseted. 
     239                 **/ 
     240                ScriptFunctionDef(scriptResetClock); 
     241 
     242 
    223243        private: 
    224244 
     
    241261                typedef ::std::vector< SharedPtr<ITimeObserver> > ObserverList; 
    242262                ::std::map < ::std::string, int32>      observerIDList; 
    243                 ObserverList                                            observers; 
     263                ObserverList                            observers; 
    244264                 
    245265                // frame filtering 
    246266                ::std::deque<float64>   frameDurationHistory; 
    247                 float64                                 frameDefaultTime; 
    248                 int32                                   frameFilteringWindow; 
     267                float64                 frameDefaultTime; 
     268                int32                   frameFilteringWindow; 
    249269                 
    250270                // time source 
  • nrEngine/include/IScript.h

    r1 r23  
    269269                        virtual Result unloadRes() {return OK;} 
    270270                         
     271                        //! Check if script should only run once  
     272                        bool shouldRunOnce() const { return mbRunOnce; } 
     273                         
     274                        //! Should the script run only once (no loop) 
     275                        void setRunOnce(bool b) { mbRunOnce = b; } 
     276                          
     277                        /** 
     278                         * This method will be called to check from base class to  
     279                         * check if run completes. If derived class returns false,  
     280                         * so script will be removed from the kernel  
     281                         **/ 
     282                        virtual bool hasCommands() = 0; 
     283                         
    271284                private: 
    272285 
     286                        //! Should this script run once  
     287                        bool mbRunOnce; 
     288                         
    273289                        //! Store here error messages 
    274290                        std::list<std::string> mErrorMsg; 
     
    305321                Result run(); 
    306322 
     323        private: 
     324                bool hasCommands() { return false; } 
    307325        }; 
    308326         
  • nrEngine/include/ITimeObserver.h

    r1 r23  
    5555                int32 getObserverID(){return _observerID; } 
    5656                 
     57                /** 
     58                 * Call this method to reset an observer. 
     59                 * Each observer should know how to reset himself 
     60                 * @param resetToTime reset the observer to this starting time 
     61                 **/ 
     62                virtual void resetObserver(float64 resetToTime = 0.0f) = 0; 
    5763                 
    5864        private: 
  • nrEngine/include/Script.h

    r1 r23  
    115115                private: 
    116116 
     117                        //! Return true if pipeline is full 
     118                        bool hasCommands(); 
     119 
    117120                        //! Derived from IScript 
    118121                        Result run(); 
  • nrEngine/include/ScriptEngine.h

    r1 r23  
    197197                        ScriptFunctionDef(scriptLoad); 
    198198                        ScriptFunctionDef(scriptRun); 
     199                        ScriptFunctionDef(scriptLoadAndRun); 
    199200                        ScriptFunctionDef(scriptCall); 
    200201                         
  • nrEngine/include/Timer.h

    r20 r23  
    2222#include "Clock.h" 
    2323#include "ITimeObserver.h" 
     24#include "Log.h" 
    2425 
    2526namespace nrEngine{ 
     
    108109                * Reset the timer, so it start count the time from the value you define 
    109110                **/ 
    110                 NR_FORCEINLINE void resetTimer(float64 startValue = 0.0f); 
     111                NR_FORCEINLINE void resetObserver(float64 resetToTime = 0.0f); 
    111112                 
    112113        private: 
     
    129130         
    130131 
    131 //---------------------------------------------------------------------------------- 
    132 NR_FORCEINLINE void Timer::resetTimer(float64 startValue) 
    133 { 
    134         _currentTime = startValue; 
    135 } 
     132        //---------------------------------------------------------------------------------- 
     133        NR_FORCEINLINE void Timer::resetObserver(float64 resetToTime) 
     134        { 
     135                _currentTime = resetToTime; 
     136                NR_Log(Log::LOG_ENGINE, "Timer: Reset timer %d to %f", resetToTime, getObserverID()); 
     137        } 
    136138 
    137139         
  • nrEngine/src/Clock.cpp

    r22 r23  
    2525namespace nrEngine{ 
    2626         
     27        //---------------------------------------------------------------------------------- 
     28        ScriptFunctionDec(scriptResetClock, Clock) 
     29        { 
     30                // check parameter count 
     31                if (args.size() < 1) 
     32                { 
     33                        return ScriptResult(std::string("resetClock([timeToReset = 0, [reset_all_timers = 0]]) - Not valid parameter count!")); 
     34                } 
     35 
     36                if (param.size() == 0) 
     37                { 
     38                        return ScriptResult(std::string("resetClock() was not properly registered before. Clock was not passed!")); 
     39                } 
     40                 
     41                // get clock  
     42                Clock* clock = nrEngine::ScriptEngine::parameter_cast<Clock* >(param[0]); 
     43                if (clock == NULL) 
     44                { 
     45                        return ScriptResult(std::string("resetClock() was not properly registered before. Clock was not passed!"));              
     46                } 
     47                 
     48                // get parameters 
     49                bool shouldResetTimers = false; 
     50                float64 timeToReset = 0; 
     51                if (args.size() > 1) timeToReset = boost::lexical_cast<float64>(args[1]); 
     52                if (args.size() > 2) shouldResetTimers = boost::lexical_cast<bool>(args[2]); 
     53                 
     54                // reset the clock  
     55                clock->reset(timeToReset, shouldResetTimers); 
     56 
     57                return ScriptResult(); 
     58        } 
     59 
    2760        //------------------------------------------------------------------------ 
    2861        Clock::Clock() : ITask(){ 
     
    6093         
    6194        //------------------------------------------------------------------------       
     95        void Clock::reset(float64 resetToTime, bool resetAllObservers) 
     96        { 
     97                // check if we have to reset observers 
     98                if (resetAllObservers) 
     99                { 
     100                        ObserverList::iterator it = observers.begin(); 
     101                        for (; it != observers.end(); it++) 
     102                                (*it)->resetObserver(resetToTime); 
     103                } 
     104                 
     105                // reset the clock  
     106                lastCurrentTime = resetToTime; 
     107                currentTime = resetToTime; 
     108                frameTime = frameDefaultTime; 
     109                frameNumber = 0; 
     110                realFrameTime = frameDefaultTime; 
     111                nextSyncTime = 0; 
     112                 
     113                // reset time source 
     114                setTimeSource(timeSource); 
     115                 
     116                // reset the frame history 
     117                setFrameWindow(frameFilteringWindow, frameDefaultTime); 
     118                 
     119                NR_Log(Log::LOG_ENGINE, "Clock: Reset clock to %f", resetToTime);                
     120        } 
     121 
     122        //------------------------------------------------------------------------       
    62123        void Clock::setTimeSource(SharedPtr<TimeSource> timeSource) 
    63124        {                
     
    86147         
    87148                // create timer as observer 
    88                 SharedPtr<ITimeObserver> timer( 
    89                                         new Timer(*this)); 
     149                SharedPtr<ITimeObserver> timer(new Timer(*this)); 
    90150                 
    91151                // add him to the list 
     
    105165         
    106166        //------------------------------------------------------------------------ 
    107         Result Clock::stopTask(){ 
     167        Result Clock::onStartTask() 
     168        { 
     169                // register function by the manager 
     170                std::vector<nrEngine::ScriptParam> param; 
     171                param.push_back(this); 
     172                Engine::sScriptEngine()->add("resetClock", scriptResetClock, param); 
     173                 
     174                return OK; 
     175        } 
     176 
     177        //------------------------------------------------------------------------ 
     178        Result Clock::stopTask() 
     179        { 
     180         
    108181                timeSource.reset(); 
    109182                 
     
    112185                } 
    113186                observers.clear(); 
     187                 
     188                Engine::sScriptEngine()->del("resetClock"); 
    114189                 
    115190                return OK; 
     
    153228                // set the last current time we used to the current time 
    154229                lastCurrentTime = currentTime; 
    155  
     230                 
    156231                // OK 
    157232                return OK; 
     
    198273                        observers.push_back (timeObserver); 
    199274                        id = observers.size(); 
    200                         observerIDList[::std::string(DEFAULT_OBSERVER_NAME)  
    201                                                                                 + ::boost::lexical_cast< ::std::string >(id)] = id; 
     275                        observerIDList[::std::string(DEFAULT_OBSERVER_NAME) + ::boost::lexical_cast< ::std::string >(id)] = id; 
    202276                        observers[observers.size()-1]->_observerID = id; 
    203277                } 
     
    212286                if (id <= 0 || id+1 >= static_cast<int32>(observers.size()) 
    213287                                || observerIDList.find(::std::string(DEFAULT_OBSERVER_NAME) +  
    214                                                         ::boost::lexical_cast< ::std::string >(observerID)) == observerIDList.end()){ 
     288                                ::boost::lexical_cast< ::std::string >(observerID)) == observerIDList.end()){ 
    215289                        return CLOCK_OBSERVER_NOT_FOUND; 
    216290                } 
     
    228302                 
    229303        //------------------------------------------------------------------------ 
    230         Result Clock::addObserver(const ::std::string& obsName, 
    231                                                                                                 SharedPtr<ITimeObserver> timeObserver){ 
    232                                                                  
     304        Result Clock::addObserver(const ::std::string& obsName,SharedPtr<ITimeObserver> timeObserver) 
     305        { 
    233306         
    234307                // check whenever such an observer already exists 
  • nrEngine/src/IScript.cpp

    r1 r23  
    3232        Result IScript::execute(bool runOnce) 
    3333        { 
     34                // set running counter parameter 
     35                mbRunOnce = runOnce; 
     36                 
    3437                // add the task to the kernel 
    3538                // also kernel is not allowed to remove this object, because 
    3639                // we created it from this, so no reference counting is used 
    3740                SharedPtr<ITask> task (this, null_deleter()); 
    38                 Engine::sKernel()->AddTask(task, ORDER_NORMAL, runOnce ? TASK_RUN_ONCE : TASK_NONE); 
     41                Engine::sKernel()->AddTask(task, ORDER_NORMAL); 
    3942 
    4043                return OK; 
     
    4447        Result IScript::forceExecute(bool runOnce) 
    4548        { 
     49                mbRunOnce = runOnce; 
     50                 
    4651                // we only run the script nothing more 
    4752                if (runOnce) return run(); 
     
    5459        Result IScript::updateTask() 
    5560        { 
    56                 return run(); 
     61                // run the script  
     62                Result ret = run(); 
     63 
     64                // if script should run once, so check if it has still commands 
     65                if (shouldRunOnce()) 
     66                { 
     67                        // check if script still have some commands 
     68                        if (!hasCommands()) 
     69                        { 
     70                                Engine::sKernel()->RemoveTask(this->getTaskID()); 
     71                        } 
     72                } 
     73 
     74                // return result 
     75                return ret; 
    5776        } 
    5877 
     
    6685        IScript::IScript(const std::string& name) : IResource(name) 
    6786        { 
    68  
     87                mbRunOnce = true; 
    6988        } 
    7089 
  • nrEngine/src/Script.cpp

    r1 r23  
    4242        Result Script::loadFromString(const std::string& str) 
    4343        { 
     44                // set task name as resource name  
     45                setTaskName(getResName() + "_ScriptTask"); 
     46                 
     47                // setup content 
    4448                mContent = str; 
    4549                return parse(mContent); 
     
    8791                        } 
    8892 
    89  
     93                        // check if we do have any command in the line  
     94                        pos = line.find_first_not_of(' ', 0); 
     95                        if (pos == std::string::npos) 
     96                                continue; 
     97                         
     98                         
    9099                        // check for the timestamp 
    91100                        pos = line.find('|'); 
     
    100109                                std::string time = trim(line.substr(0,pos)); 
    101110                                std::string command = line.substr(pos+1); 
    102  
     111                                 
    103112                                // try to convert the time and add the command to the list 
    104113                                try{ 
    105114                                        cmd.timestamp = boost::lexical_cast<float32>(time); 
    106115                                        tokenize(command, cmd.cmd, cmd.args); 
    107                                         mTimedCommand.push_back(cmd); 
     116                                        if (cmd.args.size() > 0 && cmd.args[0].length() > 0) 
     117                                        { 
     118                                                mTimedCommand.push_back(cmd); 
     119                                        } 
    108120                                }catch(...){ 
    109121                                        NR_Log(Log::LOG_ENGINE, Log::LL_ERROR, "Script: Unknown syntax in %d\n", l); 
     
    114126                        }else{ 
    115127                                tokenize(line, cmd.cmd, cmd.args); 
    116                                 mCommand.push_back(cmd); 
     128                                if (cmd.args.size() > 0 && cmd.args[0].length() > 0) 
     129                                { 
     130                                        mCommand.push_back(cmd); 
     131                                } 
    117132                        } 
    118133                } 
     
    128143        void Script::tokenize(const std::string& str, std::string& cmd, std::vector<std::string>& tokens) 
    129144        { 
     145                // do not tokenize if we do not get any token  
     146                if (str.length() == 0) return; 
     147                 
    130148                using namespace std; 
    131149                 
     
    139157                string::size_type pos     = str.find_first_of(delimiters, lastPos); 
    140158         
    141                 while (string::npos != pos || string::npos != lastPos) 
     159                while (pos != string::npos || lastPos != string::npos) 
    142160                { 
    143161                        // Found a token, add it to the vector. 
    144                         tokens.push_back(str.substr(lastPos, pos - lastPos)); 
     162                        if (pos  - lastPos > 0)  
     163                                tokens.push_back(str.substr(lastPos, pos - lastPos)); 
    145164 
    146165                        // Skip delimiters.  Note the "not_of" 
     
    153172                // now the first element in the token list is the command name 
    154173                cmd = tokens[0]; 
    155                  
    156174        } 
    157175 
     
    165183                else if (param == "loop_timed") 
    166184                        mLoop |= LOOP_TIMED_COMMAND; 
     185                else if (param == "runcomplete") 
     186                        bRunStepwise = false; 
     187                else if (param == "runonce") 
     188                        setRunOnce(true); 
    167189                else 
    168190                        return false; 
     
    197219        Result Script::step() 
    198220        { 
    199                 // ----- sequentiall commands ----- 
    200                 if (mCommandFifo.size()) 
    201                 { 
    202                         // get the id of the command 
    203                         int32 id = mCommandFifo.back(); 
    204                         mCommandFifo.pop_back(); 
    205  
    206                         // execute it 
    207                         Engine::sScriptEngine()->call(mCommand[id].cmd, mCommand[id].args); 
    208                 } 
     221                // update time 
     222                mTime = Engine::sClock()->getTime(); 
    209223 
    210224                // ----- timed commands (quasi parallel execution) ----- 
     
    222236                                it = mTimedCommandFifo.erase(it); 
    223237 
    224                                 // execute it 
    225                                 Engine::sScriptEngine()->call(mCommand[id].cmd, mCommand[id].args); 
     238                                // check if we have a stop commando 
     239                                if (mTimedCommand[id].cmd != std::string("_stop_")) 
     240                                { 
     241                                        Engine::sScriptEngine()->call(mTimedCommand[id].cmd, mTimedCommand[id].args); 
     242                                }else{ 
     243                                        Engine::sKernel()->RemoveTask(this->getTaskID()); 
     244                                } 
    226245 
    227246                        }else 
     
    229248 
    230249                } 
    231  
    232                 // update time 
    233                 // if script is sleeping, so no update occurs 
    234                 mTime = Engine::sClock()->getTime(); 
     250                 
     251                // ----- sequentiall commands ----- 
     252                if (mCommandFifo.size()) 
     253                { 
     254                        // get the id of the command 
     255                        int32 id = mCommandFifo.back(); 
     256                        mCommandFifo.pop_back(); 
     257 
     258                        // check if we have a stop commando 
     259                        if (mCommand[id].cmd != std::string("_stop_")) 
     260                        { 
     261                                Engine::sScriptEngine()->call(mCommand[id].cmd, mCommand[id].args); 
     262                        }else{ 
     263                                Engine::sKernel()->RemoveTask(this->getTaskID()); 
     264                        } 
     265                } 
    235266 
    236267                // reset the command list 
     
    240271        } 
    241272 
     273        //---------------------------------------------------------------------------------- 
     274        bool Script::hasCommands() 
     275        { 
     276                if (mCommandFifo.size() == 0 && mTimedCommandFifo.size() == 0 && !(mLoop & LOOP_COMMAND) && !(mLoop & LOOP_TIMED_COMMAND)) 
     277                        return false; 
     278                 
     279                return true; 
     280        } 
     281         
    242282        //---------------------------------------------------------------------------------- 
    243283        Result Script::run() 
     
    276316         
    277317                        // reset the list and check if the task is removed from the kernel 
    278                         bLoop = reset(); 
     318                        reset(); 
     319                        bLoop = hasCommands(); 
    279320                         
    280321                } while(bLoop && (mLoop & LOOP_COMMAND)); 
     
    290331                }else if (mTimedCommandFifo.size() == 0 && (mLoop & LOOP_TIMED_COMMAND)){ 
    291332                        resetTimedCommandFifo(); 
    292                 }else if (mCommandFifo.size() == 0 && mTimedCommandFifo.size() == 0 && !(mLoop & LOOP_COMMAND) && !(mLoop & LOOP_TIMED_COMMAND)){ 
    293                         Engine::sKernel()->RemoveTask(this->getTaskID()); 
    294                         return false; 
    295333                } 
    296334                return true; 
  • nrEngine/src/ScriptEngine.cpp

    r22 r23  
    6767                 
    6868                return ScriptResult(); 
     69        } 
     70 
     71        //---------------------------------------------------------------------------------- 
     72        ScriptFunctionDec(scriptLoadAndRun, ScriptEngine) 
     73        { 
     74                // check parameter count 
     75                if (args.size() < 2){ 
     76                        return ScriptResult(std::string("Not valid parameter count! Parameters (name, filename)")); 
     77                } 
     78 
     79                // get name and filename 
     80                const std::string& name = args[1]; 
     81                const std::string& fileName = args[2]; 
     82                 
     83                // create argument for calling 
     84                std::vector<std::string> arg; 
     85                arg.push_back(args[0]); 
     86                arg.push_back(name); 
     87                arg.push_back(fileName); 
     88                 
     89                // call load method 
     90                ScriptResult res = scriptLoad(arg, param); 
     91                 
     92                // create arguments for run method  
     93                arg.pop_back(); 
     94                 
     95                // call run if load was successfull 
     96                if (res.size() == 0) res = scriptRun(arg, param); 
     97                 
     98                return res; 
    6999        } 
    70100 
     
    125155                mDatabase["scriptExecute"].first = scriptRun; 
    126156                mDatabase["scriptCall"].first = scriptCall; 
     157                mDatabase["scriptLoadAndRun"].first = scriptLoadAndRun; 
    127158        } 
    128159 
  • nrEngine/src/ScriptLoader.cpp

    r15 r23  
    4040                declareSupportedResourceType("Script"); 
    4141                declareSupportedResourceType("Config"); 
     42                declareSupportedResourceType("nrScript"); 
    4243                 
    4344                // we do only support dll files in windows version of our engine 
     45                declareSupportedFileType("nrscript"); 
     46                declareSupportedFileType("cfg"); 
    4447                declareSupportedFileType("script"); 
    45                 declareSupportedFileType("cfg"); 
    4648 
    4749                // now delcare mapping of the types 
    48                 declareTypeMap("script", "Script"); 
     50                declareTypeMap("nrscript", "nrScript"); 
     51                declareTypeMap("script", "nrScript"); 
    4952                declareTypeMap("cfg", "Config"); 
    5053                 
     
    8184        { 
    8285                // check if we want to create just a script 
    83                 if (resourceType == "Script") 
     86                if (resourceType == "Script" || resourceType == "nrScript") 
    8487                        return new Script(); 
    8588                else if (resourceType == "Config"){ 
Note: See TracChangeset for help on using the changeset viewer.