ITickable
Engine/source/core/iTickable.h
This interface allows you to let any object be ticked.
Private Static Attributes
Last delta value for advanceTime.
Time of the last tick that occurred.
Last time value at which advanceTime was called.
Shift value to control how often Ticks occur.
Private Attributes
bool
Set to true if this object wants tick processing.
Private Static Functions
Returns a reference to the list of all ITickable objects.
Protected Functions
advanceTime(F32 timeDelta)
This method is called once every frame regardless of the return value of isProcessingTicks and informs the object of the passage of time.
interpolateTick(F32 delta)
This method is called every frame and lets the control interpolate between ticks so you can smooth things as long as isProcessingTicks returns true when it is called on the object.
This method is called once every 32ms if isProcessingTicks returns true when called on the object.
Public Functions
Constructor This will add the object to the process list.
Destructor Remove this object from the process list.
bool
Is this object wanting to receive tick notifications.
setProcessTicks(bool tick)
Sets this object as either tick processing or not.
Public Static Functions
bool
advanceTime(U32 timeDelta)
This is called in clientProcess to advance the time for all ITickable objects.
Gets the Tick mask.
Gets the Tick (seconds)
Gets the Tick bit-shift.
Detailed Description
This interface allows you to let any object be ticked.
You use it like so:
class FooClass : public SimObject, public virtual ITickable { // You still mark SimObject as Parent typdef SimObject Parent; private: ... protected: // These three methods are the interface for ITickable virtual void interpolateTick( F32 delta ); virtual void processTick(); virtual void advanceTime( F32 timeDelta ); public: ... };Please note the three methods you must implement to use ITickable, but don't worry. If you forget, the compiler will tell you so. Also note that the typedef for Parent should NOT BE SET to ITickable, the compiler will probably also tell you if you forget that. Last, but assuridly not least is that you note the way that the inheretance is done: public virtual ITickable It is very important that you keep the virtual keyword in there, otherwise proper behavior is not guarenteed. You have been warned.
The point of a tickable object is that the object gets ticks at a fixed rate which is one tick every 32ms. This means, also, that if an object doesn't get updated for 64ms, that the next update it will get two-ticks. Basically it comes down to this. You are assured to get one tick per 32ms of time passing provided that isProcessingTicks returns true when ITickable calls it.
isProcessingTicks is a virtual method and you can (should you want to) override it and put some extended functionality to decide if you want to recieve tick-notification or not.
The other half of this is that you get time-notification from advanceTime. advanceTime lets you know when time passes regardless of the return value of isProcessingTicks. The object WILL get the advanceTime call every single update. The argument passed to advanceTime is the time since the last call to advanceTime. Updates are not based on the 32ms tick time. Updates are dependant on framerate. So you may get 200 advanceTime calls in a second, or you may only get 20. There is no way of assuring consistant calls of advanceTime like there is with processTick. Both are useful for different things, and it is important to understand the differences between them.
Interpolation is the last part of the ITickable interface. It is called every update, as long as isProcessingTicks evaluates to true on the object. This is used to interpolate between 32ms ticks. The argument passed to interpolateTick is the time since the last call to processTick. You can see in the code for ITickable::advanceTime that before a tick occurs it calls interpolateTick(0) on every object. This is to tell objects which do interpolate between ticks to reset their interpolation because they are about to get a new tick.
This is an extremely powerful interface when used properly. An example of a class that properly uses this interface is GuiTickCtrl. The documentation for that class describes why it was created and why it was important that it use a consistant update frequency for its effects.
Support processBefore/After and move the GameBase processing over to use ITickable
Private Types
typedef Vector< ITickable * >::iterator ProcessListIterator
Private Static Attributes
U32 smLastDelta
Last delta value for advanceTime.
U32 smLastTick
Time of the last tick that occurred.
U32 smLastTime
Last time value at which advanceTime was called.
U32 smTickMask
U32 smTickMs
Number of milliseconds per tick, 32 in this case.
F32 smTickSec
Fraction of a second per tick.
U32 smTickShift
Shift value to control how often Ticks occur.
Private Attributes
bool mProcessTick
Set to true if this object wants tick processing.
Private Static Functions
getProcessList()
Returns a reference to the list of all ITickable objects.
Protected Functions
advanceTime(F32 timeDelta)
This method is called once every frame regardless of the return value of isProcessingTicks and informs the object of the passage of time.
Parameters:
| timeDelta | Time increment in seconds. |
Reimplemented by: VController, afxTSCtrl, ScriptTickObject, ForestWindMgr, GuiAutoScrollCtrl, GuiTickCtrl, ContextAction, LightBase, Scene
interpolateTick(F32 delta)
This method is called every frame and lets the control interpolate between ticks so you can smooth things as long as isProcessingTicks returns true when it is called on the object.
Reimplemented by: afxTSCtrl, ScriptTickObject, ForestWindMgr, GuiTickCtrl, ContextAction, LightBase, Scene, VController
processTick()
This method is called once every 32ms if isProcessingTicks returns true when called on the object.
Reimplemented by: afxTSCtrl, ScriptTickObject, ForestWindMgr, GuiAutoScrollCtrl, GuiRolloutCtrl, GuiMenuBar, GuiTickCtrl, ContextAction, LightBase, Scene, VController
Public Functions
ITickable()
Constructor This will add the object to the process list.
~ITickable()
Destructor Remove this object from the process list.
isProcessingTicks()
Is this object wanting to receive tick notifications.
True if object wants tick notifications
setProcessTicks(bool tick)
Sets this object as either tick processing or not.
Parameters:
| tick | True if this object should process ticks |
Public Static Functions
advanceTime(U32 timeDelta)
This is called in clientProcess to advance the time for all ITickable objects.
Parameters:
| timeDelta | Time increment in milliseconds. |
True if any ticks were sent
getTickMask()
Gets the Tick mask.
getTickMs()
Gets the Tick (ms)
getTickSec()
Gets the Tick (seconds)
getTickShift()
Gets the Tick bit-shift.
init(const U32 tickShift)
Initialise the ITickable system.