Changeset 8051 for code/branches/tutorial/src/libraries/tools
- Timestamp:
- Mar 9, 2011, 11:27:05 AM (14 years ago)
- Location:
- code/branches/tutorial
- Files:
-
- 5 edited
Legend:
- Unmodified
- Added
- Removed
-
code/branches/tutorial
- Property svn:mergeinfo changed
/code/branches/usability merged: 8018-8041
- Property svn:mergeinfo changed
-
code/branches/tutorial/src/libraries/tools/Shader.h
r7976 r8051 38 38 #include <OgreCompositorInstance.h> 39 39 40 #include "util/MultiType.h" 40 41 #include "util/OgreForwardRefs.h" 41 42 #include "core/ViewportEventListener.h" -
code/branches/tutorial/src/libraries/tools/Timer.cc
r7401 r8051 35 35 36 36 #include <set> 37 38 #include <boost/bimap.hpp> 37 39 38 40 #include "util/Clock.h" … … 41 43 #include "core/command/CommandExecutor.h" 42 44 #include "core/command/Functor.h" 45 #include "tools/interfaces/TimeFactorListener.h" 43 46 44 47 namespace orxonox 45 48 { 46 49 SetConsoleCommand("delay", &delay).argumentCompleter(1, autocompletion::command()); 50 SetConsoleCommand("delayreal", &delayreal).argumentCompleter(1, autocompletion::command()); 51 SetConsoleCommand("killdelay", &killdelay); 47 52 SetConsoleCommand("killdelays", &killdelays); 48 53 49 static std::set<Timer*> delaytimerset; 50 51 /** 52 @brief Console-command: Calls another console command after @a delay seconds. 54 static boost::bimap<unsigned int, Timer*> delaytimers; 55 static unsigned int delayHandleCounter = 0; 56 57 /** 58 @brief Console-command: Calls another console command after @a delay seconds (game time). 53 59 @param delay The delay in seconds 54 60 @param command The console command 55 */ 56 void delay(float delay, const std::string& command) 57 { 58 Timer* delaytimer = new Timer(); 59 delaytimerset.insert(delaytimer); 61 @return The handle of the delayed command, can be used as argument for killdelay() 62 */ 63 unsigned int delay(float delay, const std::string& command) 64 { 65 return addDelayedCommand(new Timer(), delay, command); 66 } 67 68 /** 69 @brief Console-command: Calls another console command after @a delay seconds (real time) 70 @param delay The delay in seconds 71 @param command The console command 72 @return The handle of the delayed command, can be used as argument for killdelay() 73 */ 74 unsigned int delayreal(float delay, const std::string& command) 75 { 76 return addDelayedCommand(new RealTimer(), delay, command); 77 } 78 79 /** 80 @brief Helper function, used by delay() and delayreal() to add a delayed command. 81 @param timer The timer which will execute the command 82 @param delay The delay in seconds 83 @param command The console command 84 @return The handle of the delayed command, can be used as argument for killdelay() 85 */ 86 unsigned int addDelayedCommand(Timer* timer, float delay, const std::string& command) 87 { 88 delaytimers.insert(boost::bimap<unsigned int, Timer*>::value_type(++delayHandleCounter, timer)); 60 89 61 90 const ExecutorStaticPtr& delayexecutor = createExecutor(createFunctor(&executeDelayedCommand)); 62 delayexecutor->setDefaultValues(delaytimer, command); 63 delaytimer->setTimer(delay, false, delayexecutor); 91 delayexecutor->setDefaultValues(timer, command); 92 timer->setTimer(delay, false, delayexecutor); 93 94 return delayHandleCounter; 64 95 } 65 96 … … 73 104 CommandExecutor::execute(command); 74 105 timer->destroy(); 75 delaytimers et.erase(timer);106 delaytimers.right.erase(timer); 76 107 } 77 108 … … 81 112 void killdelays() 82 113 { 83 for (std::set<Timer*>::iterator it = delaytimerset.begin(); it != delaytimerset.end(); ++it) 84 (*it)->destroy(); 85 86 delaytimerset.clear(); 114 for (boost::bimap<unsigned int, Timer*>::left_map::iterator it = delaytimers.left.begin(); it != delaytimers.left.end(); ++it) 115 it->second->destroy(); 116 117 delaytimers.clear(); 118 } 119 120 /** 121 @brief Console-command: Kills a delayed command with given handle. 122 */ 123 void killdelay(unsigned int handle) 124 { 125 boost::bimap<unsigned int, Timer*>::left_map::iterator it = delaytimers.left.find(handle); 126 if (it != delaytimers.left.end()) 127 { 128 it->second->destroy(); 129 delaytimers.left.erase(it); 130 } 87 131 } 88 132 … … 93 137 { 94 138 this->init(); 95 Register Object(Timer);139 RegisterRootObject(Timer); 96 140 } 97 141 … … 106 150 { 107 151 this->init(); 108 Register Object(Timer);152 RegisterRootObject(Timer); 109 153 110 154 this->setTimer(interval, bLoop, executor, bKillAfterCall); … … 123 167 124 168 this->time_ = 0; 169 } 170 171 /** 172 @brief Returns the current time factor of the game. 173 */ 174 float Timer::getTimeFactor() 175 { 176 return TimeFactorListener::getTimeFactor(); 125 177 } 126 178 … … 168 220 } 169 221 } 222 223 /////////////// 224 // RealTimer // 225 /////////////// 226 /// @copydoc Timer::Timer 227 RealTimer::RealTimer() 228 { 229 RegisterObject(RealTimer); 230 } 231 232 /// @copydoc Timer::Timer(float, bool, const ExecutorPtr&, bool) 233 RealTimer::RealTimer(float interval, bool bLoop, const ExecutorPtr& executor, bool bKillAfterCall) : Timer(interval, bLoop, executor, bKillAfterCall) 234 { 235 RegisterObject(RealTimer); 236 } 237 238 /// Returns always 1 because RealTimer doesn't depend on the game time. 239 float RealTimer::getTimeFactor() 240 { 241 return 1; 242 } 170 243 } -
code/branches/tutorial/src/libraries/tools/Timer.h
r7851 r8051 81 81 #include "core/OrxonoxClass.h" 82 82 #include "core/command/Executor.h" 83 #include "tools/interfaces/TimeFactorListener.h"84 83 85 84 namespace orxonox 86 85 { 87 void delay(float delay, const std::string& command); 88 void killdelays(); 86 unsigned int delay(float delay, const std::string& command); 87 unsigned int delayreal(float delay, const std::string& command); 88 89 unsigned int addDelayedCommand(Timer* timer, float delay, const std::string& command); 89 90 void executeDelayedCommand(Timer* timer, const std::string& command); 90 91 92 void killdelay(unsigned int handle); 93 void killdelays(); 94 91 95 /** 92 @brief Timer is a helper class that executes a function after a given amount of time.96 @brief Timer is a helper class that executes a function after a given amount of seconds in game-time. 93 97 94 98 @see See @ref TimerExample "Timer.h" for an example. 99 100 The time interval of Timer depends on the game time, hence it stops if the game is paused or runs 101 slower/faster if the game-speed is modified. See RealTimer for a timer class which doesn't depend 102 on the game time. 95 103 */ 96 class _ToolsExport Timer : public TimeFactorListener104 class _ToolsExport Timer : virtual public OrxonoxClass 97 105 { 98 106 public: … … 123 131 void run(); 124 132 125 /// Re-starts the Timer: The executor will be called after @a interval seconds.133 /// Re-starts the timer: The executor will be called after @a interval seconds. 126 134 inline void startTimer() 127 135 { this->bActive_ = true; this->time_ = this->interval_; } 128 /// Stops the Timer.136 /// Stops the timer. 129 137 inline void stopTimer() 130 138 { this->bActive_ = false; this->time_ = this->interval_; } 131 /// Pauses the Timer - it will continue with the actual state if you call unpauseTimer().139 /// Pauses the timer - it will continue with the actual state if you call unpauseTimer(). 132 140 inline void pauseTimer() 133 141 { this->bActive_ = false; } 134 /// Unpauses the Timer - continues with the given state.142 /// Unpauses the timer - continues with the given state. 135 143 inline void unpauseTimer() 136 144 { this->bActive_ = true; } 137 /// Returns true if the Timer is active (neither stopped nor paused).145 /// Returns true if the timer is active (neither stopped nor paused). 138 146 inline bool isActive() const 139 147 { return this->bActive_; } 140 /// Returns the remaining time until the Timer calls the executor.148 /// Returns the remaining time until the timer calls the executor. 141 149 inline float getRemainingTime() const 142 150 { return static_cast<float>(this->time_ / 1000000.0f); } 143 /// Increases the remaining time of the Timer by the given amount of time (in seconds).151 /// Increases the remaining time of the timer by the given amount of time (in seconds). 144 152 inline void addTime(float time) 145 153 { if (time > 0.0f) this->time_ += static_cast<long long>(time * 1000000.0f); } 146 /// Decreases the remaining time of the Timer by the given amount of time (in seconds)154 /// Decreases the remaining time of the timer by the given amount of time (in seconds) 147 155 inline void removeTime(float time) 148 156 { if (time > 0.0f) this->time_ -= static_cast<long long>(time * 1000000.0f); } … … 156 164 void tick(const Clock& time); 157 165 166 protected: 167 virtual float getTimeFactor(); 168 158 169 private: 159 170 void init(); … … 163 174 long long interval_; //!< The time-interval in micro seconds 164 175 bool bLoop_; //!< If true, the executor gets called every @a interval seconds 165 bool bActive_; //!< If true, the Timer ticks and calls the executor if the time's up176 bool bActive_; //!< If true, the timer ticks and calls the executor if the time's up 166 177 bool bKillAfterCall_; //!< If true the timer gets deleted after it expired and called the executor 167 178 168 179 long long time_; //!< Internal variable, counting the time untill the next executor-call 169 180 }; 181 182 /** 183 @brief RealTimer is a helper class that executes a function after a given amount of seconds in real-time. 184 185 The time interval of RealTimer doesn't depend on the game time, it will also call the function 186 if the game is paused. See Timer for a timer class that depends on the game time. 187 */ 188 class _ToolsExport RealTimer : public Timer 189 { 190 public: 191 RealTimer(); 192 RealTimer(float interval, bool bLoop, const ExecutorPtr& executor, bool bKillAfterCall = false); 193 194 protected: 195 virtual float getTimeFactor(); 196 }; 170 197 } 171 198 -
code/branches/tutorial/src/libraries/tools/ToolsPrereqs.h
r7163 r8051 85 85 class Mesh; 86 86 class ParticleInterface; 87 class RealTimer; 87 88 class ResourceCollection; 88 89 class ResourceLocation;
Note: See TracChangeset
for help on using the changeset viewer.