466 lines
14 KiB
C++
466 lines
14 KiB
C++
/**
|
|
* @file llkeyframemotion.h
|
|
* @brief Implementation of LLKeframeMotion class.
|
|
*
|
|
* $LicenseInfo:firstyear=2001&license=viewergpl$
|
|
*
|
|
* Copyright (c) 2001-2009, Linden Research, Inc.
|
|
*
|
|
* Second Life Viewer Source Code
|
|
* The source code in this file ("Source Code") is provided by Linden Lab
|
|
* to you under the terms of the GNU General Public License, version 2.0
|
|
* ("GPL"), unless you have obtained a separate licensing agreement
|
|
* ("Other License"), formally executed by you and Linden Lab. Terms of
|
|
* the GPL can be found in doc/GPL-license.txt in this distribution, or
|
|
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
|
|
*
|
|
* There are special exceptions to the terms and conditions of the GPL as
|
|
* it is applied to this Source Code. View the full text of the exception
|
|
* in the file doc/FLOSS-exception.txt in this software distribution, or
|
|
* online at
|
|
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
|
|
*
|
|
* By copying, modifying or distributing this software, you acknowledge
|
|
* that you have read and understood your obligations described above,
|
|
* and agree to abide by those obligations.
|
|
*
|
|
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
|
|
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
|
|
* COMPLETENESS OR PERFORMANCE.
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
#ifndef LL_LLKEYFRAMEMOTION_H
|
|
#define LL_LLKEYFRAMEMOTION_H
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Header files
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include <string>
|
|
|
|
#include "llassetstorage.h"
|
|
#include "llbboxlocal.h"
|
|
#include "llhandmotion.h"
|
|
#include "lljointstate.h"
|
|
#include "llmotion.h"
|
|
#include "llquaternion.h"
|
|
#include "v3dmath.h"
|
|
#include "v3math.h"
|
|
#include "llbvhconsts.h"
|
|
|
|
class LLKeyframeDataCache;
|
|
class LLVFS;
|
|
class LLDataPacker;
|
|
|
|
#define MIN_REQUIRED_PIXEL_AREA_KEYFRAME (40.f)
|
|
#define MAX_CHAIN_LENGTH (4)
|
|
|
|
const S32 KEYFRAME_MOTION_VERSION = 1;
|
|
const S32 KEYFRAME_MOTION_SUBVERSION = 0;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// class LLKeyframeMotion
|
|
//-----------------------------------------------------------------------------
|
|
class LLKeyframeMotion :
|
|
public LLMotion
|
|
{
|
|
friend class LLKeyframeDataCache;
|
|
public:
|
|
// Constructor
|
|
LLKeyframeMotion(const LLUUID &id);
|
|
|
|
// Destructor
|
|
virtual ~LLKeyframeMotion();
|
|
|
|
private:
|
|
// private helper functions to wrap some asserts
|
|
LLPointer<LLJointState>& getJointState(U32 index);
|
|
LLJoint* getJoint(U32 index);
|
|
|
|
public:
|
|
//-------------------------------------------------------------------------
|
|
// functions to support MotionController and MotionRegistry
|
|
//-------------------------------------------------------------------------
|
|
|
|
// static constructor
|
|
// all subclasses must implement such a function and register it
|
|
static LLMotion *create(const LLUUID& id);
|
|
|
|
public:
|
|
//-------------------------------------------------------------------------
|
|
// animation callbacks to be implemented by subclasses
|
|
//-------------------------------------------------------------------------
|
|
|
|
// motions must specify whether or not they loop
|
|
virtual BOOL getLoop() {
|
|
if (mJointMotionList) return mJointMotionList->mLoop;
|
|
else return FALSE;
|
|
}
|
|
|
|
// motions must report their total duration
|
|
virtual F32 getDuration() {
|
|
if (mJointMotionList) return mJointMotionList->mDuration;
|
|
else return 0.f;
|
|
}
|
|
|
|
// motions must report their "ease in" duration
|
|
virtual F32 getEaseInDuration() {
|
|
if (mJointMotionList) return mJointMotionList->mEaseInDuration;
|
|
else return 0.f;
|
|
}
|
|
|
|
// motions must report their "ease out" duration.
|
|
virtual F32 getEaseOutDuration() {
|
|
if (mJointMotionList) return mJointMotionList->mEaseOutDuration;
|
|
else return 0.f;
|
|
}
|
|
|
|
// motions must report their priority
|
|
virtual LLJoint::JointPriority getPriority() {
|
|
if (mJointMotionList) return mJointMotionList->mBasePriority;
|
|
else return LLJoint::LOW_PRIORITY;
|
|
}
|
|
|
|
virtual LLMotionBlendType getBlendType() { return NORMAL_BLEND; }
|
|
|
|
// called to determine when a motion should be activated/deactivated based on avatar pixel coverage
|
|
virtual F32 getMinPixelArea() { return MIN_REQUIRED_PIXEL_AREA_KEYFRAME; }
|
|
|
|
// run-time (post constructor) initialization,
|
|
// called after parameters have been set
|
|
// must return true to indicate success and be available for activation
|
|
virtual LLMotionInitStatus onInitialize(LLCharacter *character);
|
|
|
|
// called when a motion is activated
|
|
// must return TRUE to indicate success, or else
|
|
// it will be deactivated
|
|
virtual BOOL onActivate();
|
|
|
|
// called per time step
|
|
// must return TRUE while it is active, and
|
|
// must return FALSE when the motion is completed.
|
|
virtual BOOL onUpdate(F32 time, U8* joint_mask);
|
|
|
|
// called when a motion is deactivated
|
|
virtual void onDeactivate();
|
|
|
|
virtual void setStopTime(F32 time);
|
|
|
|
static void setVFS(LLVFS* vfs) { sVFS = vfs; }
|
|
|
|
static void onLoadComplete(LLVFS *vfs,
|
|
const LLUUID& asset_uuid,
|
|
LLAssetType::EType type,
|
|
void* user_data, S32 status, LLExtStat ext_status);
|
|
|
|
public:
|
|
U32 getFileSize();
|
|
BOOL serialize(LLDataPacker& dp) const;
|
|
BOOL deserialize(LLDataPacker& dp);
|
|
BOOL isLoaded() { return mJointMotionList != NULL; }
|
|
|
|
|
|
// setters for modifying a keyframe animation
|
|
void setLoop(BOOL loop);
|
|
|
|
F32 getLoopIn() {
|
|
return (mJointMotionList) ? mJointMotionList->mLoopInPoint : 0.f;
|
|
}
|
|
|
|
F32 getLoopOut() {
|
|
return (mJointMotionList) ? mJointMotionList->mLoopOutPoint : 0.f;
|
|
}
|
|
|
|
void setLoopIn(F32 in_point);
|
|
|
|
void setLoopOut(F32 out_point);
|
|
|
|
void setHandPose(LLHandMotion::eHandPose pose) {
|
|
if (mJointMotionList) mJointMotionList->mHandPose = pose;
|
|
}
|
|
|
|
LLHandMotion::eHandPose getHandPose() {
|
|
return (mJointMotionList) ? mJointMotionList->mHandPose : LLHandMotion::HAND_POSE_RELAXED;
|
|
}
|
|
|
|
void setPriority(S32 priority);
|
|
|
|
void setEmote(const LLUUID& emote_id);
|
|
|
|
void setEaseIn(F32 ease_in);
|
|
|
|
void setEaseOut(F32 ease_in);
|
|
|
|
F32 getLastUpdateTime() { return mLastLoopedTime; }
|
|
|
|
const LLBBoxLocal& getPelvisBBox();
|
|
|
|
static void flushKeyframeCache();
|
|
|
|
protected:
|
|
//-------------------------------------------------------------------------
|
|
// JointConstraintSharedData
|
|
//-------------------------------------------------------------------------
|
|
class JointConstraintSharedData
|
|
{
|
|
public:
|
|
JointConstraintSharedData() :
|
|
mChainLength(0),
|
|
mEaseInStartTime(0.f),
|
|
mEaseInStopTime(0.f),
|
|
mEaseOutStartTime(0.f),
|
|
mEaseOutStopTime(0.f),
|
|
mUseTargetOffset(FALSE),
|
|
mConstraintType(CONSTRAINT_TYPE_POINT),
|
|
mConstraintTargetType(CONSTRAINT_TARGET_TYPE_BODY),
|
|
mSourceConstraintVolume(0),
|
|
mTargetConstraintVolume(0),
|
|
mJointStateIndices(NULL)
|
|
{ };
|
|
~JointConstraintSharedData() { delete [] mJointStateIndices; }
|
|
|
|
S32 mSourceConstraintVolume;
|
|
LLVector3 mSourceConstraintOffset;
|
|
S32 mTargetConstraintVolume;
|
|
LLVector3 mTargetConstraintOffset;
|
|
LLVector3 mTargetConstraintDir;
|
|
S32 mChainLength;
|
|
S32* mJointStateIndices;
|
|
F32 mEaseInStartTime;
|
|
F32 mEaseInStopTime;
|
|
F32 mEaseOutStartTime;
|
|
F32 mEaseOutStopTime;
|
|
BOOL mUseTargetOffset;
|
|
EConstraintType mConstraintType;
|
|
EConstraintTargetType mConstraintTargetType;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// JointConstraint()
|
|
//-----------------------------------------------------------------------------
|
|
class JointConstraint
|
|
{
|
|
public:
|
|
JointConstraint(JointConstraintSharedData* shared_data);
|
|
~JointConstraint();
|
|
|
|
JointConstraintSharedData* mSharedData;
|
|
F32 mWeight;
|
|
F32 mTotalLength;
|
|
LLVector3 mPositions[MAX_CHAIN_LENGTH];
|
|
F32 mJointLengths[MAX_CHAIN_LENGTH];
|
|
F32 mJointLengthFractions[MAX_CHAIN_LENGTH];
|
|
BOOL mActive;
|
|
LLVector3d mGroundPos;
|
|
LLVector3 mGroundNorm;
|
|
LLJoint* mSourceVolume;
|
|
LLJoint* mTargetVolume;
|
|
F32 mFixupDistanceRMS;
|
|
};
|
|
|
|
void applyKeyframes(F32 time);
|
|
|
|
void applyConstraints(F32 time, U8* joint_mask);
|
|
|
|
void activateConstraint(JointConstraint* constraintp);
|
|
|
|
void initializeConstraint(JointConstraint* constraint);
|
|
|
|
void deactivateConstraint(JointConstraint *constraintp);
|
|
|
|
void applyConstraint(JointConstraint* constraintp, F32 time, U8* joint_mask);
|
|
|
|
BOOL setupPose();
|
|
|
|
public:
|
|
enum AssetStatus { ASSET_LOADED, ASSET_FETCHED, ASSET_NEEDS_FETCH, ASSET_FETCH_FAILED, ASSET_UNDEFINED };
|
|
|
|
enum InterpolationType { IT_STEP, IT_LINEAR, IT_SPLINE };
|
|
|
|
//-------------------------------------------------------------------------
|
|
// ScaleKey
|
|
//-------------------------------------------------------------------------
|
|
class ScaleKey
|
|
{
|
|
public:
|
|
ScaleKey() { mTime = 0.0f; }
|
|
ScaleKey(F32 time, const LLVector3 &scale) { mTime = time; mScale = scale; }
|
|
|
|
F32 mTime;
|
|
LLVector3 mScale;
|
|
};
|
|
|
|
//-------------------------------------------------------------------------
|
|
// RotationKey
|
|
//-------------------------------------------------------------------------
|
|
class RotationKey
|
|
{
|
|
public:
|
|
RotationKey() { mTime = 0.0f; }
|
|
RotationKey(F32 time, const LLQuaternion &rotation) { mTime = time; mRotation = rotation; }
|
|
|
|
F32 mTime;
|
|
LLQuaternion mRotation;
|
|
};
|
|
|
|
//-------------------------------------------------------------------------
|
|
// PositionKey
|
|
//-------------------------------------------------------------------------
|
|
class PositionKey
|
|
{
|
|
public:
|
|
PositionKey() { mTime = 0.0f; }
|
|
PositionKey(F32 time, const LLVector3 &position) { mTime = time; mPosition = position; }
|
|
|
|
F32 mTime;
|
|
LLVector3 mPosition;
|
|
};
|
|
|
|
//-------------------------------------------------------------------------
|
|
// ScaleCurve
|
|
//-------------------------------------------------------------------------
|
|
class ScaleCurve
|
|
{
|
|
public:
|
|
ScaleCurve();
|
|
~ScaleCurve();
|
|
LLVector3 getValue(F32 time, F32 duration);
|
|
LLVector3 interp(F32 u, ScaleKey& before, ScaleKey& after);
|
|
|
|
InterpolationType mInterpolationType;
|
|
S32 mNumKeys;
|
|
typedef std::map<F32, ScaleKey> key_map_t;
|
|
key_map_t mKeys;
|
|
ScaleKey mLoopInKey;
|
|
ScaleKey mLoopOutKey;
|
|
};
|
|
|
|
//-------------------------------------------------------------------------
|
|
// RotationCurve
|
|
//-------------------------------------------------------------------------
|
|
class RotationCurve
|
|
{
|
|
public:
|
|
RotationCurve();
|
|
~RotationCurve();
|
|
LLQuaternion getValue(F32 time, F32 duration);
|
|
LLQuaternion interp(F32 u, RotationKey& before, RotationKey& after);
|
|
|
|
InterpolationType mInterpolationType;
|
|
S32 mNumKeys;
|
|
typedef std::map<F32, RotationKey> key_map_t;
|
|
key_map_t mKeys;
|
|
RotationKey mLoopInKey;
|
|
RotationKey mLoopOutKey;
|
|
};
|
|
|
|
//-------------------------------------------------------------------------
|
|
// PositionCurve
|
|
//-------------------------------------------------------------------------
|
|
class PositionCurve
|
|
{
|
|
public:
|
|
PositionCurve();
|
|
~PositionCurve();
|
|
LLVector3 getValue(F32 time, F32 duration);
|
|
LLVector3 interp(F32 u, PositionKey& before, PositionKey& after);
|
|
|
|
InterpolationType mInterpolationType;
|
|
S32 mNumKeys;
|
|
typedef std::map<F32, PositionKey> key_map_t;
|
|
key_map_t mKeys;
|
|
PositionKey mLoopInKey;
|
|
PositionKey mLoopOutKey;
|
|
};
|
|
|
|
//-------------------------------------------------------------------------
|
|
// JointMotion
|
|
//-------------------------------------------------------------------------
|
|
class JointMotion
|
|
{
|
|
public:
|
|
PositionCurve mPositionCurve;
|
|
RotationCurve mRotationCurve;
|
|
ScaleCurve mScaleCurve;
|
|
std::string mJointName;
|
|
U32 mUsage;
|
|
LLJoint::JointPriority mPriority;
|
|
|
|
void update(LLJointState* joint_state, F32 time, F32 duration);
|
|
};
|
|
|
|
//-------------------------------------------------------------------------
|
|
// JointMotionList
|
|
//-------------------------------------------------------------------------
|
|
class JointMotionList
|
|
{
|
|
public:
|
|
std::vector<JointMotion*> mJointMotionArray;
|
|
F32 mDuration;
|
|
BOOL mLoop;
|
|
F32 mLoopInPoint;
|
|
F32 mLoopOutPoint;
|
|
F32 mEaseInDuration;
|
|
F32 mEaseOutDuration;
|
|
LLJoint::JointPriority mBasePriority;
|
|
LLHandMotion::eHandPose mHandPose;
|
|
LLJoint::JointPriority mMaxPriority;
|
|
typedef std::list<JointConstraintSharedData*> constraint_list_t;
|
|
constraint_list_t mConstraints;
|
|
LLBBoxLocal mPelvisBBox;
|
|
// mEmoteName is a facial motion, but it's necessary to appear here so that it's cached.
|
|
// TODO: LLKeyframeDataCache::getKeyframeData should probably return a class containing
|
|
// JointMotionList and mEmoteName, see LLKeyframeMotion::onInitialize.
|
|
std::string mEmoteName;
|
|
public:
|
|
JointMotionList();
|
|
~JointMotionList();
|
|
U32 dumpDiagInfo();
|
|
JointMotion* getJointMotion(U32 index) const { llassert(index < mJointMotionArray.size()); return mJointMotionArray[index]; }
|
|
U32 getNumJointMotions() const { return mJointMotionArray.size(); }
|
|
};
|
|
|
|
|
|
protected:
|
|
static LLVFS* sVFS;
|
|
|
|
//-------------------------------------------------------------------------
|
|
// Member Data
|
|
//-------------------------------------------------------------------------
|
|
JointMotionList* mJointMotionList;
|
|
std::vector<LLPointer<LLJointState> > mJointStates;
|
|
LLJoint* mPelvisp;
|
|
LLCharacter* mCharacter;
|
|
typedef std::list<JointConstraint*> constraint_list_t;
|
|
constraint_list_t mConstraints;
|
|
U32 mLastSkeletonSerialNum;
|
|
F32 mLastUpdateTime;
|
|
F32 mLastLoopedTime;
|
|
AssetStatus mAssetStatus;
|
|
};
|
|
|
|
class LLKeyframeDataCache
|
|
{
|
|
public:
|
|
// *FIX: implement this as an actual singleton member of LLKeyframeMotion
|
|
LLKeyframeDataCache(){};
|
|
~LLKeyframeDataCache();
|
|
|
|
typedef std::map<LLUUID, class LLKeyframeMotion::JointMotionList*> keyframe_data_map_t;
|
|
static keyframe_data_map_t sKeyframeDataMap;
|
|
|
|
static void addKeyframeData(const LLUUID& id, LLKeyframeMotion::JointMotionList*);
|
|
static LLKeyframeMotion::JointMotionList* getKeyframeData(const LLUUID& id);
|
|
|
|
static void removeKeyframeData(const LLUUID& id);
|
|
|
|
//print out diagnostic info
|
|
static void dumpDiagInfo();
|
|
static void clear();
|
|
};
|
|
|
|
#endif // LL_LLKEYFRAMEMOTION_H
|
|
|
|
|