Crystal Space: iSequenceManager Struct Reference (Crystal Space Public API Reference)

| ## Public API Reference

- Main Page
- Modules
- Namespaces
- Classes
- Files
- Related Pages

- Alphabetical List
- Class List
- Class Hierarchy
- Class Members

# iSequenceManager Struct Reference

The sequence manager. More...

`#include <ivaria/sequence.h>`

Inheritance diagram for iSequenceManager:

[legend]
List of all members.

## Public Member Functions
virtual void | Clear ()=0
| Clear all sequence operations currently in memory (this will call DecRef() on them).
virtual void | DestroySequenceOperations (uint sequence_id)=0
| Destroy all operations with a given sequence id.
virtual csTicks | GetDeltaTime () const =0
| Get the delta time to add to the main time to get the real main time.
virtual csTicks | GetMainTime () const =0
| Get the current time for the sequence manager.
virtual uint | GetUniqueID ()=0
| Return a unique id that you can use for identifying the sequence operations.
virtual bool | IsEmpty ()=0
| Return true if the sequence manager has nothing to do (i.e.
virtual bool | IsSuspended ()=0
| Return true if the sequence manager is suspended.
virtual csPtr< iSequence > | NewSequence ()=0
| Create a new empty sequence.
virtual void | Resume ()=0
| Resume the sequence manager at exactly the point it was previously suspended.
virtual void | RunSequence (csTicks time, iSequence *sequence, iBase *params=0, uint sequence_id=0)=0
| Execute a sequence at the given time.
virtual void | Suspend ()=0
| Suspend the sequence manager.
virtual void | TimeWarp (csTicks time, bool skip)=0
| Perform a time warp.

## Detailed Description

The sequence manager.

The sequence manager is a plugin that will perform sequences of operations depending on elapsed time. It is mostly useful for demo's or intros of games.

Main creators of instances implementing this interface:

- Sequence Manager plugin (crystalspace.utilities.sequence)

Main ways to get pointers to this interface:

- CS_QUERY_REGISTRY()

Main users of this interface:

- iEngineSequenceManager

Definition at line 179 of file sequence.h.

## Member Function Documentation

virtual void iSequenceManager::Clear | ( |  | ) | `[pure virtual]`

Clear all sequence operations currently in memory (this will call DecRef() on them).

virtual void iSequenceManager::DestroySequenceOperations | ( | uint | sequence_id | ) | `[pure virtual]`

Destroy all operations with a given sequence id.

virtual csTicks iSequenceManager::GetDeltaTime | ( |  | ) | const`[pure virtual]`

Get the delta time to add to the main time to get the real main time.

Do not use GetDeltaTime() from within the operation callback.

virtual csTicks iSequenceManager::GetMainTime | ( |  | ) | const`[pure virtual]`

Get the current time for the sequence manager.

This is not directly related to the real current time. Suspending the sequence manager will also freeze this time. Note that the sequence manager updates the main time AFTER rendering frames. So if you want to get the real main time you should add the delta returned by GetDeltaTime() too. However from within operation callbacks you should just use GetMainTime() in combination with the supplied delta.

virtual uint iSequenceManager::GetUniqueID | ( |  | ) | `[pure virtual]`

Return a unique id that you can use for identifying the sequence operations.

virtual bool iSequenceManager::IsEmpty | ( |  | ) | `[pure virtual]`

Return true if the sequence manager has nothing to do (i.e.

the queue of sequence operations is empty).

virtual bool iSequenceManager::IsSuspended | ( |  | ) | `[pure virtual]`

Return true if the sequence manager is suspended.

virtual csPtr<iSequence> iSequenceManager::NewSequence | ( |  | ) | `[pure virtual]`

Create a new empty sequence.

This sequence is not attached to the sequence manager in any way. After calling NewSequence() you can add operations to it and then use RunSequence() to run it.

virtual void iSequenceManager::Resume | ( |  | ) | `[pure virtual]`

Resume the sequence manager at exactly the point it was previously suspended.

Calling Resume() on a running sequence manager has no effect.

virtual void iSequenceManager::RunSequence | ( | csTicks | time,
|  | iSequence * | sequence,
|  | iBase * | params = `0`,
|  | uint | sequence_id = `0` |
| ) |  |  | `[pure virtual]`

Execute a sequence at the given time.

This will effectively put the sequence on the queue to be executed when the time has elapsed. Modifications on a sequence after it has been added have no effect. You can also remove the sequence (with DecRef()) immediatelly after running it.

The optional params instance will be given to all operations that are added on the main sequence. Ref counting is used to keep track of this object. So you can safely DecRef() your own reference after calling RunSequence.

Parameters:

  | time | Time at which the sequence should be executed.
  | sequence | Sequence to execute.
  | params | Optional instance given to all operations added to the main sequence.
  | sequence_id | This identifier can be used to get track of a given sequence. You can use this id to remove all operations that have this id.

virtual void iSequenceManager::Suspend | ( |  | ) | `[pure virtual]`

Suspend the sequence manager.

This will totally stop all actions that the sequence manager was doing. Use Resume() to resume. Calling Suspend() on an already suspended sequence manager has no effect. Note that a sequence manager is suspended by default. This is so you can set it up and add the needed operations and then call resume to start it all.

virtual void iSequenceManager::TimeWarp | ( | csTicks | time,
|  | bool | skip |
| ) |  |  | `[pure virtual]`

Perform a time warp.

This will effectively let the sequence manager think that the given time has passed. If the 'skip' flag is set then all sequence parts that would have been executed in the skipped time are not executed. Otherwise they will all be executed at the same time (but the delta time parameter to 'Do' and 'Condition' will contain the correct difference). 'time' is usually positive. When 'time' is negative this will have the effect of adding extra time before the first operation in the queue will be executed. i.e. we jump in the past but operations that used to be there before are already deleted and will not be executed again.

The documentation for this struct was generated from the following file:

- ivaria/sequence.h