?? interpolator.cpp
字號:
if(!TokenStream.ReadVector2(Node.OutTan)) return FALSE;
if(!TokenStream.ExpectChar(',')) return FALSE;
break;
}
case INTERPOLATOR_TYPE_VECTOR3:
{
if(!TokenStream.ReadVector3(Node.Vector)) return FALSE;
if(!TokenStream.ExpectChar(',')) return FALSE;
if(InterpolationType == INTERPOLATION_TYPE_NONE) break;
if(InterpolationType == INTERPOLATION_TYPE_LINEAR) break;
if(!TokenStream.ExpectWord("InTan")) return FALSE;
if(!TokenStream.ReadVector3(Node.InTan)) return FALSE;
if(!TokenStream.ExpectChar(',')) return FALSE;
if(!TokenStream.ExpectWord("OutTan")) return FALSE;
if(!TokenStream.ReadVector3(Node.OutTan)) return FALSE;
if(!TokenStream.ExpectChar(',')) return FALSE;
break;
}
case INTERPOLATOR_TYPE_VECTOR4:
{
if(!TokenStream.ReadVector4(Node.Vector)) return FALSE;
if(!TokenStream.ExpectChar(',')) return FALSE;
if(InterpolationType == INTERPOLATION_TYPE_NONE) break;
if(InterpolationType == INTERPOLATION_TYPE_LINEAR) break;
if(!TokenStream.ExpectWord("InTan")) return FALSE;
if(!TokenStream.ReadVector4(Node.InTan)) return FALSE;
if(!TokenStream.ExpectChar(',')) return FALSE;
if(!TokenStream.ExpectWord("OutTan")) return FALSE;
if(!TokenStream.ReadVector4(Node.OutTan)) return FALSE;
if(!TokenStream.ExpectChar(',')) return FALSE;
break;
}
}
NodeList.push_back(Node);
}
if(!TokenStream.ExpectChar('}')) return FALSE;
Static = FALSE;
return TRUE;
}
//+-----------------------------------------------------------------------------
//| Retrieves the scalar at a certain timepoint
//+-----------------------------------------------------------------------------
FLOAT INTERPOLATOR::GetScalar(CONST SEQUENCE_TIME& Time)
{
D3DXVECTOR4 TempVector;
if(Static) return StaticVector.x;
if(NodeList.size() <= 0) return 0.0f;
GetInterpolatedValue(TempVector, Time);
return TempVector.x;
}
//+-----------------------------------------------------------------------------
//| Retrieves the vector at a certain timepoint
//+-----------------------------------------------------------------------------
D3DXVECTOR2 INTERPOLATOR::GetVector2(CONST SEQUENCE_TIME& Time)
{
D3DXVECTOR2 Vector2;
D3DXVECTOR4 TempVector;
if(Static) return D3DXVECTOR2(StaticVector.x, StaticVector.y);
if(NodeList.size() <= 0) return D3DXVECTOR2(0.0f, 0.0f);
GetInterpolatedValue(TempVector, Time);
Vector2.x = TempVector.x;
Vector2.y = TempVector.y;
return Vector2;
}
//+-----------------------------------------------------------------------------
//| Retrieves the vector at a certain timepoint
//+-----------------------------------------------------------------------------
D3DXVECTOR3 INTERPOLATOR::GetVector3(CONST SEQUENCE_TIME& Time)
{
D3DXVECTOR3 Vector3;
D3DXVECTOR4 TempVector;
if(Static) return D3DXVECTOR3(StaticVector.x, StaticVector.y, StaticVector.z);
if(NodeList.size() <= 0) return D3DXVECTOR3(0.0f, 0.0f, 0.0f);
GetInterpolatedValue(TempVector, Time);
Vector3.x = TempVector.x;
Vector3.y = TempVector.y;
Vector3.z = TempVector.z;
return Vector3;
}
//+-----------------------------------------------------------------------------
//| Retrieves the vector at a certain timepoint
//+-----------------------------------------------------------------------------
D3DXVECTOR4 INTERPOLATOR::GetVector4(CONST SEQUENCE_TIME& Time)
{
D3DXVECTOR4 Vector4;
if(Static) return StaticVector;
if(NodeList.size() <= 0) return D3DXVECTOR4(0.0f, 0.0f, 0.0f, 1.0f);
GetQuaternionValue(Vector4, Time);
return Vector4;
}
//+-----------------------------------------------------------------------------
//| Sets a static scalar
//+-----------------------------------------------------------------------------
VOID INTERPOLATOR::SetStaticScalar(FLOAT NewScalar, CONST std::string& NewName)
{
Clear();
Type = INTERPOLATOR_TYPE_SCALAR;
StaticVector = D3DXVECTOR4(NewScalar, 0.0f, 0.0f, 0.0f);
Static = TRUE;
if(NewName != "")
{
Name = NewName;
DefaultVector = StaticVector;
}
}
//+-----------------------------------------------------------------------------
//| Sets a static integer scalar
//+-----------------------------------------------------------------------------
VOID INTERPOLATOR::SetStaticScalarInt(INT NewScalar, CONST std::string& NewName)
{
Clear();
Type = INTERPOLATOR_TYPE_SCALAR_INT;
StaticVector = D3DXVECTOR4(static_cast<FLOAT>(NewScalar), 0.0f, 0.0f, 0.0f);
Static = TRUE;
if(NewName != "")
{
Name = NewName;
DefaultVector = StaticVector;
}
}
//+-----------------------------------------------------------------------------
//| Sets a static vector
//+-----------------------------------------------------------------------------
VOID INTERPOLATOR::SetStaticVector2(CONST D3DXVECTOR2& NewVector2, CONST std::string& NewName)
{
Clear();
Type = INTERPOLATOR_TYPE_VECTOR2;
StaticVector = D3DXVECTOR4(NewVector2.x, NewVector2.y, 0.0f, 0.0f);
Static = TRUE;
if(NewName != "")
{
Name = NewName;
DefaultVector = StaticVector;
}
}
//+-----------------------------------------------------------------------------
//| Sets a static vector
//+-----------------------------------------------------------------------------
VOID INTERPOLATOR::SetStaticVector3(CONST D3DXVECTOR3& NewVector3, CONST std::string& NewName)
{
Clear();
Type = INTERPOLATOR_TYPE_VECTOR3;
StaticVector = D3DXVECTOR4(NewVector3.x, NewVector3.y, NewVector3.z, 0.0f);
Static = TRUE;
if(NewName != "")
{
Name = NewName;
DefaultVector = StaticVector;
}
}
//+-----------------------------------------------------------------------------
//| Sets a static vector
//+-----------------------------------------------------------------------------
VOID INTERPOLATOR::SetStaticVector4(CONST D3DXVECTOR4& NewVector4, CONST std::string& NewName)
{
Clear();
Type = INTERPOLATOR_TYPE_VECTOR4;
StaticVector = NewVector4;
Static = TRUE;
if(NewName != "")
{
Name = NewName;
DefaultVector = StaticVector;
}
}
//+-----------------------------------------------------------------------------
//| Retrieves the interpolated value
//+-----------------------------------------------------------------------------
VOID INTERPOLATOR::GetInterpolatedValue(D3DXVECTOR4& Vector, CONST SEQUENCE_TIME& Time)
{
FLOAT Factor;
FLOAT InverseFactor;
SEQUENCE_TIME TempTime;
MODEL_GLOBAL_SEQUENCE* GlobalSequence;
std::list<INTERPOLATOR_NODE>::iterator Node1;
std::list<INTERPOLATOR_NODE>::iterator Node2;
if(GlobalSequenceNode.IsAttached())
{
GlobalSequence = GlobalSequenceNode.GetObjectData();
TempTime.IntervalStart = 0;
TempTime.IntervalEnd = GlobalSequence->Data().Duration;
TempTime.Time = GlobalSequence->Data().Time;
}
else
{
TempTime = Time;
}
GetSurroundingNodes(TempTime, Node1, Node2);
if(Node1 == NodeList.end())
{
Vector = DefaultVector;
return;
}
if(Node2 == NodeList.end())
{
Vector = Node1->Vector;
return;
}
if(Node1->Time >= Node2->Time)
{
Vector = Node1->Vector;
return;
}
Factor = static_cast<FLOAT>(TempTime.Time - Node1->Time) / static_cast<FLOAT>(Node2->Time - Node1->Time);
InverseFactor = (1.0f - Factor);
switch(InterpolationType)
{
case INTERPOLATION_TYPE_NONE:
{
Vector = Node1->Vector;
break;
}
case INTERPOLATION_TYPE_LINEAR:
{
Vector = (InverseFactor * Node1->Vector) + (Factor * Node2->Vector);
break;
}
case INTERPOLATION_TYPE_HERMITE:
{
FLOAT Factor1;
FLOAT Factor2;
FLOAT Factor3;
FLOAT Factor4;
FLOAT FactorTimesTwo;
FactorTimesTwo = Factor * Factor;
Factor1 = FactorTimesTwo * (2.0f * Factor - 3.0f) + 1;
Factor2 = FactorTimesTwo * (Factor - 2.0f) + Factor;
Factor3 = FactorTimesTwo * (Factor - 1.0f);
Factor4 = FactorTimesTwo * (3.0f - 2.0f * Factor);
Vector = (Factor1 * Node1->Vector) + (Factor2 * Node1->OutTan) + (Factor3 * Node2->InTan) + (Factor4 * Node2->Vector);
break;
}
case INTERPOLATION_TYPE_BEZIER:
{
FLOAT Factor1;
FLOAT Factor2;
FLOAT Factor3;
FLOAT Factor4;
FLOAT FactorTimesTwo;
FLOAT InverseFactorTimesTwo;
FactorTimesTwo = Factor * Factor;
InverseFactorTimesTwo = InverseFactor * InverseFactor;
Factor1 = InverseFactorTimesTwo * InverseFactor;
Factor2 = 3.0f * Factor * InverseFactorTimesTwo;
Factor3 = 3.0f * FactorTimesTwo * InverseFactor;
Factor4 = FactorTimesTwo * Factor;
Vector = (Factor1 * Node1->Vector) + (Factor2 * Node1->OutTan) + (Factor3 * Node2->InTan) + (Factor4 * Node2->Vector);
break;
}
}
}
//+-----------------------------------------------------------------------------
//| Retrieves the interpolated quaternion value
//+-----------------------------------------------------------------------------
VOID INTERPOLATOR::GetQuaternionValue(D3DXVECTOR4& Vector, CONST SEQUENCE_TIME& Time)
{
FLOAT Factor;
SEQUENCE_TIME TempTime;
MODEL_GLOBAL_SEQUENCE* GlobalSequence;
std::list<INTERPOLATOR_NODE>::iterator Node1;
std::list<INTERPOLATOR_NODE>::iterator Node2;
if(GlobalSequenceNode.IsAttached())
{
GlobalSequence = GlobalSequenceNode.GetObjectData();
TempTime.IntervalStart = 0;
TempTime.IntervalEnd = GlobalSequence->Data().Duration;
TempTime.Time = GlobalSequence->Data().Time;
}
else
{
TempTime = Time;
}
GetSurroundingNodes(TempTime, Node1, Node2);
if(Node1 == NodeList.end())
{
if(Node2 == NodeList.end())
{
Vector = DefaultVector;
}
else
{
Vector = Node2->Vector;
}
return;
}
if(Node2 == NodeList.end())
{
Vector = Node1->Vector;
return;
}
if(Node1->Time >= Node2->Time)
{
Vector = Node1->Vector;
return;
}
Factor = static_cast<FLOAT>(TempTime.Time - Node1->Time) / static_cast<FLOAT>(Node2->Time - Node1->Time);
switch(InterpolationType)
{
case INTERPOLATION_TYPE_NONE:
{
Vector = Node1->Vector;
break;
}
case INTERPOLATION_TYPE_LINEAR:
{
D3DXQUATERNION* Quaternion;
D3DXQUATERNION* Quaternion1;
D3DXQUATERNION* Quaternion2;
Quaternion = reinterpret_cast<D3DXQUATERNION*>(&Vector);
Quaternion1 = reinterpret_cast<D3DXQUATERNION*>(&Node1->Vector);
Quaternion2 = reinterpret_cast<D3DXQUATERNION*>(&Node2->Vector);
D3DXQuaternionSlerp(Quaternion, Quaternion1, Quaternion2, Factor);
break;
}
case INTERPOLATION_TYPE_HERMITE:
case INTERPOLATION_TYPE_BEZIER:
{
D3DXQUATERNION* Quaternion;
D3DXQUATERNION* Quaternion1;
D3DXQUATERNION* Quaternion2;
D3DXQUATERNION* Quaternion3;
D3DXQUATERNION* Quaternion4;
D3DXQUATERNION QuaternionA;
D3DXQUATERNION QuaternionB;
D3DXQUATERNION QuaternionC;
Quaternion = reinterpret_cast<D3DXQUATERNION*>(&Vector);
Quaternion1 = reinterpret_cast<D3DXQUATERNION*>(&Node1->Vector);
Quaternion2 = reinterpret_cast<D3DXQUATERNION*>(&Node1->InTan);
Quaternion3 = reinterpret_cast<D3DXQUATERNION*>(&Node2->Vector);
Quaternion4 = reinterpret_cast<D3DXQUATERNION*>(&Node2->OutTan);
D3DXQuaternionSquadSetup(&QuaternionA, &QuaternionB, &QuaternionC, Quaternion1, Quaternion2, Quaternion3, Quaternion4);
D3DXQuaternionSquad(Quaternion, Quaternion1, &QuaternionA, &QuaternionB, &QuaternionC, Factor);
break;
}
}
}
//+-----------------------------------------------------------------------------
//| Retrieves the surrounding nodes
//+-----------------------------------------------------------------------------
VOID INTERPOLATOR::GetSurroundingNodes(CONST SEQUENCE_TIME& Time, std::list<INTERPOLATOR_NODE>::iterator& Node1, std::list<INTERPOLATOR_NODE>::iterator& Node2)
{
Node1 = NodeList.end();
Node2 = NodeList.begin();
while(TRUE)
{
if(Node2 == NodeList.end()) break;
if(Time.Time < Node2->Time) break;
Node1 = Node2;
Node2++;
}
if((Node1 != NodeList.end()) && (Node1->Time < Time.IntervalStart)) Node1 = NodeList.end();
if((Node2 != NodeList.end()) && (Node2->Time > Time.IntervalEnd)) Node2 = NodeList.end();
}
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -