607 lines
24 KiB
C++
607 lines
24 KiB
C++
/*************************************************************************/
|
|
/* File : CKKeyframeData.h */
|
|
/* Author : Romain Sididris */
|
|
/* */
|
|
/* Definition of base Keyframe Key types and base animation controller */
|
|
/* Virtools SDK */
|
|
/* Copyright (c) Virtools 2000, All Rights Reserved. */
|
|
/*************************************************************************/
|
|
#ifndef CKKEYFRAMEDATA_H
|
|
|
|
#define CKKEYFRAMEDATA_H "$Id:$"
|
|
|
|
/*************************************************************************
|
|
Summary : Base class for animation keys.
|
|
|
|
Remarks:
|
|
This is the base class for all animation key. It contains only the time at which the key occurs.
|
|
|
|
See Also: CKObjectAnimation,CKAnimController,CKPositionKey,CKRotationKey,CKTCBPositionKey,CKTCBRotationKey
|
|
*************************************************************************/
|
|
class CKKey {
|
|
public:
|
|
//Summary:Returns the time for this key.
|
|
float GetTime() { return TimeStep; }
|
|
//Summary:Sets the time for this key.
|
|
void SetTime(float t) { TimeStep=t; }
|
|
|
|
CKKey(float Time=0) { TimeStep=Time; }
|
|
public:
|
|
float TimeStep; // Time of this key
|
|
};
|
|
|
|
//------------------- Linear Keys ------------------------------//
|
|
|
|
/*************************************************************
|
|
Summary : Linear Rotation Key
|
|
|
|
Remarks:
|
|
This is the base class for all rotation keys. It contains only
|
|
a VxQuaternion with the rotation information.
|
|
See Also: CKKey,CKPositionKey,CKTCBRotationKey
|
|
*************************************************************/
|
|
class CKRotationKey:public CKKey {
|
|
public:
|
|
//Summary:Returns the rotation value for this key.
|
|
const VxQuaternion& GetRotation() { return Rot; }
|
|
//Summary:Sets the rotation value for this key.
|
|
void SetRotation(const VxQuaternion& rot) { Rot = rot; }
|
|
|
|
CKRotationKey():CKKey(0) {}
|
|
CKRotationKey(float Time,VxQuaternion& rot):CKKey(Time) { Rot=rot; }
|
|
|
|
CKBOOL Compare(CKRotationKey& key,float Threshold) {
|
|
return ((XFabs(TimeStep-key.TimeStep)<=Threshold) && (XFabs(Rot.x-key.Rot.x)<=Threshold) && (XFabs(Rot.y-key.Rot.y)<=Threshold) && (XFabs(Rot.z-key.Rot.z)<=Threshold) && (XFabs(Rot.w-key.Rot.w)<=Threshold));
|
|
}
|
|
public:
|
|
VxQuaternion Rot; // Rotation info for this key.
|
|
};
|
|
|
|
/*************************************************************
|
|
Summary : Linear Position Key
|
|
|
|
Remarks:
|
|
This is the base class for all position keys. It contains only
|
|
a VxVector with the position information.
|
|
See Also: CKKey,CKRotationKey,CKTCBPositionKey,CKBezierPositionKey
|
|
*************************************************************/
|
|
class CKPositionKey:public CKKey {
|
|
public:
|
|
//Summary:Returns the position value for this key.
|
|
const VxVector& GetPosition() { return Pos; }
|
|
//Summary:Sets the position value for this key.
|
|
void SetPosition(const VxVector& pos) { Pos = pos; }
|
|
|
|
CKPositionKey():CKKey(0) {}
|
|
CKPositionKey(float Time,VxVector& pos):CKKey(Time) { Pos=pos; }
|
|
|
|
CKBOOL Compare(CKPositionKey& key,float Threshold) {
|
|
return ((XFabs(TimeStep-key.TimeStep)<=Threshold) && (XFabs(Pos.x-key.Pos.x)<=Threshold) && (XFabs(Pos.y-key.Pos.y)<=Threshold) && (XFabs(Pos.z-key.Pos.z)<=Threshold));
|
|
}
|
|
public:
|
|
VxVector Pos; // Position info for this key.
|
|
};
|
|
|
|
/*************************************************************
|
|
Summary : Linear Float Key
|
|
|
|
Remarks:
|
|
A simple float animation.
|
|
See Also: CKKey,CKRotationKey,CKTCBPositionKey,CKBezierPositionKey
|
|
*************************************************************/
|
|
class CKFloatKey:public CKKey {
|
|
public:
|
|
//Summary:Returns the position value for this key.
|
|
float GetValue() const { return Value; }
|
|
//Summary:Sets the position value for this key.
|
|
void SetValue(float value) { Value = value; }
|
|
|
|
CKFloatKey():CKKey(0) {}
|
|
CKFloatKey(float Time, float value) : CKKey(Time), Value(value) {}
|
|
|
|
CKBOOL Compare(const CKFloatKey& key,float Threshold) {
|
|
return ((XFabs(TimeStep - key.TimeStep) <= Threshold) && (XFabs(Value - key.Value) <= Threshold));
|
|
}
|
|
public:
|
|
float Value; // Position info for this key.
|
|
};
|
|
|
|
|
|
typedef CKPositionKey CKScaleKey;
|
|
|
|
typedef CKRotationKey CKScaleAxisKey;
|
|
|
|
//------------------- TCB Keys ------------------------------//
|
|
|
|
/*************************************************************
|
|
Summary : TCB Position Key
|
|
|
|
Remarks:
|
|
This class defines a TCB position key which contains
|
|
tension,continuity,bias for the key. easeto and easefrom
|
|
parameters defines the respectively incoming and outgoing accelerations.
|
|
See Also: CKKey,CKPositionKey,CKTCBRotationKey,CKBezierPositionKey
|
|
*************************************************************/
|
|
class CKTCBPositionKey:public CKPositionKey {
|
|
public:
|
|
|
|
CKTCBPositionKey() {}
|
|
|
|
CKTCBPositionKey(float Time,VxVector& pos,float t=0,float c=0,float b=0,float easeTo=0,float easeFrom=0):CKPositionKey(Time,pos),tension(t),continuity(c),bias(b),easeto(easeTo),easefrom(easeFrom) { }
|
|
|
|
CKBOOL Compare(CKTCBPositionKey& key,float Threshold) {
|
|
if (tension!=key.tension || continuity!=key.continuity || bias!=key.bias || easeto!=key.easeto || easefrom!=key.easefrom) return FALSE;
|
|
return CKPositionKey::Compare(key,Threshold);
|
|
}
|
|
public:
|
|
float tension,continuity,bias;
|
|
float easeto,easefrom;
|
|
};
|
|
|
|
/*************************************************************
|
|
Summary : TCB Float Key
|
|
|
|
Remarks:
|
|
This class defines a TCB float key which contains
|
|
tension,continuity,bias for the key. easeto and easefrom
|
|
parameters defines the respectively incoming and outgoing accelerations.
|
|
See Also: CKKey,CKFloatKey
|
|
*************************************************************/
|
|
class CKTCBFloatKey:public CKFloatKey {
|
|
public:
|
|
|
|
CKTCBFloatKey() {}
|
|
|
|
CKTCBFloatKey(float Time, float value,float t=0,float c=0,float b=0,float easeTo=0,float easeFrom=0):CKFloatKey(Time,value),tension(t),continuity(c),bias(b),easeto(easeTo),easefrom(easeFrom) { }
|
|
|
|
CKBOOL Compare(CKTCBFloatKey& key,float Threshold) {
|
|
if (tension!=key.tension || continuity!=key.continuity || bias!=key.bias || easeto!=key.easeto || easefrom!=key.easefrom) return FALSE;
|
|
return CKFloatKey::Compare(key,Threshold);
|
|
}
|
|
public:
|
|
float tension,continuity,bias;
|
|
float easeto,easefrom;
|
|
};
|
|
|
|
/*************************************************************
|
|
Summary : TCB Rotation Key
|
|
|
|
Remarks:
|
|
This class defines a TCB rotation key which contains
|
|
tension,continuity,bias for the key. easeto and easefrom
|
|
parameters defines the respectively incoming and outgoing accelerations.
|
|
See Also: CKKey,CKRotationKey,CKTCBPositionKey,CKBezierPositionKey
|
|
*************************************************************/
|
|
class CKTCBRotationKey:public CKRotationKey {
|
|
public:
|
|
CKTCBRotationKey() {}
|
|
CKTCBRotationKey(float Time,VxQuaternion& rot,float t=0,float c=0,float b=0,float easeTo=0,float easeFrom=0):CKRotationKey(Time,rot),tension(t),continuity(c),bias(b),easeto(easeTo),easefrom(easeFrom) { }
|
|
|
|
CKBOOL Compare(CKTCBRotationKey& key,float Threshold) {
|
|
if (tension!=key.tension || continuity!=key.continuity || bias!=key.bias || easeto!=key.easeto || easefrom!=key.easefrom) return FALSE;
|
|
return CKRotationKey::Compare(key,Threshold);
|
|
}
|
|
public:
|
|
float tension,continuity,bias;
|
|
float easeto,easefrom;
|
|
};
|
|
|
|
|
|
typedef CKTCBPositionKey CKTCBScaleKey;
|
|
|
|
typedef CKTCBRotationKey CKTCBScaleAxisKey;
|
|
|
|
|
|
//------------------- Bezier Keys ------------------------------//
|
|
|
|
|
|
#define INTAN_MASK 0xFFFF
|
|
#define OUTTAN_MASK 0xFFFF0000L
|
|
#define OUTTAN_SHIFT 16
|
|
|
|
|
|
typedef enum CKBEZIERKEY_FLAGS {
|
|
BEZIER_KEY_AUTOSMOOTH = 0x0001, // compute smooth tangents
|
|
BEZIER_KEY_LINEAR = 0x0002, // linear to/from pt
|
|
BEZIER_KEY_STEP = 0x0004, // step to/from pt
|
|
BEZIER_KEY_FAST = 0x0008, // compute fast (2* (keyn-keyp)) tangent
|
|
BEZIER_KEY_SLOW = 0x0010, // compute slow (0) Tangent
|
|
BEZIER_KEY_TANGENTS = 0x0020, // Use tangent value
|
|
} CKBEZIERKEY_FLAGS;
|
|
|
|
|
|
class CKBezierKeyFlags {
|
|
public:
|
|
//
|
|
CKBEZIERKEY_FLAGS GetInTangentMode() { return (CKBEZIERKEY_FLAGS)(m_Flags & INTAN_MASK); }
|
|
CKBEZIERKEY_FLAGS GetOutTangentMode() { return (CKBEZIERKEY_FLAGS)((m_Flags & OUTTAN_MASK)>>OUTTAN_SHIFT); }
|
|
void SetInTangentMode(CKBEZIERKEY_FLAGS f) { m_Flags = ((m_Flags & ~INTAN_MASK) | (f & INTAN_MASK)); }
|
|
void SetOutTangentMode(CKBEZIERKEY_FLAGS f) { m_Flags = ((m_Flags & ~OUTTAN_MASK) | ((f<<OUTTAN_SHIFT) & OUTTAN_MASK)); }
|
|
|
|
|
|
friend int operator != (const CKBezierKeyFlags& f1, const CKBezierKeyFlags& f2) { return f1.m_Flags != f2.m_Flags; }
|
|
CKBezierKeyFlags() { m_Flags = 0; }
|
|
protected:
|
|
CKDWORD m_Flags;
|
|
};
|
|
|
|
/*************************************************************
|
|
Summary : Bezier Float Key
|
|
|
|
Remarks:
|
|
+ This class defines a Bezier float key which contains incoming and ougoing derivative for the key.
|
|
+ The key also contain a CKBezierKeyFlags which defines how the incoming and outgoing tangents are computed. For example if the incoming tangent mode is set to BEZIER_KEY_TANGENTS we will use the In vector as incoming tangent otherwise the incoming tangent will be automatically computed according to the given mode.
|
|
|
|
{html:<table width="90%" border="1" align="center" bordercolorlight="#FFFFFF" bordercolordark="#FFFFFF" bgcolor="#FFFFFF" bordercolor="#FFFFFF"><tr bgcolor="#E6E6E6" bordercolor="#000000"><td>}
|
|
|
|
class CKBezierKeyFlags {
|
|
CKBEZIERKEY_FLAGS GetInTangentMode();
|
|
CKBEZIERKEY_FLAGS GetOutTangentMode();
|
|
void SetInTangentMode(CKBEZIERKEY_FLAGS f);
|
|
void SetOutTangentMode(CKBEZIERKEY_FLAGS f);
|
|
}
|
|
|
|
typedef enum CKBEZIERKEY_FLAGS {
|
|
BEZIER_KEY_AUTOSMOOTH = 0x0001, // compute smooth tangents
|
|
BEZIER_KEY_LINEAR = 0x0002, // linear to/from pt
|
|
BEZIER_KEY_STEP = 0x0004, // step to/from pt
|
|
BEZIER_KEY_FAST = 0x0008, // Fast Tangent
|
|
BEZIER_KEY_SLOW = 0x0010, // 0 Tangent
|
|
BEZIER_KEY_TANGENTS = 0x0020, // Use tangent value (In or Out)
|
|
} CKBEZIERKEY_FLAGS;
|
|
|
|
{html:</td></tr></table>}
|
|
|
|
See Also: CKKey,CKFloatKey,CKTCBFloatKey
|
|
*************************************************************/
|
|
class CKBezierFloatKey:public CKFloatKey {
|
|
public:
|
|
// Summary: Returns the tangents computation mode.
|
|
CKBezierKeyFlags& GetFlags() { return Flags; }
|
|
CKBezierFloatKey() { Flags.SetInTangentMode(BEZIER_KEY_AUTOSMOOTH); Flags.SetOutTangentMode(BEZIER_KEY_AUTOSMOOTH);}
|
|
CKBezierFloatKey(float Time,float value,const CKBezierKeyFlags& flags, float in, float out):CKFloatKey(Time,value),Flags(flags),In(in),Out(out) { }
|
|
CKBezierFloatKey(float Time,float value,const CKBezierKeyFlags& flags):CKFloatKey(Time,value),Flags(flags) {}
|
|
CKBezierFloatKey(float Time,float value,float in,float out):CKFloatKey(Time,value),In(in),Out(out)
|
|
{
|
|
Flags.SetInTangentMode(BEZIER_KEY_TANGENTS);
|
|
Flags.SetOutTangentMode(BEZIER_KEY_TANGENTS);
|
|
}
|
|
|
|
CKBOOL Compare(CKBezierFloatKey& key,float Threshold) {
|
|
if (Flags!=key.Flags) return FALSE;
|
|
if ((Flags.GetInTangentMode()==BEZIER_KEY_TANGENTS) && (In!=key.In)) return FALSE;
|
|
if ((Flags.GetOutTangentMode()==BEZIER_KEY_TANGENTS) && (Out!=key.Out)) return FALSE;
|
|
return CKFloatKey::Compare(key,Threshold);
|
|
}
|
|
public:
|
|
CKBezierKeyFlags Flags; // Flags specifying how incoming and outgoing tangents are computed.
|
|
float In; // Incoming Derivative.
|
|
float Out; // Outgoing Derivative.
|
|
|
|
};
|
|
|
|
/*************************************************************
|
|
Summary : Bezier Position Key
|
|
|
|
Remarks:
|
|
+ This class defines a Bezier position key which contains incoming and ougoing tangent vectors for the key.
|
|
+ The key also contain a CKBezierKeyFlags which defines how the incoming and outgoing tangents are computed. For example if the incoming tangent mode is set to BEZIER_KEY_TANGENTS we will use the In vector as incoming tangent otherwise the incoming tangent will be automatically computed according to the given mode.
|
|
|
|
{html:<table width="90%" border="1" align="center" bordercolorlight="#FFFFFF" bordercolordark="#FFFFFF" bgcolor="#FFFFFF" bordercolor="#FFFFFF"><tr bgcolor="#E6E6E6" bordercolor="#000000"><td>}
|
|
|
|
class CKBezierKeyFlags {
|
|
CKBEZIERKEY_FLAGS GetInTangentMode();
|
|
CKBEZIERKEY_FLAGS GetOutTangentMode();
|
|
void SetInTangentMode(CKBEZIERKEY_FLAGS f);
|
|
void SetOutTangentMode(CKBEZIERKEY_FLAGS f);
|
|
}
|
|
|
|
typedef enum CKBEZIERKEY_FLAGS {
|
|
BEZIER_KEY_AUTOSMOOTH = 0x0001, // compute smooth tangents
|
|
BEZIER_KEY_LINEAR = 0x0002, // linear to/from pt
|
|
BEZIER_KEY_STEP = 0x0004, // step to/from pt
|
|
BEZIER_KEY_FAST = 0x0008, // Fast Tangent
|
|
BEZIER_KEY_SLOW = 0x0010, // 0 Tangent
|
|
BEZIER_KEY_TANGENTS = 0x0020, // Use tangent value (In or Out)
|
|
} CKBEZIERKEY_FLAGS;
|
|
|
|
{html:</td></tr></table>}
|
|
|
|
See Also: CKKey,CKPositionKey,CKTCBPositionKey
|
|
*************************************************************/
|
|
class CKBezierPositionKey:public CKPositionKey {
|
|
public:
|
|
// Summary: Returns the tangents computation mode.
|
|
CKBezierKeyFlags& GetFlags() { return Flags; }
|
|
CKBezierPositionKey() { Flags.SetInTangentMode(BEZIER_KEY_AUTOSMOOTH); Flags.SetOutTangentMode(BEZIER_KEY_AUTOSMOOTH);}
|
|
CKBezierPositionKey(float Time,VxVector& pos,const CKBezierKeyFlags& flags,VxVector& in,VxVector& out):CKPositionKey(Time,pos),Flags(flags),In(in),Out(out) { }
|
|
CKBezierPositionKey(float Time,VxVector& pos,const CKBezierKeyFlags& flags):CKPositionKey(Time,pos),Flags(flags) {}
|
|
CKBezierPositionKey(float Time,VxVector& pos,VxVector& in,VxVector& out):CKPositionKey(Time,pos),In(in),Out(out)
|
|
{
|
|
Flags.SetInTangentMode(BEZIER_KEY_TANGENTS);
|
|
Flags.SetOutTangentMode(BEZIER_KEY_TANGENTS);
|
|
}
|
|
|
|
CKBOOL Compare(CKBezierPositionKey& key,float Threshold) {
|
|
if (Flags!=key.Flags) return FALSE;
|
|
if ((Flags.GetInTangentMode()==BEZIER_KEY_TANGENTS) && (In!=key.In)) return FALSE;
|
|
if ((Flags.GetOutTangentMode()==BEZIER_KEY_TANGENTS) && (Out!=key.Out)) return FALSE;
|
|
return CKPositionKey::Compare(key,Threshold);
|
|
}
|
|
public:
|
|
CKBezierKeyFlags Flags; // Flags specifying how incoming and outgoing tangents are computed.
|
|
VxVector In; // Incoming tangent vector.
|
|
VxVector Out; // Outgoing tangent vector.
|
|
|
|
};
|
|
|
|
|
|
typedef CKBezierPositionKey CKBezierScaleKey;
|
|
|
|
|
|
//------------------ Morph Keys --------------------------------//
|
|
|
|
/*************************************************************
|
|
Summary : Morph Key
|
|
|
|
Remarks:
|
|
|
|
+ A Morph key contains a list of vertex for a given time but can also contain normal information.
|
|
+ If normal are also stored, they used a VxCompressedVector (1 DWORD) per normal.
|
|
+ The number of vertices in a key is stored by its owner CKMorphController.(CKMorphController::SetMorphVertexCount)
|
|
|
|
See Also: CKKey,CKRotationKey,CKTCBPositionKey,CKBezierPositionKey
|
|
*************************************************************/
|
|
class CKMorphKey:public CKKey {
|
|
public:
|
|
VxVector* PosArray; // List of vertex positions
|
|
VxCompressedVector* NormArray; // List of vertex normals
|
|
|
|
CKMorphKey(float Time=0) : CKKey(Time)
|
|
{
|
|
PosArray = NULL;
|
|
NormArray = NULL;
|
|
}
|
|
|
|
|
|
CKBOOL Compare(CKMorphKey& key,int NbVertex,float Threshold) {
|
|
if (XFabs(TimeStep-key.TimeStep)>Threshold) return FALSE;
|
|
if (PosArray) {
|
|
if (!key.PosArray) return FALSE;
|
|
for (int i=0;i<NbVertex;++i) {
|
|
if (PosArray[i]!=key.PosArray[i]) return FALSE;
|
|
}
|
|
}
|
|
if (NormArray) {
|
|
if (!key.NormArray) return FALSE;
|
|
for (int i=0;i<NbVertex;++i) {
|
|
if (NormArray[i].xa!=key.NormArray[i].xa) return FALSE;
|
|
if (NormArray[i].ya!=key.NormArray[i].ya) return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
};
|
|
|
|
/****************************************************************
|
|
Summary: List of availables animations controllers
|
|
|
|
Remarks:
|
|
+ CKANIMATION_CONTROLLER contains the list of available animation controllers.
|
|
+ It is used when creating or deleting a controller on a CKObjectAnimation.
|
|
|
|
When deleting a controller with CKObjectAnimation::DeleteController only the base type is used (CKANIMATION_CONTROLLER_MASK).
|
|
|
|
See Also : CKAnimController,CKObjectAnimation::CreateController,CKObjectAnimation::DeleteController
|
|
*****************************************************************/
|
|
typedef enum CKANIMATION_CONTROLLER {
|
|
CKANIMATION_CONTROLLER_POS = 0x00000001, // Base type mask for position controllers
|
|
CKANIMATION_CONTROLLER_ROT = 0x00000002, // Base type mask for rotation controllers
|
|
CKANIMATION_CONTROLLER_SCL = 0x00000004, // Base type mask for scale controller
|
|
CKANIMATION_CONTROLLER_SCLAXIS = 0x00000008, // Base type mask for off-axis scale controller (Shear)
|
|
CKANIMATION_CONTROLLER_MORPH = 0x00000010, // Base type mask for morph controller
|
|
CKANIMATION_CONTROLLER_FLOAT = 0x00000020, // Base type mask for float controller (blend shapes)
|
|
CKANIMATION_CONTROLLER_MASK = 0x000000FF, // Mask for all controller types
|
|
|
|
|
|
CKANIMATION_LINFLOAT_CONTROL = 0x40856620, // LinearFloat Controller
|
|
CKANIMATION_LINPOS_CONTROL = 0x637c4301, // LinearPosition Controller
|
|
CKANIMATION_LINROT_CONTROL = 0x49ed4002, // Linear Rotation Controller
|
|
CKANIMATION_LINSCL_CONTROL = 0x654a3a04, // Linear Scale Controller
|
|
CKANIMATION_LINSCLAXIS_CONTROL = 0x2f200b08, // Linear Off-Axis Scale Controller (Shear)
|
|
|
|
CKANIMATION_TCBFLOAT_CONTROL = 0x5cb57a20, // TCB Float Controller
|
|
CKANIMATION_TCBPOS_CONTROL = 0x347e4a01, // TCB Position Controller
|
|
CKANIMATION_TCBROT_CONTROL = 0x45b52a02, // TCB Rotation Controller
|
|
CKANIMATION_TCBSCL_CONTROL = 0x1b545904, // TCB Scale Controller
|
|
CKANIMATION_TCBSCLAXIS_CONTROL = 0x32595908, // TCB Off-Axis Scale Controller (Shear)
|
|
|
|
CKANIMATION_BEZIERFLOAT_CONTROL = 0x5ed10220, // Bezier Float Controller
|
|
CKANIMATION_BEZIERPOS_CONTROL = 0x921ab801, // Bezier Position Controller
|
|
CKANIMATION_BEZIERSCL_CONTROL = 0x18ab4404, // Bezier Scale Controller
|
|
|
|
CKANIMATION_MORPH_CONTROL = 0x73847810 // Morph Controller
|
|
} CKANIMATION_CONTROLLER;
|
|
|
|
|
|
|
|
//--------- Base Animation Controller -------------------//
|
|
|
|
/**********************************************************
|
|
Summary : Base animation controller class.
|
|
|
|
Remarks:
|
|
+ All the animation controllers derives from this class. It provides the base methods to add,remove keys, save them to a memory buffer and perform the interpolation.
|
|
+ The interpolation methods are automatically called by the framework when using animations.
|
|
|
|
See Also:Animation Keys,CKMorphController
|
|
**********************************************************/
|
|
class CKAnimController : public VxPoolObject {
|
|
public:
|
|
|
|
CKAnimController(CKDWORD Type):m_Type(Type),m_NbKeys(0) {}
|
|
|
|
virtual ~CKAnimController() {}
|
|
|
|
/*****************************************************
|
|
Summary: Evaluates the result of the controller at a given time.
|
|
|
|
Arguments:
|
|
TimeStep: Time at which the interpolation should be done.
|
|
res: See Remarks.
|
|
Return Value:
|
|
TRUE if successful, FALSE otherwise (no keys for example).
|
|
Remarks:
|
|
According to the type of controller res is a pointer to:
|
|
|
|
+ A VxVector for position and scale controllers
|
|
+ A VxQuaternion for rotation and off axis scale controllers.
|
|
+ This method can not be called in this version for morph controllers (See CKMorphController)
|
|
See Also:AddKey
|
|
******************************************************/
|
|
virtual CKBOOL Evaluate(float TimeStep,void* res) = 0;
|
|
|
|
/*****************************************************
|
|
Summary: Adds a key to this controller.
|
|
|
|
Arguments:
|
|
key: A pointer to a CKKey (derived class) that contain the information.
|
|
Return Value:
|
|
Index of the generated key.
|
|
Remarks:
|
|
+The type of key depends on both the type of the controller (Position,Rotation,Scale,etc..) and the type
|
|
of interpolation used (linear,TCB,Bezier).
|
|
+The keys added by this method are automatically sorted by increasing time
|
|
value so there is not a specific order in which keys should be added.
|
|
+Since keys can be re-ordered when AddKey is called the returned index is
|
|
only valid until next call to AddKey.
|
|
See Also:Animation Keys,GetKey,GetKeyCount
|
|
******************************************************/
|
|
virtual int AddKey(CKKey* key) = 0;
|
|
/*****************************************************
|
|
Summary: Retuns a given key
|
|
|
|
Arguments:
|
|
index: Index of the key to be returned.
|
|
Remarks:
|
|
+The type of returned key depends on both the type of the controller (Position,Rotation,Scale,etc..) and the type
|
|
of interpolation used (linear,TCB,Bezier).
|
|
+The returned pointer must not be deleted nor should its time value be modified
|
|
but its content value (position,scale,tangents,etc...) can be changed.
|
|
Return Value:
|
|
A pointer to the 'index'th key.
|
|
See Also:Animation Keys,GetKeyCount
|
|
******************************************************/
|
|
virtual CKKey* GetKey(int index) = 0;
|
|
/*****************************************************
|
|
Summary: Removes a given key from the list.
|
|
|
|
Arguments:
|
|
index: Index of the key to be deleted.
|
|
See Also:Animation Keys,AddKey,GetKeyCount
|
|
******************************************************/
|
|
virtual void RemoveKey(int index) = 0;
|
|
|
|
/*****************************************************
|
|
Summary: Stores all controller data in a memory buffer.
|
|
|
|
Arguments:
|
|
Buffer: A pointer to the memory buffer where the controller data should be stored.
|
|
Return Value:
|
|
Size in bytes of the data written (or needed) to Buffer.
|
|
Remarks:
|
|
Call this method in two steps:
|
|
|
|
+ First with Buffer set to NULL, so that the method will return the needed size
|
|
to allocate for buffer.
|
|
+ Then with a valid pointer to a memory buffer allocated with a least
|
|
the returned size.
|
|
See Also:ReadKeysFrom
|
|
******************************************************/
|
|
virtual int DumpKeysTo(void* Buffer) = 0; // Pass NULL to get the size
|
|
/*****************************************************
|
|
Summary: Reads controller data from a memory buffer.
|
|
|
|
Arguments:
|
|
Buffer: A pointer to the memory buffer that was previously written DumpKeysTo.
|
|
Return Value:
|
|
Size in bytes of the data read from Buffer.
|
|
See Also:DumpKeysTo
|
|
******************************************************/
|
|
virtual int ReadKeysFrom(void* Buffer) = 0;
|
|
|
|
|
|
virtual CKBOOL Compare(CKAnimController* control,float Threshold=0.0f) = 0;
|
|
|
|
virtual CKBOOL Clone(CKAnimController* control) { m_NbKeys=control->m_NbKeys; m_Length=control->m_Length; return TRUE; }
|
|
|
|
// Summary: Returns the number of keys of this controller.
|
|
//
|
|
// See Also:GetKey
|
|
int GetKeyCount() { return m_NbKeys; }
|
|
// Summary: Returns the CKANIMATION_CONTROLLER type of this controller.
|
|
CKDWORD GetType() { return m_Type; }
|
|
|
|
// Summary: Sets the time length of this controller.
|
|
void SetLength(float l) { m_Length=l; }
|
|
// Summary: Returns the time length of this controller.
|
|
float GetLength() { return m_Length; }
|
|
|
|
public:
|
|
CKDWORD m_Type;
|
|
int m_NbKeys;
|
|
float m_Length;
|
|
};
|
|
|
|
//------------------ Morph Controller ---------------------------/
|
|
|
|
/**********************************************************
|
|
Summary : Morph controller class.
|
|
|
|
Remarks:
|
|
A Morph controller contains a list of morph keys (CKMorphKey)
|
|
and perfoms linear interpolation between these keys to
|
|
get the final result.
|
|
|
|
See Also:Animation Keys,CKAnimController
|
|
**********************************************************/
|
|
class CKMorphController : public CKAnimController {
|
|
public:
|
|
|
|
CKMorphController() : CKAnimController(CKANIMATION_MORPH_CONTROL) {}
|
|
/*********************************************************
|
|
Summary: Adds a morph key.
|
|
|
|
Arguments:
|
|
TimeStep: Time value for the key to generate.
|
|
key: A pointer to a CKMorphKey that contains the vertex positions.
|
|
AllocateNormals: TRUE if the new key should contain normal information.
|
|
Return Value:
|
|
Index of the generated key.
|
|
See Also: CKMorphKey.
|
|
********************************************************/
|
|
virtual int AddKey(float TimeStep,CKBOOL AllocateNormals) =0 ;
|
|
virtual int AddKey(CKKey* key,CKBOOL AllocateNormals) =0 ;
|
|
virtual int AddKey(CKKey* key) { return AddKey(key,TRUE); }
|
|
|
|
virtual CKKey* GetKey(int index) = 0;
|
|
|
|
virtual void RemoveKey(int index) = 0;
|
|
|
|
virtual CKBOOL Evaluate(float TimeStep,void* res) = 0;
|
|
/************************************************
|
|
Summary: Evaluates the vertex position at a given time
|
|
|
|
Arguments:
|
|
TimeStep: Time value at which interpolation should be done.
|
|
VertexPtr: A pointer to positions that will be filled.
|
|
VertexStride: Amount in bytes between each position in VertexPtr.
|
|
NormalPtr: A pointer to an array of VxCompressedVector that will be filled with the resulting normals.
|
|
*************************************************/
|
|
virtual CKBOOL Evaluate(float TimeStep,int VertexCount,void* VertexPtr,CKDWORD VertexStride,VxCompressedVector* NormalPtr) =0;
|
|
// Summary: Sets the number of vertices per key.
|
|
virtual void SetMorphVertexCount(int count) = 0;
|
|
};
|
|
|
|
#endif
|