1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
/**
* @file llmotioncontroller.h
* @brief Implementation of LLMotionController class.
*
* Copyright (c) 2001-$CurrentYear$, Linden Research, Inc.
* $License$
*/
#ifndef LL_LLMOTIONCONTROLLER_H
#define LL_LLMOTIONCONTROLLER_H
//-----------------------------------------------------------------------------
// Header files
//-----------------------------------------------------------------------------
#include <string>
#include <map>
#include <deque>
#include "lluuidhashmap.h"
#include "llmotion.h"
#include "llpose.h"
#include "llframetimer.h"
#include "llstatemachine.h"
#include "llstring.h"
//-----------------------------------------------------------------------------
// Class predeclaration
// This is necessary because llcharacter.h includes this file.
//-----------------------------------------------------------------------------
class LLCharacter;
//-----------------------------------------------------------------------------
// LLMotionRegistry
//-----------------------------------------------------------------------------
typedef LLMotion*(*LLMotionConstructor)(const LLUUID &id);
class LLMotionTableEntry
{
public:
LLMotionTableEntry();
LLMotionTableEntry(LLMotionConstructor constructor, const LLUUID& id);
~LLMotionTableEntry(){};
LLMotion* create(const LLUUID& id);
static BOOL uuidEq(const LLUUID &uuid, const LLMotionTableEntry &id_pair)
{
if (uuid == id_pair.mID)
{
return TRUE;
}
return FALSE;
}
const LLUUID& getID() { return mID; }
protected:
LLMotionConstructor mConstructor;
LLUUID mID;
};
class LLMotionRegistry
{
public:
// Constructor
LLMotionRegistry();
// Destructor
~LLMotionRegistry();
// adds motion classes to the registry
// returns true if successfull
BOOL addMotion( const LLUUID& id, LLMotionConstructor create);
// creates a new instance of a named motion
// returns NULL motion is not registered
LLMotion *createMotion( const LLUUID &id );
// initialization of motion failed, don't try to create this motion again
void markBad( const LLUUID& id );
protected:
LLUUIDHashMap<LLMotionTableEntry, 32> mMotionTable;
};
//-----------------------------------------------------------------------------
// class LLMotionController
//-----------------------------------------------------------------------------
class LLMotionController
{
public:
typedef std::list<LLMotion*> motion_list_t;
typedef std::set<LLMotion*> motion_set_t;
public:
// Constructor
LLMotionController();
// Destructor
virtual ~LLMotionController();
// set associated character
// this must be called exactly once by the containing character class.
// this is generally done in the Character constructor
void setCharacter( LLCharacter *character );
// registers a motion with the controller
// (actually just forwards call to motion registry)
// returns true if successfull
BOOL addMotion( const LLUUID& id, LLMotionConstructor create );
// creates a motion from the registry
LLMotion *createMotion( const LLUUID &id );
// unregisters a motion with the controller
// (actually just forwards call to motion registry)
// returns true if successfull
void removeMotion( const LLUUID& id );
// start motion
// begins playing the specified motion
// returns true if successful
BOOL startMotion( const LLUUID &id, F32 start_offset );
// stop motion
// stops a playing motion
// in reality, it begins the ease out transition phase
// returns true if successful
BOOL stopMotionLocally( const LLUUID &id, BOOL stop_immediate );
// update motions
// invokes the update handlers for each active motion
// activates sequenced motions
// deactivates terminated motions`
void updateMotion();
// flush motions
// releases all motion instances
void flushAllMotions();
//Flush is a liar.
void deactivateAllMotions();
// pause and continue all motions
void pause();
void unpause();
BOOL isPaused() { return mPaused; }
void setTimeStep(F32 step);
void setTimeFactor(F32 time_factor);
F32 getTimeFactor() { return mTimeFactor; }
motion_list_t& getActiveMotions() { return mActiveMotions; }
//protected:
bool isMotionActive( LLMotion *motion );
bool isMotionLoading( LLMotion *motion );
LLMotion *findMotion( const LLUUID& id );
protected:
// internal operations act on motion instances directly
// as there can be duplicate motions per id during blending overlap
void deleteAllMotions();
void addLoadedMotion(LLMotion *motion);
BOOL activateMotionInstance(LLMotion *motion, F32 time);
BOOL deactivateMotionInstance(LLMotion *motion);
void deprecateMotionInstance(LLMotion* motion);
BOOL stopMotionInstance(LLMotion *motion, BOOL stop_imemdiate);
void removeMotionInstance(LLMotion* motion);
void updateRegularMotions();
void updateAdditiveMotions();
void resetJointSignatures();
void updateMotionsByType(LLMotion::LLMotionBlendType motion_type);
protected:
F32 mTimeFactor;
static LLMotionRegistry sRegistry;
LLPoseBlender mPoseBlender;
LLCharacter *mCharacter;
// Life cycle of an animation:
//
// Animations are instantiated and immediately put in the mAllMotions map for their entire lifetime.
// If the animations depend on any asset data, the appropriate data is fetched from the data server,
// and the animation is put on the mLoadingMotions list.
// Once an animations is loaded, it will be initialized and put on the mLoadedMotions deque.
// Any animation that is currently playing also sits in the mActiveMotions list.
typedef std::map<LLUUID, LLMotion*> motion_map_t;
motion_map_t mAllMotions;
motion_set_t mLoadingMotions;
motion_list_t mLoadedMotions;
motion_list_t mActiveMotions;
motion_set_t mDeprecatedMotions;
LLFrameTimer mTimer;
F32 mTime;
F32 mTimeOffset;
F32 mLastTime;
BOOL mHasRunOnce;
BOOL mPaused;
F32 mTimeStep;
S32 mTimeStepCount;
F32 mLastInterp;
F32 mPauseTime;
U8 mJointSignature[2][LL_CHARACTER_MAX_JOINTS];
};
//-----------------------------------------------------------------------------
// Class declaractions
//-----------------------------------------------------------------------------
#include "llcharacter.h"
#endif // LL_LLMOTIONCONTROLLER_H
|
