Cyd
2b8ca921cb
Complete disaster-recovery snapshot: engine/game source, game data assets, VC6 toolchain + DX SDKs, build outputs, deployed game, and _UNUSED archive. Large binaries in Git LFS; text preserved byte-for-byte (core.autocrlf=false, no eol attributes). See RECOVERY.md for the one-clone rebuild procedure.
2788 lines
73 KiB
C++
2788 lines
73 KiB
C++
//===========================================================================//
|
|
// File: AnimationHolder.cpp
|
|
//---------------------------------------------------------------------------//
|
|
// Date Who Modification //
|
|
// -------- --- ---------------------------------------------------------- //
|
|
// 02/23/999 JSE Inital coding
|
|
//---------------------------------------------------------------------------//
|
|
// Copyright (C) 1998, Microsoft Corp. //
|
|
// All Rights reserved worldwide //
|
|
// This unpublished sourcecode is PROPRIETARY and CONFIDENTIAL //
|
|
//===========================================================================//
|
|
|
|
|
|
#include "MW4Headers.hpp"
|
|
|
|
#include "Vehicle.hpp"
|
|
#include "AnimationState.hpp"
|
|
|
|
using namespace MW4Animation;
|
|
|
|
|
|
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void PoseHolder::Load(AnimationStateEngine *anim_state_engine, NameList *param_list, bool run_minimal)
|
|
{
|
|
|
|
NameList::Entry *page = param_list->FindEntry("AnimType");
|
|
Check_Object(page);
|
|
|
|
page = param_list->FindEntry("Position");
|
|
Check_Object(page);
|
|
targetPosition = page->GetAtof();
|
|
Verify(targetPosition >= 0.0f);
|
|
Verify(targetPosition <= 1.0f);
|
|
|
|
page = param_list->FindEntry("Anim");
|
|
Check_Object(page);
|
|
|
|
// god i hate mstrings...
|
|
MString string;
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
animInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(animInstance);
|
|
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
bool PoseHolder::Advance(AnimationStateEngine *anim_state_engine, Stuff::Scalar time_slice, bool run_minimal)
|
|
{
|
|
Verify(animIterator != NULL);
|
|
|
|
// work thru the delay if there is one...
|
|
currentTime += time_slice;
|
|
|
|
if (currentTime >= startDelay)
|
|
{
|
|
animIterator->SetVelocityScale(0.0f);
|
|
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(animIterator);
|
|
|
|
|
|
|
|
if (startDelay == 0.0f)
|
|
{
|
|
carryOver = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
carryOver = currentTime - startDelay;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
|
|
void PoseHolder::Que(Stuff::Scalar position, bool run_minimal)
|
|
{
|
|
Verify(animIterator != NULL);
|
|
|
|
|
|
animIterator->SetPosition(targetPosition);
|
|
|
|
|
|
|
|
currentTime = 0.0f;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void PoseHolder::LoadIterators(bool run_minimal)
|
|
{
|
|
Verify(animIterator == NULL);
|
|
animIterator = new MW4Animation::AnimIterator(animInstance);
|
|
Register_Pointer(animIterator);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void PoseHolder::UnloadIterators(void)
|
|
{
|
|
Verify(animIterator != NULL);
|
|
Unregister_Pointer(animIterator);
|
|
delete animIterator;
|
|
animIterator = NULL;
|
|
currentTime = -1.0f;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
|
|
Stuff::Scalar PoseHolder::GetCurrentPercentage()
|
|
{
|
|
Verify(animInstance != NULL);
|
|
|
|
if (startDelay == 0.0f)
|
|
{
|
|
return startPercentage;
|
|
}
|
|
|
|
Scalar percent = currentTime / startDelay;
|
|
|
|
percent *= percentageOfChain;
|
|
percent += startPercentage;
|
|
|
|
Verify(percent <= 1.0f);
|
|
Verify(percent >= 0.0f);
|
|
|
|
return percent;
|
|
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
|
|
Stuff::Scalar PoseHolder::GetTimeTotal()
|
|
{
|
|
Verify(animInstance != NULL);
|
|
return
|
|
0.0f + startDelay;
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void CycleHolder::Load(AnimationStateEngine *anim_state_engine, NameList *param_list, bool run_minimal)
|
|
{
|
|
|
|
NameList::Entry *page = param_list->FindEntry("AnimType");
|
|
Check_Object(page);
|
|
|
|
page = param_list->FindEntry("Position");
|
|
Check_Object(page);
|
|
|
|
if (!_stricmp(page->GetChar(), "old"))
|
|
{
|
|
startPosition = -1;
|
|
}
|
|
else
|
|
{
|
|
startPosition = page->GetAtof();
|
|
}
|
|
|
|
//cycle_holder->targetPosition = page->GetAtof();
|
|
|
|
page = param_list->FindEntry("Anim");
|
|
Check_Object(page);
|
|
|
|
// god i hate mstrings...
|
|
MString string;
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
animInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(animInstance);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
bool CycleHolder::Advance(AnimationStateEngine *anim_state_engine, Stuff::Scalar time_slice, bool run_minimal)
|
|
{
|
|
Verify(animIterator != NULL);
|
|
|
|
currentTime += time_slice;
|
|
|
|
if (currentTime >= startDelay)
|
|
{
|
|
if (animIterator->IncrementTime(time_slice))
|
|
{
|
|
carryOver = animIterator->GetCarryOverTime();
|
|
return true;
|
|
}
|
|
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(animIterator);
|
|
|
|
// add the curve
|
|
if (curveCount)
|
|
{
|
|
// we don't support multiple curves now
|
|
Verify(curveCount == 1);
|
|
animIterator->SetBlendValue(anim_state_engine->animCurves[firstCurve].Play(animIterator->GetPosition()));
|
|
}
|
|
}
|
|
|
|
|
|
return false;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void CycleHolder::Que(Stuff::Scalar position, bool run_minimal)
|
|
{
|
|
Verify(animIterator != NULL);
|
|
|
|
|
|
if (position != -1.0f)
|
|
{
|
|
animIterator->SetPosition(position);
|
|
Verify(startDelay == 0.0f);
|
|
|
|
currentTime = GetTimeTotal() * position;
|
|
}
|
|
else
|
|
{
|
|
animIterator->SetPosition(startPosition);
|
|
currentTime = 0.0f;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void CycleHolder::LoadIterators(bool run_minimal)
|
|
{
|
|
Verify(animIterator == NULL);
|
|
animIterator = new MW4Animation::AnimIterator(animInstance);
|
|
Register_Pointer(animIterator);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void CycleHolder::UnloadIterators(void)
|
|
{
|
|
Verify(animIterator != NULL);
|
|
Unregister_Pointer(animIterator);
|
|
delete animIterator;
|
|
animIterator = NULL;
|
|
currentTime = -1.0f;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
Stuff::Scalar CycleHolder::GetCurrentPercentage()
|
|
{
|
|
Verify(animInstance != NULL);
|
|
|
|
Scalar percent = currentTime / GetTimeTotal();
|
|
|
|
percent *= percentageOfChain;
|
|
percent += startPercentage;
|
|
|
|
//SPEW(("jerryeds", "GetTime %f", animIterator->GetTime()));
|
|
|
|
Verify(percent <= 1.0f);
|
|
Verify(percent >= 0.0f);
|
|
|
|
return
|
|
percent;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
Stuff::Scalar CycleHolder::GetTimeTotal()
|
|
{
|
|
Verify(animInstance != NULL);
|
|
|
|
// don't forget the start offset and the start delay..
|
|
Scalar anim_time = animInstance->animData->animHeaderBlock->endTime -
|
|
animInstance->animData->animHeaderBlock->startTime;
|
|
|
|
if (startPosition == -1.0f)
|
|
{
|
|
return (anim_time + startDelay);
|
|
}
|
|
|
|
return
|
|
anim_time + startDelay - (anim_time * startPosition);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void SpeedCycleHolder::Load(AnimationStateEngine *anim_state_engine, NameList *param_list, bool run_minimal)
|
|
{
|
|
|
|
NameList::Entry *page = param_list->FindEntry("AnimType");
|
|
Check_Object(page);
|
|
|
|
page = param_list->FindEntry("Position");
|
|
Check_Object(page);
|
|
|
|
if (!_stricmp(page->GetChar(), "old"))
|
|
{
|
|
STOP(("NO LONGER SUPPORTED"));
|
|
startPosition = -1;
|
|
}
|
|
else
|
|
{
|
|
startPosition = page->GetAtof();
|
|
}
|
|
|
|
//targetPosition = page->GetAtof();
|
|
|
|
page = param_list->FindEntry("Anim");
|
|
Check_Object(page);
|
|
|
|
// god i hate mstrings...
|
|
MString string;
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
animInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(animInstance);
|
|
|
|
page = param_list->FindEntry("SpeedAttrib");
|
|
Check_Object(page);
|
|
|
|
speedAttrib = anim_state_engine->vehicleParent->GetAttributeEntry(page->GetChar());
|
|
Check_Object(speedAttrib);
|
|
|
|
// get the speed
|
|
animSpeed = 0.0f;
|
|
|
|
MW4Animation::AnimIterator *anim_iterator = new MW4Animation::AnimIterator(animInstance);
|
|
Register_Pointer(anim_iterator);
|
|
|
|
for (int i = 0; i < animInstance->animData->GetChannelCount(); ++i)
|
|
{
|
|
if (animInstance->animData->animChannelBlock[i].channelType ==
|
|
MW4Animation::ChannelAnimData::VelocityChannelType )
|
|
{
|
|
MW4Animation::BaseKeyframe *keyframe = NULL;
|
|
MW4Animation::BaseKeyframeTime *keyframetime = NULL;
|
|
keyframe = anim_iterator->GetLastKeyFrame(i);
|
|
keyframetime = anim_iterator->GetLastKeyFrameTime(i);
|
|
|
|
animSpeed = Abs(MW4Animation::Point3DVelPosSnapInterpolator(keyframe, keyframe, keyframetime, keyframetime, 0.0f).z);
|
|
|
|
keyframe = anim_iterator->GetFirstKeyFrame(i);
|
|
keyframetime = anim_iterator->GetFirstKeyFrameTime(i);
|
|
|
|
if (animSpeed < Abs(MW4Animation::Point3DVelPosSnapInterpolator(keyframe, keyframe, keyframetime, keyframetime, 0.0f).z))
|
|
{
|
|
animSpeed = Abs(MW4Animation::Point3DVelPosSnapInterpolator(keyframe, keyframe, keyframetime, keyframetime, 0.0f).z);
|
|
}
|
|
}
|
|
}
|
|
|
|
Unregister_Pointer(anim_iterator);
|
|
delete anim_iterator;
|
|
|
|
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
bool SpeedCycleHolder::Advance(AnimationStateEngine *anim_state_engine, Stuff::Scalar time_slice, bool run_minimal)
|
|
{
|
|
Verify(animIterator != NULL);
|
|
|
|
// frig with the time slice
|
|
Stuff::Scalar current_speed;
|
|
speedAttrib->GetValue(anim_state_engine->vehicleParent, ¤t_speed);
|
|
current_speed = Abs(current_speed);
|
|
|
|
Stuff::Scalar time_slow_down = 0.0f;
|
|
|
|
if (!Small_Enough(animSpeed, 0.0f))
|
|
{
|
|
time_slow_down = current_speed/animSpeed;
|
|
}
|
|
else
|
|
{
|
|
// if the animspeed is 0 then we just play full speed with no speed effect
|
|
time_slow_down = 1.0f;
|
|
}
|
|
|
|
currentTime += (time_slice * time_slow_down);
|
|
|
|
|
|
if (currentTime >= startDelay)
|
|
{
|
|
animIterator->SetVelocityScale(time_slow_down);
|
|
if(time_slow_down > 0.0f)
|
|
{
|
|
if (animIterator->IncrementTime(time_slice * time_slow_down))
|
|
{
|
|
// ok, this isn't as easy as this.
|
|
// we actually have to scale the carryover back up!
|
|
carryOver = animIterator->GetCarryOverTime()/time_slow_down;
|
|
//SPEW(("jerryeds", "ts:%f tsd:%f tsco:%f co:%f", time_slice, time_slow_down, animIterator->GetCarryOverTime(), carryOver));
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(animIterator);
|
|
|
|
// add the curve
|
|
if (curveCount)
|
|
{
|
|
// we don't support multiple curves now
|
|
Verify(curveCount == 1);
|
|
animIterator->SetBlendValue(anim_state_engine->animCurves[firstCurve].Play(animIterator->GetPosition()));
|
|
}
|
|
}
|
|
|
|
|
|
return false;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void SpeedCycleHolder::Que(Stuff::Scalar position, bool run_minimal)
|
|
{
|
|
Verify(animIterator != NULL);
|
|
|
|
|
|
if (position != -1.0f)
|
|
{
|
|
animIterator->SetPosition(position);
|
|
Verify(startDelay == 0.0f);
|
|
|
|
currentTime = GetTimeTotal() * position;
|
|
}
|
|
else
|
|
{
|
|
animIterator->SetPosition(startPosition);
|
|
currentTime = 0.0f;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void SpeedCycleHolder::LoadIterators(bool run_minimal)
|
|
{
|
|
Verify(animIterator == NULL);
|
|
animIterator = new MW4Animation::AnimIterator(animInstance);
|
|
Register_Pointer(animIterator);
|
|
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void SpeedCycleHolder::UnloadIterators(void)
|
|
{
|
|
Verify(animIterator != NULL);
|
|
Unregister_Pointer(animIterator);
|
|
delete animIterator;
|
|
animIterator = NULL;
|
|
currentTime = -1.0f;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
Stuff::Scalar SpeedCycleHolder::GetCurrentPercentage()
|
|
{
|
|
Verify(animInstance != NULL);
|
|
|
|
Scalar percent = currentTime / GetTimeTotal();
|
|
|
|
percent *= percentageOfChain;
|
|
percent += startPercentage;
|
|
|
|
Verify(percent <= 1.0f);
|
|
Verify(percent >= 0.0f);
|
|
|
|
return
|
|
percent;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
Stuff::Scalar SpeedCycleHolder::GetTimeTotal()
|
|
{
|
|
Verify(animInstance != NULL);
|
|
|
|
Scalar anim_time = animInstance->animData->animHeaderBlock->endTime -
|
|
animInstance->animData->animHeaderBlock->startTime;
|
|
|
|
if (startPosition == -1.0f)
|
|
{
|
|
return (anim_time + startDelay);
|
|
}
|
|
|
|
return
|
|
anim_time + startDelay - (anim_time * startPosition);
|
|
}
|
|
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void SpeedBlenderCycleHolder::Load(AnimationStateEngine *anim_state_engine, NameList *param_list, bool run_minimal)
|
|
{
|
|
|
|
NameList::Entry *page = param_list->FindEntry("AnimType");
|
|
Check_Object(page);
|
|
|
|
page = param_list->FindEntry("Position");
|
|
Check_Object(page);
|
|
|
|
if (!_stricmp(page->GetChar(), "old"))
|
|
{
|
|
startPosition = -1;
|
|
}
|
|
else
|
|
{
|
|
startPosition = page->GetAtof();
|
|
}
|
|
|
|
//targetPosition = page->GetAtof();
|
|
|
|
page = param_list->FindEntry("SlowAnim");
|
|
Check_Object(page);
|
|
|
|
// god i hate mstrings...
|
|
MString string;
|
|
string += page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
slowAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(slowAnimInstance);
|
|
|
|
|
|
page = param_list->FindEntry("FastAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
fastAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(fastAnimInstance);
|
|
|
|
|
|
page = param_list->FindEntry("SpeedAttrib");
|
|
Check_Object(page);
|
|
|
|
speedAttrib = anim_state_engine->vehicleParent->GetAttributeEntry(page->GetChar());
|
|
Check_Object(speedAttrib);
|
|
|
|
// get the speeds
|
|
slowSpeed = -1.0f;
|
|
|
|
MW4Animation::AnimIterator *anim_iterator = new MW4Animation::AnimIterator(slowAnimInstance);
|
|
Register_Pointer(anim_iterator);
|
|
|
|
for (int i = 0; i < slowAnimInstance->animData->GetChannelCount(); ++i)
|
|
{
|
|
if (slowAnimInstance->animData->animChannelBlock[i].channelType ==
|
|
MW4Animation::ChannelAnimData::VelocityChannelType )
|
|
{
|
|
MW4Animation::BaseKeyframe *keyframe = NULL;
|
|
keyframe = anim_iterator->GetLastKeyFrame(i);
|
|
|
|
MW4Animation::BaseKeyframeTime *keyframetime = NULL;
|
|
keyframetime = anim_iterator->GetLastKeyFrameTime(i);
|
|
|
|
slowSpeed = Abs(MW4Animation::Point3DVelPosSnapInterpolator(keyframe, keyframe, keyframetime, keyframetime, 0.0f).z);
|
|
}
|
|
}
|
|
|
|
Unregister_Pointer(anim_iterator);
|
|
delete anim_iterator;
|
|
|
|
Verify(slowSpeed != -1.0f);
|
|
|
|
fastSpeed = -1.0f;
|
|
|
|
anim_iterator = new MW4Animation::AnimIterator(fastAnimInstance);
|
|
Register_Pointer(anim_iterator);
|
|
|
|
for (i = 0; i < fastAnimInstance->animData->GetChannelCount(); ++i)
|
|
{
|
|
if (fastAnimInstance->animData->animChannelBlock[i].channelType ==
|
|
MW4Animation::ChannelAnimData::VelocityChannelType )
|
|
{
|
|
MW4Animation::BaseKeyframe *keyframe = NULL;
|
|
keyframe = anim_iterator->GetLastKeyFrame(i);
|
|
|
|
MW4Animation::BaseKeyframeTime *keyframetime = NULL;
|
|
keyframetime = anim_iterator->GetLastKeyFrameTime(i);
|
|
|
|
fastSpeed = Abs(MW4Animation::Point3DVelPosSnapInterpolator(keyframe, keyframe, keyframetime, keyframetime, 0.0f).z);
|
|
}
|
|
}
|
|
|
|
slowSpeedMultiplier = 1.0f;
|
|
page = param_list->FindEntry("SlowSpeedMultiplier");
|
|
if (page)
|
|
{
|
|
slowSpeedMultiplier = page->GetAtof();
|
|
}
|
|
|
|
|
|
|
|
Unregister_Pointer(anim_iterator);
|
|
delete anim_iterator;
|
|
|
|
Verify(fastSpeed != -1.0f);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
bool SpeedBlenderCycleHolder::Advance(AnimationStateEngine *anim_state_engine, Stuff::Scalar time_slice, bool run_minimal)
|
|
{
|
|
Verify(slowAnimIterator != NULL);
|
|
Verify(fastAnimIterator != NULL);
|
|
|
|
// frig with the time slice
|
|
Stuff::Scalar current_speed;
|
|
speedAttrib->GetValue(anim_state_engine->vehicleParent, ¤t_speed);
|
|
current_speed = Abs(current_speed);
|
|
|
|
if (currentTime >= startDelay)
|
|
{
|
|
// we want to be absolutly sure that we mix the animations in their own layer
|
|
AnimHierarchyNode *heir_node = NULL;
|
|
heir_node = anim_state_engine->iteratorManager->PushLayer(1.0f);
|
|
|
|
//{
|
|
if (current_speed < (slowSpeed * slowSpeedMultiplier))
|
|
{
|
|
Stuff::Scalar position = slowAnimIterator->GetPosition();
|
|
Stuff::Scalar time_slow_down = current_speed/slowSpeed;
|
|
|
|
if(time_slow_down > 0.0f)
|
|
{
|
|
currentTime += (time_slice * time_slow_down);
|
|
|
|
if( slowAnimIterator->IncrementTime(time_slice * time_slow_down) )
|
|
{
|
|
carryOver = slowAnimIterator->GetCarryOverTime()/time_slow_down;;
|
|
anim_state_engine->iteratorManager->UndoPush();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
position = slowAnimIterator->GetPosition() - position;
|
|
if (position != 0.0f)
|
|
{
|
|
fastAnimIterator->IncrementPosition(position);
|
|
}
|
|
}
|
|
slowAnimIterator->SetVelocityScale(time_slow_down);
|
|
fastAnimIterator->SetVelocityScale(time_slow_down);
|
|
slowAnimIterator->SetBlendValue(1.0f);
|
|
fastAnimIterator->SetBlendValue(0.0f);
|
|
|
|
//SPEW(("jerryeds", "w-- wp:%f rp:%f cs:%f ts:%f wb:%f rb:%f", slowAnimIterator->GetPosition(), fastAnimIterator->GetPosition(), current_speed, time_slow_down, 1.0f, 0.0f));
|
|
|
|
}
|
|
else
|
|
{
|
|
slowAnimIterator->SetVelocityScale(0.0f);
|
|
fastAnimIterator->SetVelocityScale(0.0f);
|
|
}
|
|
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(slowAnimIterator);
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(fastAnimIterator);
|
|
|
|
}
|
|
else if (current_speed >= fastSpeed)
|
|
{
|
|
Stuff::Scalar position = fastAnimIterator->GetPosition();
|
|
Stuff::Scalar time_slow_down = current_speed/fastSpeed;
|
|
currentTime += (time_slice * time_slow_down);
|
|
|
|
if(time_slow_down > 0.0f)
|
|
{
|
|
if( fastAnimIterator->IncrementTime(time_slice * time_slow_down) )
|
|
{
|
|
carryOver = fastAnimIterator->GetCarryOverTime()/time_slow_down;;
|
|
anim_state_engine->iteratorManager->UndoPush();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
position = fastAnimIterator->GetPosition() - position;
|
|
if (position != 0.0f)
|
|
{
|
|
slowAnimIterator->IncrementPosition(position);
|
|
}
|
|
}
|
|
slowAnimIterator->SetVelocityScale(time_slow_down);
|
|
fastAnimIterator->SetVelocityScale(time_slow_down);
|
|
slowAnimIterator->SetBlendValue(0.0f);
|
|
fastAnimIterator->SetBlendValue(1.0f);
|
|
|
|
//SPEW(("jerryeds", "r-- wp:%f rp:%f cs:%f ts:%f wb:%f rb:%f", slowAnimIterator->GetPosition(), fastAnimIterator->GetPosition(), current_speed, time_slow_down, 0.0f, 1.0f));
|
|
}
|
|
else
|
|
{
|
|
slowAnimIterator->SetVelocityScale(0.0f);
|
|
fastAnimIterator->SetVelocityScale(0.0f);
|
|
}
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(slowAnimIterator);
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(fastAnimIterator);
|
|
}
|
|
else
|
|
{
|
|
//we are in blending mode...
|
|
Stuff::Scalar position = fastAnimIterator->GetPosition();
|
|
|
|
//run is in control
|
|
|
|
currentTime += time_slice;
|
|
|
|
if( fastAnimIterator->IncrementTime(time_slice) )
|
|
{
|
|
carryOver = fastAnimIterator->GetCarryOverTime();
|
|
anim_state_engine->iteratorManager->UndoPush();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
position = fastAnimIterator->GetPosition() - position;
|
|
if (position != 0.0f)
|
|
{
|
|
slowAnimIterator->IncrementPosition(position);
|
|
}
|
|
|
|
}
|
|
fastAnimIterator->SetVelocityScale(1.0f);
|
|
slowAnimIterator->SetVelocityScale(1.0f);
|
|
|
|
Scalar speed_diff = fastSpeed - slowSpeed;
|
|
Stuff::Scalar fast_blend_value = (current_speed - slowSpeed)/speed_diff;
|
|
|
|
fastAnimIterator->SetBlendValue(fast_blend_value);
|
|
slowAnimIterator->SetBlendValue(1.0f - fast_blend_value);
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(slowAnimIterator);
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(fastAnimIterator);
|
|
}
|
|
|
|
|
|
//}
|
|
|
|
anim_state_engine->iteratorManager->PopLayer();
|
|
|
|
// add the curve
|
|
if (curveCount)
|
|
{
|
|
// we don't support multiple curves now
|
|
Check_Pointer(heir_node);
|
|
Verify(curveCount == 1);
|
|
heir_node->SetBlendValue(anim_state_engine->animCurves[firstCurve].Play(fastAnimIterator->GetPosition()));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
currentTime += time_slice;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void SpeedBlenderCycleHolder::Que(Stuff::Scalar position, bool run_minimal)
|
|
{
|
|
Verify(slowAnimIterator != NULL);
|
|
Verify(fastAnimIterator != NULL);
|
|
|
|
|
|
if (position != -1.0f)
|
|
{
|
|
slowAnimIterator->SetPosition(position);
|
|
fastAnimIterator->SetPosition(position);
|
|
|
|
Verify(startDelay == 0.0f);
|
|
|
|
currentTime = GetTimeTotal() * position;
|
|
}
|
|
else
|
|
{
|
|
slowAnimIterator->SetPosition(startPosition);
|
|
fastAnimIterator->SetPosition(startPosition);
|
|
currentTime = 0.0f;
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void SpeedBlenderCycleHolder::LoadIterators(bool run_minimal)
|
|
{
|
|
Verify(slowAnimIterator == NULL);
|
|
slowAnimIterator = new MW4Animation::AnimIterator(slowAnimInstance);
|
|
Register_Pointer(slowAnimIterator);
|
|
|
|
Verify(fastAnimIterator == NULL);
|
|
fastAnimIterator = new MW4Animation::AnimIterator(fastAnimInstance);
|
|
Register_Pointer(fastAnimIterator);
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void SpeedBlenderCycleHolder::UnloadIterators(void)
|
|
{
|
|
Verify(slowAnimIterator != NULL);
|
|
Unregister_Pointer(slowAnimIterator);
|
|
delete slowAnimIterator;
|
|
slowAnimIterator = NULL;
|
|
|
|
Verify(fastAnimIterator != NULL);
|
|
Unregister_Pointer(fastAnimIterator);
|
|
delete fastAnimIterator;
|
|
fastAnimIterator = NULL;
|
|
|
|
currentTime = -1.0f;
|
|
}
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
Stuff::Scalar SpeedBlenderCycleHolder::GetCurrentPercentage()
|
|
{
|
|
Verify(slowAnimInstance != NULL);
|
|
|
|
Scalar percent = currentTime / GetTimeTotal();
|
|
|
|
percent *= percentageOfChain;
|
|
percent += startPercentage;
|
|
|
|
Verify(percent <= 1.0f);
|
|
Verify(percent >= 0.0f);
|
|
|
|
return
|
|
percent;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
Stuff::Scalar SpeedBlenderCycleHolder::GetTimeTotal()
|
|
{
|
|
Verify(slowAnimInstance != NULL);
|
|
|
|
Scalar anim_time = slowAnimInstance->animData->animHeaderBlock->endTime -
|
|
slowAnimInstance->animData->animHeaderBlock->startTime;
|
|
|
|
if (startPosition == -1.0f)
|
|
{
|
|
return (anim_time + startDelay);
|
|
}
|
|
|
|
return
|
|
anim_time + startDelay - (anim_time * startPosition);
|
|
}
|
|
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void LerpCycleHolder::Load(AnimationStateEngine *anim_state_engine, NameList *param_list, bool run_minimal)
|
|
{
|
|
|
|
NameList::Entry *page = param_list->FindEntry("AnimType");
|
|
Check_Object(page);
|
|
|
|
page = param_list->FindEntry("Position");
|
|
Check_Object(page);
|
|
targetPosition = page->GetAtof();
|
|
|
|
|
|
page = param_list->FindEntry("LerpTime");
|
|
Check_Object(page);
|
|
lerpTime = page->GetAtof();
|
|
|
|
|
|
page = param_list->FindEntry("Anim");
|
|
Check_Object(page);
|
|
|
|
// god i hate mstrings...
|
|
MString string;
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
animInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(animInstance);
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
bool LerpCycleHolder::Advance(AnimationStateEngine *anim_state_engine, Stuff::Scalar time_slice, bool run_minimal)
|
|
{
|
|
|
|
currentTime += time_slice;
|
|
|
|
if (currentTime >= startDelay)
|
|
{
|
|
|
|
if (currentTime > lerpTime + startDelay)
|
|
{
|
|
carryOver = currentTime - startDelay;
|
|
return true;
|
|
}
|
|
animIterator->SetVelocityScale(0.0f);
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(animIterator);
|
|
}
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void LerpCycleHolder::Que(Stuff::Scalar position, bool run_minimal)
|
|
{
|
|
|
|
|
|
Verify(animIterator != NULL);
|
|
animIterator->SetPosition(targetPosition);
|
|
currentTime = 0.0f;
|
|
|
|
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
|
|
void LerpCycleHolder::LoadIterators(bool run_minimal)
|
|
{
|
|
Verify(animIterator == NULL);
|
|
animIterator = new MW4Animation::AnimIterator(animInstance);
|
|
Register_Pointer(animIterator);
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void LerpCycleHolder::UnloadIterators(void)
|
|
{
|
|
Verify(animIterator != NULL);
|
|
Unregister_Pointer(animIterator);
|
|
delete animIterator;
|
|
animIterator = NULL;
|
|
currentTime = -1.0f;
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
Stuff::Scalar LerpCycleHolder::GetCurrentPercentage()
|
|
{
|
|
Verify(animInstance != NULL);
|
|
|
|
Scalar percent = currentTime / lerpTime + startDelay;
|
|
|
|
percent *= percentageOfChain;
|
|
percent += startPercentage;
|
|
|
|
Verify(percent <= 1.0f);
|
|
Verify(percent >= 0.0f);
|
|
|
|
return percent;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
Stuff::Scalar LerpCycleHolder::GetTimeTotal()
|
|
{
|
|
Verify(animInstance != NULL);
|
|
return
|
|
currentTime + startDelay;
|
|
}
|
|
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void FullHeightBlenderCycleHolder::Load(AnimationStateEngine *anim_state_engine, NameList *param_list, bool run_minimal)
|
|
{
|
|
|
|
NameList::Entry *page = param_list->FindEntry("AnimType");
|
|
Check_Object(page);
|
|
|
|
page = param_list->FindEntry("Position");
|
|
Check_Object(page);
|
|
|
|
if (!_stricmp(page->GetChar(), "old"))
|
|
{
|
|
startPosition = -1;
|
|
}
|
|
else
|
|
{
|
|
startPosition = page->GetAtof();
|
|
}
|
|
|
|
|
|
|
|
MString string;
|
|
page = param_list->FindEntry("EvenAnim");
|
|
Check_Object(page);
|
|
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
evenAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(evenAnimInstance);
|
|
|
|
|
|
if (!run_minimal)
|
|
{
|
|
page = param_list->FindEntry("UpAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
upAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(upAnimInstance);
|
|
|
|
|
|
page = param_list->FindEntry("DownAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
downAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(downAnimInstance);
|
|
|
|
|
|
page = param_list->FindEntry("LeftAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
leftAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(leftAnimInstance);
|
|
|
|
page = param_list->FindEntry("RightAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
rightAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(rightAnimInstance);
|
|
}
|
|
|
|
|
|
|
|
|
|
page = param_list->FindEntry("RollAttrib");
|
|
Check_Object(page);
|
|
|
|
rollAttrib = anim_state_engine->vehicleParent->GetAttributeEntry(page->GetChar());
|
|
Check_Object(rollAttrib);
|
|
|
|
page = param_list->FindEntry("PitchAttrib");
|
|
Check_Object(page);
|
|
|
|
pitchAttrib = anim_state_engine->vehicleParent->GetAttributeEntry(page->GetChar());
|
|
Check_Object(pitchAttrib);
|
|
|
|
|
|
page = param_list->FindEntry("SpeedAttrib");
|
|
Check_Object(page);
|
|
|
|
speedAttrib = anim_state_engine->vehicleParent->GetAttributeEntry(page->GetChar());
|
|
Check_Object(speedAttrib);
|
|
|
|
|
|
// get the speed
|
|
animSpeed = 0.0f;
|
|
|
|
MW4Animation::AnimIterator *anim_iterator = new MW4Animation::AnimIterator(evenAnimInstance);
|
|
Register_Pointer(anim_iterator);
|
|
|
|
for (int i = 0; i < evenAnimInstance->animData->GetChannelCount(); ++i)
|
|
{
|
|
if (evenAnimInstance->animData->animChannelBlock[i].channelType ==
|
|
MW4Animation::ChannelAnimData::VelocityChannelType )
|
|
{
|
|
MW4Animation::BaseKeyframe *keyframe = NULL;
|
|
keyframe = anim_iterator->GetLastKeyFrame(i);
|
|
|
|
MW4Animation::BaseKeyframeTime *keyframetime = NULL;
|
|
keyframetime = anim_iterator->GetLastKeyFrameTime(i);
|
|
|
|
animSpeed = Abs(MW4Animation::Point3DVelPosSnapInterpolator(keyframe, keyframe, keyframetime, keyframetime, 0.0f).z);
|
|
|
|
keyframe = anim_iterator->GetFirstKeyFrame(i);
|
|
keyframetime = anim_iterator->GetFirstKeyFrameTime(i);
|
|
|
|
|
|
if (animSpeed < Abs(MW4Animation::Point3DVelPosSnapInterpolator(keyframe, keyframe, keyframetime, keyframetime, 0.0f).z))
|
|
{
|
|
animSpeed = Abs(MW4Animation::Point3DVelPosSnapInterpolator(keyframe, keyframe, keyframetime, keyframetime, 0.0f).z);
|
|
}
|
|
}
|
|
}
|
|
|
|
Unregister_Pointer(anim_iterator);
|
|
delete anim_iterator;
|
|
|
|
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
bool FullHeightBlenderCycleHolder::Advance(AnimationStateEngine *anim_state_engine, Stuff::Scalar time_slice, bool run_minimal)
|
|
{
|
|
|
|
#ifdef _ARMOR
|
|
Verify(evenAnimIterator != NULL);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
Verify(upAnimIterator != NULL);
|
|
Verify(downAnimIterator != NULL);
|
|
Verify(leftAnimIterator != NULL);
|
|
Verify(rightAnimIterator != NULL);
|
|
}
|
|
#endif
|
|
|
|
Stuff::Scalar current_speed;
|
|
speedAttrib->GetValue(anim_state_engine->vehicleParent, ¤t_speed);
|
|
current_speed = Abs(current_speed);
|
|
|
|
Stuff::Scalar time_slow_down = 0.0f;
|
|
|
|
if (!Small_Enough(animSpeed, 0.0f))
|
|
{
|
|
time_slow_down = current_speed/animSpeed;
|
|
}
|
|
else
|
|
{
|
|
// if the animspeed is 0 then we just play full speed with no speed effect
|
|
time_slow_down = 1.0f;
|
|
}
|
|
|
|
currentTime += (time_slice * time_slow_down);
|
|
|
|
if (currentTime >= startDelay)
|
|
{
|
|
evenAnimIterator->SetVelocityScale(time_slow_down);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
downAnimIterator->SetVelocityScale(time_slow_down);
|
|
upAnimIterator->SetVelocityScale(time_slow_down);
|
|
leftAnimIterator->SetVelocityScale(time_slow_down);
|
|
rightAnimIterator->SetVelocityScale(time_slow_down);
|
|
}
|
|
|
|
AnimHierarchyNode *heir_node = NULL;
|
|
heir_node = anim_state_engine->iteratorManager->PushLayer(1.0f);
|
|
|
|
|
|
Stuff::Scalar roll_slope;
|
|
Stuff::Scalar pitch_slope;
|
|
|
|
rollAttrib->GetValue(anim_state_engine->vehicleParent, &roll_slope);
|
|
pitchAttrib->GetValue(anim_state_engine->vehicleParent, &pitch_slope);
|
|
|
|
if(time_slow_down > 0.0f)
|
|
{
|
|
Stuff::Scalar position;
|
|
position = evenAnimIterator->GetPosition();
|
|
if (evenAnimIterator->IncrementTime(time_slice * time_slow_down))
|
|
{
|
|
carryOver = evenAnimIterator->GetCarryOverTime()/time_slow_down;;
|
|
anim_state_engine->iteratorManager->UndoPush();
|
|
return true;
|
|
}
|
|
|
|
position = evenAnimIterator->GetPosition() - position;
|
|
if (position != 0.0f && !run_minimal)
|
|
{
|
|
downAnimIterator->IncrementPosition(position);
|
|
upAnimIterator->IncrementPosition(position);
|
|
leftAnimIterator->IncrementPosition(position);
|
|
rightAnimIterator->IncrementPosition(position);
|
|
}
|
|
}
|
|
|
|
// figure out blend value
|
|
|
|
Stuff::Scalar up_blend = 0.0f;
|
|
Stuff::Scalar down_blend = 0.0f;
|
|
Stuff::Scalar even_blend = 0.0f;
|
|
Stuff::Scalar left_blend = 0.0f;
|
|
Stuff::Scalar right_blend = 0.0f;
|
|
|
|
//SPEW(("jerryeds", "ps: %f", pitch_slope));
|
|
|
|
if(pitch_slope > 0.0f)
|
|
{
|
|
down_blend = 0.0f;
|
|
Max_Clamp(pitch_slope, Pi_Over_4);
|
|
|
|
up_blend = pitch_slope/Pi_Over_4;
|
|
//even_blend = 1.0f - up_blend;
|
|
|
|
//SPEW(("jerryeds", "db: %f", up_blend));
|
|
}
|
|
else if(pitch_slope < 0.0f)
|
|
{
|
|
up_blend = 0.0f;
|
|
pitch_slope = -pitch_slope;
|
|
Max_Clamp(pitch_slope, Pi_Over_4);
|
|
|
|
down_blend = pitch_slope/Pi_Over_4;
|
|
//even_blend = 1.0f - down_blend;
|
|
|
|
//SPEW(("jerryeds", "db: %f", down_blend));
|
|
|
|
}
|
|
else
|
|
{
|
|
down_blend = 0.0f;
|
|
up_blend = 0.0f;
|
|
}
|
|
|
|
if(roll_slope > 0.0f)
|
|
{
|
|
right_blend = 0.0f;
|
|
Max_Clamp(roll_slope, Pi_Over_4);
|
|
|
|
left_blend = roll_slope/Pi_Over_4;
|
|
//even_blend = 1.0f - right_blend;
|
|
|
|
//SPEW(("jerryeds", "db: %f", up_blend));
|
|
}
|
|
else if(roll_slope < 0.0f)
|
|
{
|
|
left_blend = 0.0f;
|
|
roll_slope = -roll_slope;
|
|
Max_Clamp(roll_slope, Pi_Over_4);
|
|
|
|
right_blend = roll_slope/Pi_Over_4;
|
|
//even_blend = 1.0f - left_blend;
|
|
|
|
//SPEW(("jerryeds", "db: %f", down_blend));
|
|
|
|
}
|
|
else
|
|
{
|
|
right_blend = 0.0f;
|
|
left_blend = 0.0f;
|
|
}
|
|
|
|
|
|
if ((left_blend + right_blend + up_blend + down_blend) < 1.0f)
|
|
{
|
|
even_blend = 1.0f - (left_blend + right_blend + up_blend + down_blend);
|
|
}
|
|
else
|
|
{
|
|
even_blend = 0.015f;
|
|
}
|
|
|
|
//SPEW(("jerryeds", "%f - P<%f:%f> R<%f:%f>", even_blend, left_blend, right_blend, up_blend, down_blend));
|
|
|
|
evenAnimIterator->SetBlendValue(even_blend);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
downAnimIterator->SetBlendValue(down_blend);
|
|
upAnimIterator->SetBlendValue(up_blend);
|
|
leftAnimIterator->SetBlendValue(left_blend);
|
|
rightAnimIterator->SetBlendValue(right_blend);
|
|
}
|
|
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(evenAnimIterator);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(upAnimIterator);
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(downAnimIterator);
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(leftAnimIterator);
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(rightAnimIterator);
|
|
}
|
|
|
|
// add the curve
|
|
if (curveCount)
|
|
{
|
|
// we don't support multiple curves now
|
|
Check_Pointer(heir_node);
|
|
Verify(curveCount == 1);
|
|
heir_node->SetBlendValue(anim_state_engine->animCurves[firstCurve].Play(evenAnimIterator->GetPosition()));
|
|
}
|
|
|
|
anim_state_engine->iteratorManager->PopLayer();
|
|
}
|
|
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void FullHeightBlenderCycleHolder::Que(Stuff::Scalar position, bool run_minimal)
|
|
{
|
|
|
|
#ifdef _ARMOR
|
|
Verify(evenAnimIterator != NULL);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
Verify(upAnimIterator != NULL);
|
|
Verify(downAnimIterator != NULL);
|
|
Verify(leftAnimIterator != NULL);
|
|
Verify(rightAnimIterator != NULL);
|
|
}
|
|
#endif
|
|
|
|
|
|
if (position != -1.0f )
|
|
{
|
|
evenAnimIterator->SetPosition(position);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
upAnimIterator->SetPosition(position);
|
|
downAnimIterator->SetPosition(position);
|
|
leftAnimIterator->SetPosition(position);
|
|
rightAnimIterator->SetPosition(position);
|
|
}
|
|
Verify(startDelay == 0.0f);
|
|
|
|
currentTime = GetTimeTotal() * position;
|
|
}
|
|
else
|
|
{
|
|
|
|
evenAnimIterator->SetPosition(startPosition);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
upAnimIterator->SetPosition(startPosition);
|
|
downAnimIterator->SetPosition(startPosition);
|
|
leftAnimIterator->SetPosition(startPosition);
|
|
rightAnimIterator->SetPosition(startPosition);
|
|
}
|
|
currentTime = 0.0f;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void FullHeightBlenderCycleHolder::LoadIterators(bool run_minimal)
|
|
{
|
|
|
|
Verify(evenAnimIterator == NULL);
|
|
evenAnimIterator = new MW4Animation::AnimIterator(evenAnimInstance);
|
|
Register_Pointer(evenAnimIterator);
|
|
|
|
|
|
if (!run_minimal)
|
|
{
|
|
Verify(upAnimIterator == NULL);
|
|
upAnimIterator = new MW4Animation::AnimIterator(upAnimInstance);
|
|
Register_Pointer(upAnimIterator);
|
|
|
|
Verify(downAnimIterator == NULL);
|
|
downAnimIterator = new MW4Animation::AnimIterator(downAnimInstance);
|
|
Register_Pointer(downAnimIterator);
|
|
|
|
Verify(leftAnimIterator == NULL);
|
|
leftAnimIterator = new MW4Animation::AnimIterator(leftAnimInstance);
|
|
Register_Pointer(leftAnimIterator);
|
|
|
|
Verify(rightAnimIterator == NULL);
|
|
rightAnimIterator = new MW4Animation::AnimIterator(rightAnimInstance);
|
|
Register_Pointer(rightAnimIterator);
|
|
}
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void FullHeightBlenderCycleHolder::UnloadIterators(void)
|
|
{
|
|
|
|
Verify(evenAnimIterator != NULL);
|
|
Unregister_Pointer(evenAnimIterator);
|
|
delete evenAnimIterator;
|
|
evenAnimIterator = NULL;
|
|
|
|
|
|
// blends are loaded
|
|
if(upAnimIterator != NULL)
|
|
{
|
|
Unregister_Pointer(upAnimIterator);
|
|
delete upAnimIterator;
|
|
upAnimIterator = NULL;
|
|
|
|
Verify(downAnimIterator != NULL);
|
|
Unregister_Pointer(downAnimIterator);
|
|
delete downAnimIterator;
|
|
downAnimIterator = NULL;
|
|
|
|
Verify(leftAnimIterator != NULL);
|
|
Unregister_Pointer(leftAnimIterator);
|
|
delete leftAnimIterator;
|
|
leftAnimIterator = NULL;
|
|
|
|
Verify(rightAnimIterator != NULL);
|
|
Unregister_Pointer(rightAnimIterator);
|
|
delete rightAnimIterator;
|
|
rightAnimIterator = NULL;
|
|
}
|
|
|
|
|
|
currentTime = -1.0f;
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
Stuff::Scalar FullHeightBlenderCycleHolder::GetCurrentPercentage()
|
|
{
|
|
Verify(evenAnimInstance != NULL);
|
|
|
|
Scalar percent = currentTime / GetTimeTotal();
|
|
|
|
percent *= percentageOfChain;
|
|
percent += startPercentage;
|
|
|
|
Verify(percent <= 1.0f);
|
|
Verify(percent >= 0.0f);
|
|
|
|
return
|
|
percent;
|
|
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
Stuff::Scalar FullHeightBlenderCycleHolder::GetTimeTotal()
|
|
{
|
|
Verify(evenAnimInstance != NULL);
|
|
|
|
Scalar anim_time = evenAnimInstance->animData->animHeaderBlock->endTime -
|
|
evenAnimInstance->animData->animHeaderBlock->startTime;
|
|
|
|
if (startPosition == -1.0f)
|
|
{
|
|
return (anim_time + startDelay);
|
|
}
|
|
|
|
return
|
|
anim_time + startDelay - (anim_time * startPosition);
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void FullHeightSpeedBlenderCycleHolder::Load(AnimationStateEngine *anim_state_engine, NameList *param_list, bool run_minimal)
|
|
{
|
|
|
|
NameList::Entry *page = param_list->FindEntry("AnimType");
|
|
Check_Object(page);
|
|
|
|
page = param_list->FindEntry("Position");
|
|
Check_Object(page);
|
|
|
|
if (!_stricmp(page->GetChar(), "old"))
|
|
{
|
|
startPosition = -1;
|
|
}
|
|
else
|
|
{
|
|
startPosition = page->GetAtof();
|
|
}
|
|
|
|
page = param_list->FindEntry("SlowUpAnim");
|
|
Check_Object(page);
|
|
|
|
// god i hate mstrings...
|
|
MString string;
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
slowUpAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(slowUpAnimInstance);
|
|
|
|
page = param_list->FindEntry("SlowEvenAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
slowEvenAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(slowEvenAnimInstance);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
page = param_list->FindEntry("SlowDownAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
slowDownAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(slowDownAnimInstance);
|
|
|
|
|
|
page = param_list->FindEntry("SlowLeftAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
slowLeftAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(slowLeftAnimInstance);
|
|
|
|
page = param_list->FindEntry("SlowRightAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
slowRightAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(slowRightAnimInstance);
|
|
}
|
|
|
|
|
|
|
|
page = param_list->FindEntry("FastEvenAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
fastEvenAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(fastEvenAnimInstance);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
page = param_list->FindEntry("FastUpAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
fastUpAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(fastUpAnimInstance);
|
|
|
|
page = param_list->FindEntry("FastDownAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
fastDownAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(fastDownAnimInstance);
|
|
|
|
|
|
page = param_list->FindEntry("FastLeftAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
fastLeftAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(fastLeftAnimInstance);
|
|
|
|
page = param_list->FindEntry("FastRightAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
fastRightAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(fastRightAnimInstance);
|
|
}
|
|
|
|
|
|
page = param_list->FindEntry("RollAttrib");
|
|
Check_Object(page);
|
|
|
|
rollAttrib = anim_state_engine->vehicleParent->GetAttributeEntry(page->GetChar());
|
|
Check_Object(rollAttrib);
|
|
|
|
page = param_list->FindEntry("PitchAttrib");
|
|
Check_Object(page);
|
|
|
|
pitchAttrib = anim_state_engine->vehicleParent->GetAttributeEntry(page->GetChar());
|
|
Check_Object(pitchAttrib);
|
|
|
|
|
|
page = param_list->FindEntry("SpeedAttrib");
|
|
Check_Object(page);
|
|
|
|
speedAttrib = anim_state_engine->vehicleParent->GetAttributeEntry(page->GetChar());
|
|
Check_Object(speedAttrib);
|
|
|
|
|
|
// get the speed
|
|
slowSpeed = -1.0f;
|
|
|
|
MW4Animation::AnimIterator *anim_iterator = new MW4Animation::AnimIterator(slowEvenAnimInstance);
|
|
Register_Pointer(anim_iterator);
|
|
|
|
for (int i = 0; i < slowEvenAnimInstance->animData->GetChannelCount(); ++i)
|
|
{
|
|
if (slowEvenAnimInstance->animData->animChannelBlock[i].channelType ==
|
|
MW4Animation::ChannelAnimData::VelocityChannelType )
|
|
{
|
|
MW4Animation::BaseKeyframe *keyframe = NULL;
|
|
keyframe = anim_iterator->GetLastKeyFrame(i);
|
|
MW4Animation::BaseKeyframeTime *keyframetime = NULL;
|
|
keyframetime = anim_iterator->GetLastKeyFrameTime(i);
|
|
|
|
slowSpeed = Abs(MW4Animation::Point3DVelPosSnapInterpolator(keyframe, keyframe, keyframetime, keyframetime, 0.0f).z);
|
|
}
|
|
}
|
|
|
|
Unregister_Pointer(anim_iterator);
|
|
delete anim_iterator;
|
|
|
|
Verify(slowSpeed != -1.0f);
|
|
|
|
fastSpeed = -1.0f;
|
|
|
|
anim_iterator = new MW4Animation::AnimIterator(fastEvenAnimInstance);
|
|
Register_Pointer(anim_iterator);
|
|
|
|
for (i = 0; i < fastEvenAnimInstance->animData->GetChannelCount(); ++i)
|
|
{
|
|
if (fastEvenAnimInstance->animData->animChannelBlock[i].channelType ==
|
|
MW4Animation::ChannelAnimData::VelocityChannelType )
|
|
{
|
|
MW4Animation::BaseKeyframe *keyframe = NULL;
|
|
keyframe = anim_iterator->GetLastKeyFrame(i);
|
|
|
|
MW4Animation::BaseKeyframeTime *keyframetime = NULL;
|
|
keyframetime = anim_iterator->GetLastKeyFrameTime(i);
|
|
|
|
fastSpeed = Abs(MW4Animation::Point3DVelPosSnapInterpolator(keyframe, keyframe, keyframetime, keyframetime, 0.0f).z);
|
|
}
|
|
}
|
|
|
|
Unregister_Pointer(anim_iterator);
|
|
delete anim_iterator;
|
|
|
|
slowSpeedMultiplier = 1.0f;
|
|
page = param_list->FindEntry("SlowSpeedMultiplier");
|
|
if (page)
|
|
{
|
|
slowSpeedMultiplier = page->GetAtof();
|
|
}
|
|
|
|
Verify(fastSpeed != -1.0f);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
bool FullHeightSpeedBlenderCycleHolder::Advance(AnimationStateEngine *anim_state_engine, Stuff::Scalar time_slice, bool run_minimal)
|
|
{
|
|
#ifdef _ARMOR
|
|
Verify(slowEvenAnimIterator != NULL);
|
|
Verify(fastEvenAnimIterator != NULL);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
Verify(fastUpAnimIterator != NULL);
|
|
Verify(fastDownAnimIterator != NULL);
|
|
Verify(fastLeftAnimIterator != NULL);
|
|
Verify(fastRightAnimIterator != NULL);
|
|
Verify(slowUpAnimIterator != NULL);
|
|
Verify(slowDownAnimIterator != NULL);
|
|
Verify(slowLeftAnimIterator != NULL);
|
|
Verify(slowRightAnimIterator != NULL);
|
|
}
|
|
#endif
|
|
// frig with the time slice
|
|
Stuff::Scalar current_speed;
|
|
speedAttrib->GetValue(anim_state_engine->vehicleParent, ¤t_speed);
|
|
current_speed = Abs(current_speed);
|
|
|
|
Stuff::Scalar slow_blend_value = 0.0f;
|
|
Stuff::Scalar fast_blend_value = 0.0f;
|
|
|
|
|
|
if (currentTime >= startDelay)
|
|
{
|
|
// we want to be absolutly sure that we mix the animations in their own layer
|
|
AnimHierarchyNode *heir_node = NULL;
|
|
heir_node = anim_state_engine->iteratorManager->PushLayer(1.0f);
|
|
|
|
//{
|
|
if (current_speed < (slowSpeed * slowSpeedMultiplier))
|
|
{
|
|
|
|
|
|
Stuff::Scalar position = slowEvenAnimIterator->GetPosition();
|
|
Stuff::Scalar time_slow_down = current_speed/slowSpeed;
|
|
|
|
//SPEWALWAYS(("jerryeds", "SLOW SPEED ts:%f slow:%f speed:%f", time_slice, time_slow_down, current_speed));
|
|
|
|
if(time_slow_down > 0.0f)
|
|
{
|
|
currentTime += (time_slice * time_slow_down);
|
|
|
|
if( slowEvenAnimIterator->IncrementTime(time_slice * time_slow_down) )
|
|
{
|
|
carryOver = slowEvenAnimIterator->GetCarryOverTime()/time_slow_down;;
|
|
fastEvenAnimIterator->SetPosition(1.0f);
|
|
anim_state_engine->iteratorManager->UndoPush();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
Scalar fast_position = slowEvenAnimIterator->GetPosition() - fastEvenAnimIterator->GetPosition();
|
|
Scalar slow_position = slowEvenAnimIterator->GetPosition() - position;
|
|
|
|
|
|
fastEvenAnimIterator->IncrementPosition(fast_position);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
fastUpAnimIterator->IncrementPosition(fast_position);
|
|
fastDownAnimIterator->IncrementPosition(fast_position);
|
|
fastLeftAnimIterator->IncrementPosition(fast_position);
|
|
fastRightAnimIterator->IncrementPosition(fast_position);
|
|
slowUpAnimIterator->IncrementPosition(slow_position);
|
|
slowDownAnimIterator->IncrementPosition(slow_position);
|
|
slowLeftAnimIterator->IncrementPosition(slow_position);
|
|
slowRightAnimIterator->IncrementPosition(slow_position);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fastEvenAnimIterator->SetVelocityScale(time_slow_down);
|
|
slowEvenAnimIterator->SetVelocityScale(time_slow_down);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
fastUpAnimIterator->SetVelocityScale(time_slow_down);
|
|
fastDownAnimIterator->SetVelocityScale(time_slow_down);
|
|
fastLeftAnimIterator->SetVelocityScale(time_slow_down);
|
|
fastRightAnimIterator->SetVelocityScale(time_slow_down);
|
|
slowUpAnimIterator->SetVelocityScale(time_slow_down);
|
|
slowDownAnimIterator->SetVelocityScale(time_slow_down);
|
|
slowLeftAnimIterator->SetVelocityScale(time_slow_down);
|
|
slowRightAnimIterator->SetVelocityScale(time_slow_down);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
slowEvenAnimIterator->SetVelocityScale(0.0f);
|
|
fastEvenAnimIterator->SetVelocityScale(0.0f);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
fastUpAnimIterator->SetVelocityScale(0.0f);
|
|
fastDownAnimIterator->SetVelocityScale(0.0f);
|
|
fastLeftAnimIterator->SetVelocityScale(0.0f);
|
|
fastRightAnimIterator->SetVelocityScale(0.0f);
|
|
slowUpAnimIterator->SetVelocityScale(0.0f);
|
|
slowDownAnimIterator->SetVelocityScale(0.0f);
|
|
slowLeftAnimIterator->SetVelocityScale(0.0f);
|
|
slowRightAnimIterator->SetVelocityScale(0.0f);
|
|
}
|
|
}
|
|
|
|
slow_blend_value = 1.0f;
|
|
fast_blend_value = 0.0f;
|
|
|
|
//Start(anim_state_engine);
|
|
}
|
|
else if (current_speed >= fastSpeed)
|
|
{
|
|
Stuff::Scalar position = fastEvenAnimIterator->GetPosition();
|
|
Stuff::Scalar time_slow_down = current_speed/fastSpeed;
|
|
currentTime += (time_slice * time_slow_down);
|
|
|
|
//SPEWALWAYS(("jerryeds", "FAST SPEED ts:%f speed:%f slow:%f ", time_slice, current_speed, time_slow_down));
|
|
|
|
if(time_slow_down > 0.0f)
|
|
{
|
|
if( fastEvenAnimIterator->IncrementTime(time_slice * time_slow_down) )
|
|
{
|
|
carryOver = fastEvenAnimIterator->GetCarryOverTime()/time_slow_down;;
|
|
slowEvenAnimIterator->SetPosition(1.0f);
|
|
anim_state_engine->iteratorManager->UndoPush();
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
Scalar slow_position = fastEvenAnimIterator->GetPosition() - slowEvenAnimIterator->GetPosition();
|
|
Scalar fast_position = fastEvenAnimIterator->GetPosition() - position;
|
|
|
|
|
|
slowEvenAnimIterator->IncrementPosition(slow_position);
|
|
if (!run_minimal)
|
|
{
|
|
fastUpAnimIterator->IncrementPosition(fast_position);
|
|
fastDownAnimIterator->IncrementPosition(fast_position);
|
|
fastLeftAnimIterator->IncrementPosition(fast_position);
|
|
fastRightAnimIterator->IncrementPosition(fast_position);
|
|
|
|
slowUpAnimIterator->IncrementPosition(slow_position);
|
|
slowDownAnimIterator->IncrementPosition(slow_position);
|
|
slowLeftAnimIterator->IncrementPosition(slow_position);
|
|
slowRightAnimIterator->IncrementPosition(slow_position);
|
|
}
|
|
|
|
}
|
|
|
|
fastEvenAnimIterator->SetVelocityScale(time_slow_down);
|
|
slowEvenAnimIterator->SetVelocityScale(time_slow_down);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
fastUpAnimIterator->SetVelocityScale(time_slow_down);
|
|
fastDownAnimIterator->SetVelocityScale(time_slow_down);
|
|
fastLeftAnimIterator->SetVelocityScale(time_slow_down);
|
|
fastRightAnimIterator->SetVelocityScale(time_slow_down);
|
|
slowUpAnimIterator->SetVelocityScale(time_slow_down);
|
|
slowDownAnimIterator->SetVelocityScale(time_slow_down);
|
|
slowLeftAnimIterator->SetVelocityScale(time_slow_down);
|
|
slowRightAnimIterator->SetVelocityScale(time_slow_down);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fastEvenAnimIterator->SetVelocityScale(0.0f);
|
|
slowEvenAnimIterator->SetVelocityScale(0.0f);
|
|
if (!run_minimal)
|
|
{
|
|
fastUpAnimIterator->SetVelocityScale(0.0f);
|
|
fastDownAnimIterator->SetVelocityScale(0.0f);
|
|
fastLeftAnimIterator->SetVelocityScale(0.0f);
|
|
fastRightAnimIterator->SetVelocityScale(0.0f);
|
|
slowUpAnimIterator->SetVelocityScale(0.0f);
|
|
slowDownAnimIterator->SetVelocityScale(0.0f);
|
|
slowLeftAnimIterator->SetVelocityScale(0.0f);
|
|
slowRightAnimIterator->SetVelocityScale(0.0f);
|
|
}
|
|
}
|
|
slow_blend_value = 0.0f;
|
|
fast_blend_value = 1.0f;
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
|
|
|
|
//we are in blending mode...
|
|
Stuff::Scalar position = fastEvenAnimIterator->GetPosition();
|
|
|
|
//run is in control
|
|
|
|
currentTime += time_slice;
|
|
|
|
if( fastEvenAnimIterator->IncrementTime(time_slice) )
|
|
{
|
|
carryOver = fastEvenAnimIterator->GetCarryOverTime();
|
|
slowEvenAnimIterator->SetPosition(1.0f);
|
|
anim_state_engine->iteratorManager->UndoPush();
|
|
//SPEWALWAYS(("jerryeds", "BLEND CO ts:%f speed:%f co:%f", time_slice, current_speed, carryOver));
|
|
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
|
|
Scalar slow_position = fastEvenAnimIterator->GetPosition() - slowEvenAnimIterator->GetPosition();
|
|
Scalar fast_position = fastEvenAnimIterator->GetPosition() - position;
|
|
|
|
|
|
slowEvenAnimIterator->IncrementPosition(slow_position);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
fastUpAnimIterator->IncrementPosition(fast_position);
|
|
fastDownAnimIterator->IncrementPosition(fast_position);
|
|
fastLeftAnimIterator->IncrementPosition(fast_position);
|
|
fastRightAnimIterator->IncrementPosition(fast_position);
|
|
|
|
slowUpAnimIterator->IncrementPosition(slow_position);
|
|
slowDownAnimIterator->IncrementPosition(slow_position);
|
|
slowLeftAnimIterator->IncrementPosition(slow_position);
|
|
slowRightAnimIterator->IncrementPosition(slow_position);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
slowEvenAnimIterator->SetVelocityScale(1.0f);
|
|
fastEvenAnimIterator->SetVelocityScale(1.0f);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
fastUpAnimIterator->SetVelocityScale(1.0f);
|
|
fastDownAnimIterator->SetVelocityScale(1.0f);
|
|
fastLeftAnimIterator->SetVelocityScale(1.0f);
|
|
fastRightAnimIterator->SetVelocityScale(1.0f);
|
|
slowUpAnimIterator->SetVelocityScale(1.0f);
|
|
slowDownAnimIterator->SetVelocityScale(1.0f);
|
|
slowLeftAnimIterator->SetVelocityScale(1.0f);
|
|
slowRightAnimIterator->SetVelocityScale(1.0f);
|
|
}
|
|
|
|
Scalar speed_diff = fastSpeed - slowSpeed;
|
|
fast_blend_value = (current_speed - slowSpeed)/speed_diff;
|
|
slow_blend_value = 1.0f - fast_blend_value;
|
|
|
|
|
|
//SPEWALWAYS(("jerryeds", "BLEND ts:%f speed:%f sp:%f fp:%f", time_slice, current_speed, slowEvenAnimIterator->GetPosition(), fastEvenAnimIterator->GetPosition()));
|
|
|
|
}
|
|
|
|
// start
|
|
|
|
CalculateAndSetHeightCurves(anim_state_engine, run_minimal);
|
|
|
|
Verify(Close_Enough(fast_blend_value + slow_blend_value, 1.0f));
|
|
|
|
anim_state_engine->iteratorManager->PushLayer(slow_blend_value);
|
|
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(slowEvenAnimIterator);
|
|
if (!run_minimal)
|
|
{
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(slowUpAnimIterator);
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(slowDownAnimIterator);
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(slowLeftAnimIterator);
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(slowRightAnimIterator);
|
|
}
|
|
|
|
anim_state_engine->iteratorManager->PopLayer();
|
|
|
|
|
|
anim_state_engine->iteratorManager->PushLayer(fast_blend_value);
|
|
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(fastEvenAnimIterator);
|
|
if (!run_minimal)
|
|
{
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(fastUpAnimIterator);
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(fastDownAnimIterator);
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(fastLeftAnimIterator);
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(fastRightAnimIterator);
|
|
}
|
|
anim_state_engine->iteratorManager->PopLayer();
|
|
|
|
|
|
|
|
|
|
anim_state_engine->iteratorManager->PopLayer();
|
|
|
|
// add the curve
|
|
if (curveCount)
|
|
{
|
|
// we don't support multiple curves now
|
|
Check_Pointer(heir_node);
|
|
Verify(curveCount == 1);
|
|
heir_node->SetBlendValue(anim_state_engine->animCurves[firstCurve].Play(fastEvenAnimIterator->GetPosition()));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
currentTime += time_slice;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void FullHeightSpeedBlenderCycleHolder::CalculateAndSetHeightCurves(AnimationStateEngine *anim_state_engine, bool run_minimal)
|
|
{
|
|
|
|
Stuff::Scalar roll_slope;
|
|
Stuff::Scalar pitch_slope;
|
|
|
|
// figure out blend value
|
|
rollAttrib->GetValue(anim_state_engine->vehicleParent, &roll_slope);
|
|
pitchAttrib->GetValue(anim_state_engine->vehicleParent, &pitch_slope);
|
|
|
|
Stuff::Scalar up_blend = 0.0f;
|
|
Stuff::Scalar down_blend = 0.0f;
|
|
Stuff::Scalar even_blend = 0.0f;
|
|
Stuff::Scalar left_blend = 0.0f;
|
|
Stuff::Scalar right_blend = 0.0f;
|
|
|
|
//SPEW(("jerryeds", "ps: %f", pitch_slope));
|
|
|
|
if(pitch_slope > 0.0f)
|
|
{
|
|
down_blend = 0.0f;
|
|
Max_Clamp(pitch_slope, Pi_Over_4);
|
|
|
|
up_blend = pitch_slope/Pi_Over_4;
|
|
|
|
}
|
|
else if(pitch_slope < 0.0f)
|
|
{
|
|
up_blend = 0.0f;
|
|
pitch_slope = -pitch_slope;
|
|
Max_Clamp(pitch_slope, Pi_Over_4);
|
|
|
|
down_blend = pitch_slope/Pi_Over_4;
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
down_blend = 0.0f;
|
|
up_blend = 0.0f;
|
|
}
|
|
|
|
if(roll_slope > 0.0f)
|
|
{
|
|
right_blend = 0.0f;
|
|
Max_Clamp(roll_slope, Pi_Over_4);
|
|
|
|
left_blend = roll_slope/Pi_Over_4;
|
|
|
|
}
|
|
else if(roll_slope < 0.0f)
|
|
{
|
|
left_blend = 0.0f;
|
|
roll_slope = -roll_slope;
|
|
Max_Clamp(roll_slope, Pi_Over_4);
|
|
|
|
right_blend = roll_slope/Pi_Over_4;
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
right_blend = 0.0f;
|
|
left_blend = 0.0f;
|
|
}
|
|
|
|
|
|
if ((left_blend + right_blend + up_blend + down_blend) < 1.0f)
|
|
{
|
|
even_blend = 1.0f - (left_blend + right_blend + up_blend + down_blend);
|
|
}
|
|
else
|
|
{
|
|
even_blend = 0.015f;
|
|
}
|
|
|
|
fastEvenAnimIterator->SetBlendValue(even_blend);
|
|
slowEvenAnimIterator->SetBlendValue(even_blend);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
fastDownAnimIterator->SetBlendValue(down_blend);
|
|
fastUpAnimIterator->SetBlendValue(up_blend);
|
|
fastLeftAnimIterator->SetBlendValue(left_blend);
|
|
fastRightAnimIterator->SetBlendValue(right_blend);
|
|
slowDownAnimIterator->SetBlendValue(down_blend);
|
|
slowUpAnimIterator->SetBlendValue(up_blend);
|
|
slowLeftAnimIterator->SetBlendValue(left_blend);
|
|
slowRightAnimIterator->SetBlendValue(right_blend);
|
|
}
|
|
//SPEW(("jerryeds", "%f %f %f %f %f", even_blend, up_blend, down_blend, left_blend, right_blend));
|
|
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void FullHeightSpeedBlenderCycleHolder::Que(Stuff::Scalar position, bool run_minimal)
|
|
{
|
|
|
|
|
|
//SPEWALWAYS(("jerryeds", "QUE - %f", position));
|
|
|
|
#ifdef _ARMOR
|
|
Verify(slowEvenAnimIterator != NULL);
|
|
Verify(fastEvenAnimIterator != NULL);
|
|
|
|
|
|
if (!run_minimal)
|
|
{
|
|
Verify(fastUpAnimIterator != NULL);
|
|
Verify(fastDownAnimIterator != NULL);
|
|
Verify(fastLeftAnimIterator != NULL);
|
|
Verify(fastRightAnimIterator != NULL);
|
|
Verify(slowUpAnimIterator != NULL);
|
|
Verify(slowDownAnimIterator != NULL);
|
|
Verify(slowLeftAnimIterator != NULL);
|
|
Verify(slowRightAnimIterator != NULL);
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
if (position != -1.0f)
|
|
{
|
|
fastEvenAnimIterator->SetPosition(position);
|
|
slowEvenAnimIterator->SetPosition(position);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
fastUpAnimIterator->SetPosition(position);
|
|
fastDownAnimIterator->SetPosition(position);
|
|
fastLeftAnimIterator->SetPosition(position);
|
|
fastRightAnimIterator->SetPosition(position);
|
|
slowUpAnimIterator->SetPosition(position);
|
|
slowDownAnimIterator->SetPosition(position);
|
|
slowLeftAnimIterator->SetPosition(position);
|
|
slowRightAnimIterator->SetPosition(position);
|
|
|
|
//SPEWALWAYS(("jerryeds", "R-FE-QUE - %f", fastEvenAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-FU-QUE - %f", fastUpAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-FD-QUE - %f", fastDownAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-FL-QUE - %f", fastLeftAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-FR-QUE - %f", fastRightAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-SE-QUE - %f", slowEvenAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-SU-QUE - %f", slowUpAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-SD-QUE - %f", slowDownAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-SL-QUE - %f", slowLeftAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-SR-QUE - %f", slowRightAnimIterator->GetPosition()));
|
|
|
|
}
|
|
|
|
Verify(startDelay == 0.0f);
|
|
|
|
currentTime = GetTimeTotal() * position;
|
|
}
|
|
else
|
|
{
|
|
fastEvenAnimIterator->SetPosition(startPosition);
|
|
slowEvenAnimIterator->SetPosition(startPosition);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
fastUpAnimIterator->SetPosition(startPosition);
|
|
fastDownAnimIterator->SetPosition(startPosition);
|
|
fastLeftAnimIterator->SetPosition(startPosition);
|
|
fastRightAnimIterator->SetPosition(startPosition);
|
|
slowUpAnimIterator->SetPosition(startPosition);
|
|
slowDownAnimIterator->SetPosition(startPosition);
|
|
slowLeftAnimIterator->SetPosition(startPosition);
|
|
slowRightAnimIterator->SetPosition(startPosition);
|
|
|
|
//SPEWALWAYS(("jerryeds", "R-FE-QUE - %f", fastEvenAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-FU-QUE - %f", fastUpAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-FD-QUE - %f", fastDownAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-FL-QUE - %f", fastLeftAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-FR-QUE - %f", fastRightAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-SE-QUE - %f", slowEvenAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-SU-QUE - %f", slowUpAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-SD-QUE - %f", slowDownAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-SL-QUE - %f", slowLeftAnimIterator->GetPosition()));
|
|
//SPEWALWAYS(("jerryeds", "R-SR-QUE - %f", slowRightAnimIterator->GetPosition()));
|
|
|
|
|
|
}
|
|
currentTime = 0.0f;
|
|
}
|
|
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void FullHeightSpeedBlenderCycleHolder::LoadIterators(bool run_minimal)
|
|
{
|
|
|
|
Verify(fastEvenAnimIterator == NULL);
|
|
fastEvenAnimIterator = new MW4Animation::AnimIterator(fastEvenAnimInstance);
|
|
Register_Pointer(fastEvenAnimIterator);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
Verify(fastUpAnimIterator == NULL);
|
|
fastUpAnimIterator = new MW4Animation::AnimIterator(fastUpAnimInstance);
|
|
Register_Pointer(fastUpAnimIterator);
|
|
|
|
Verify(fastDownAnimIterator == NULL);
|
|
fastDownAnimIterator = new MW4Animation::AnimIterator(fastDownAnimInstance);
|
|
Register_Pointer(fastDownAnimIterator);
|
|
|
|
Verify(fastLeftAnimIterator == NULL);
|
|
fastLeftAnimIterator = new MW4Animation::AnimIterator(fastLeftAnimInstance);
|
|
Register_Pointer(fastLeftAnimIterator);
|
|
|
|
Verify(fastRightAnimIterator == NULL);
|
|
fastRightAnimIterator = new MW4Animation::AnimIterator(fastRightAnimInstance);
|
|
Register_Pointer(fastRightAnimIterator);
|
|
}
|
|
|
|
|
|
Verify(slowEvenAnimIterator == NULL);
|
|
slowEvenAnimIterator = new MW4Animation::AnimIterator(slowEvenAnimInstance);
|
|
Register_Pointer(slowEvenAnimIterator);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
Verify(slowUpAnimIterator == NULL);
|
|
slowUpAnimIterator = new MW4Animation::AnimIterator(slowUpAnimInstance);
|
|
Register_Pointer(slowUpAnimIterator);
|
|
|
|
|
|
Verify(slowDownAnimIterator == NULL);
|
|
slowDownAnimIterator = new MW4Animation::AnimIterator(slowDownAnimInstance);
|
|
Register_Pointer(slowDownAnimIterator);
|
|
|
|
Verify(slowLeftAnimIterator == NULL);
|
|
slowLeftAnimIterator = new MW4Animation::AnimIterator(slowLeftAnimInstance);
|
|
Register_Pointer(slowLeftAnimIterator);
|
|
|
|
Verify(slowRightAnimIterator == NULL);
|
|
slowRightAnimIterator = new MW4Animation::AnimIterator(slowRightAnimInstance);
|
|
Register_Pointer(slowRightAnimIterator);
|
|
}
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void FullHeightSpeedBlenderCycleHolder::UnloadIterators(void)
|
|
{
|
|
|
|
Verify(slowEvenAnimIterator != NULL);
|
|
Unregister_Pointer(slowEvenAnimIterator);
|
|
delete slowEvenAnimIterator;
|
|
slowEvenAnimIterator = NULL;
|
|
|
|
Verify(fastEvenAnimIterator != NULL);
|
|
Unregister_Pointer(fastEvenAnimIterator);
|
|
delete fastEvenAnimIterator;
|
|
fastEvenAnimIterator = NULL;
|
|
|
|
|
|
if (slowUpAnimIterator != NULL)
|
|
{
|
|
Unregister_Pointer(slowUpAnimIterator);
|
|
delete slowUpAnimIterator;
|
|
slowUpAnimIterator = NULL;
|
|
|
|
Verify(slowDownAnimIterator != NULL);
|
|
Unregister_Pointer(slowDownAnimIterator);
|
|
delete slowDownAnimIterator;
|
|
slowDownAnimIterator = NULL;
|
|
|
|
Verify(slowLeftAnimIterator != NULL);
|
|
Unregister_Pointer(slowLeftAnimIterator);
|
|
delete slowLeftAnimIterator;
|
|
slowLeftAnimIterator = NULL;
|
|
|
|
Verify(slowRightAnimIterator != NULL);
|
|
Unregister_Pointer(slowRightAnimIterator);
|
|
delete slowRightAnimIterator;
|
|
slowRightAnimIterator = NULL;
|
|
|
|
Verify(fastUpAnimIterator != NULL);
|
|
Unregister_Pointer(fastUpAnimIterator);
|
|
delete fastUpAnimIterator;
|
|
fastUpAnimIterator = NULL;
|
|
|
|
Verify(fastDownAnimIterator != NULL);
|
|
Unregister_Pointer(fastDownAnimIterator);
|
|
delete fastDownAnimIterator;
|
|
fastDownAnimIterator = NULL;
|
|
|
|
Verify(fastLeftAnimIterator != NULL);
|
|
Unregister_Pointer(fastLeftAnimIterator);
|
|
delete fastLeftAnimIterator;
|
|
fastLeftAnimIterator = NULL;
|
|
|
|
Verify(fastRightAnimIterator != NULL);
|
|
Unregister_Pointer(fastRightAnimIterator);
|
|
delete fastRightAnimIterator;
|
|
fastRightAnimIterator = NULL;
|
|
}
|
|
|
|
|
|
currentTime = -1.0f;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
Stuff::Scalar FullHeightSpeedBlenderCycleHolder::GetCurrentPercentage()
|
|
{
|
|
Verify(slowEvenAnimInstance != NULL);
|
|
|
|
Verify(startDelay == 0.0f);
|
|
|
|
//Scalar percent = currentTime / GetTimeTotal();
|
|
Scalar percent = slowEvenAnimIterator->GetPosition();
|
|
|
|
percent *= percentageOfChain;
|
|
percent += startPercentage;
|
|
|
|
Verify(percent <= 1.0f);
|
|
Verify(percent >= 0.0f);
|
|
|
|
return
|
|
percent;
|
|
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
Stuff::Scalar FullHeightSpeedBlenderCycleHolder::GetTimeTotal()
|
|
{
|
|
Verify(slowEvenAnimInstance != NULL);
|
|
|
|
Scalar anim_time = slowEvenAnimInstance->animData->animHeaderBlock->endTime -
|
|
slowEvenAnimInstance->animData->animHeaderBlock->startTime;
|
|
|
|
if (startPosition == -1.0f)
|
|
{
|
|
return (anim_time + startDelay);
|
|
}
|
|
|
|
return
|
|
anim_time + startDelay - (anim_time * startPosition);
|
|
}
|
|
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void FullHeightPoseHolder::Load(AnimationStateEngine *anim_state_engine, NameList *param_list, bool run_minimal)
|
|
{
|
|
|
|
NameList::Entry *page = param_list->FindEntry("AnimType");
|
|
Check_Object(page);
|
|
|
|
page = param_list->FindEntry("Position");
|
|
Check_Object(page);
|
|
targetPosition = page->GetAtof();
|
|
Verify(targetPosition >= 0.0f);
|
|
Verify(targetPosition <= 1.0f);
|
|
|
|
MString string;
|
|
|
|
|
|
page = param_list->FindEntry("EvenAnim");
|
|
Check_Object(page);
|
|
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
evenAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(evenAnimInstance);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
|
|
page = param_list->FindEntry("UpAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
upAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(upAnimInstance);
|
|
|
|
|
|
page = param_list->FindEntry("DownAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
downAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(downAnimInstance);
|
|
|
|
|
|
page = param_list->FindEntry("LeftAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
leftAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(leftAnimInstance);
|
|
|
|
page = param_list->FindEntry("RightAnim");
|
|
Check_Object(page);
|
|
|
|
string = page->GetChar();
|
|
string += ".MW4ANIM";
|
|
|
|
rightAnimInstance = anim_state_engine->LoadOrMakeAnimInstance((const char *)string);
|
|
Check_Object(rightAnimInstance);
|
|
|
|
}
|
|
|
|
|
|
page = param_list->FindEntry("RollAttrib");
|
|
Check_Object(page);
|
|
|
|
rollAttrib = anim_state_engine->vehicleParent->GetAttributeEntry(page->GetChar());
|
|
Check_Object(rollAttrib);
|
|
|
|
page = param_list->FindEntry("PitchAttrib");
|
|
Check_Object(page);
|
|
|
|
pitchAttrib = anim_state_engine->vehicleParent->GetAttributeEntry(page->GetChar());
|
|
Check_Object(pitchAttrib);
|
|
|
|
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
bool FullHeightPoseHolder::Advance(AnimationStateEngine *anim_state_engine, Stuff::Scalar time_slice, bool run_minimal)
|
|
{
|
|
|
|
#ifdef _ARMOR
|
|
Verify(evenAnimIterator != NULL);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
Verify(upAnimIterator != NULL);
|
|
Verify(downAnimIterator != NULL);
|
|
Verify(leftAnimIterator != NULL);
|
|
Verify(rightAnimIterator != NULL);
|
|
}
|
|
#endif
|
|
|
|
// work thru the delay if there is one...
|
|
currentTime += time_slice;
|
|
|
|
if (currentTime >= startDelay)
|
|
{
|
|
AnimHierarchyNode *heir_node = NULL;
|
|
heir_node = anim_state_engine->iteratorManager->PushLayer(1.0f);
|
|
|
|
evenAnimIterator->SetVelocityScale(0.0f);
|
|
if (!run_minimal)
|
|
{
|
|
upAnimIterator->SetVelocityScale(0.0f);
|
|
downAnimIterator->SetVelocityScale(0.0f);
|
|
leftAnimIterator->SetVelocityScale(0.0f);
|
|
rightAnimIterator->SetVelocityScale(0.0f);
|
|
}
|
|
|
|
Stuff::Scalar roll_slope;
|
|
Stuff::Scalar pitch_slope;
|
|
Stuff::Scalar up_blend = 0.0f;
|
|
Stuff::Scalar down_blend = 0.0f;
|
|
Stuff::Scalar even_blend = 0.0f;
|
|
Stuff::Scalar left_blend = 0.0f;
|
|
Stuff::Scalar right_blend = 0.0f;
|
|
|
|
rollAttrib->GetValue(anim_state_engine->vehicleParent, &roll_slope);
|
|
pitchAttrib->GetValue(anim_state_engine->vehicleParent, &pitch_slope);
|
|
|
|
|
|
if(pitch_slope > 0.0f)
|
|
{
|
|
down_blend = 0.0f;
|
|
Max_Clamp(pitch_slope, Pi_Over_4);
|
|
|
|
up_blend = pitch_slope/Pi_Over_4;
|
|
//even_blend = 1.0f - up_blend;
|
|
|
|
|
|
}
|
|
else if(pitch_slope < 0.0f)
|
|
{
|
|
up_blend = 0.0f;
|
|
pitch_slope = -pitch_slope;
|
|
Max_Clamp(pitch_slope, Pi_Over_4);
|
|
|
|
down_blend = pitch_slope/Pi_Over_4;
|
|
//even_blend = 1.0f - down_blend;
|
|
}
|
|
else
|
|
{
|
|
|
|
down_blend = 0.0f;
|
|
up_blend = 0.0f;
|
|
}
|
|
|
|
if(roll_slope > 0.0f)
|
|
{
|
|
right_blend = 0.0f;
|
|
Max_Clamp(roll_slope, Pi_Over_4);
|
|
|
|
left_blend = roll_slope/Pi_Over_4;
|
|
//even_blend = 1.0f - right_blend;
|
|
|
|
|
|
}
|
|
else if(roll_slope < 0.0f)
|
|
{
|
|
left_blend = 0.0f;
|
|
roll_slope = -roll_slope;
|
|
Max_Clamp(roll_slope, Pi_Over_4);
|
|
|
|
right_blend = roll_slope/Pi_Over_4;
|
|
//even_blend = 1.0f - left_blend;
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
right_blend = 0.0f;
|
|
left_blend = 0.0f;
|
|
}
|
|
|
|
|
|
if ((left_blend + right_blend + up_blend + down_blend) < 1.0f)
|
|
{
|
|
even_blend = 1.0f - (left_blend + right_blend + up_blend + down_blend);
|
|
}
|
|
else
|
|
{
|
|
even_blend = 0.015f;
|
|
}
|
|
|
|
|
|
//SPEW(("jerryeds", "%f %f %f %f %f", up_blend, down_blend, even_blend, left_blend, right_blend));
|
|
|
|
evenAnimIterator->SetBlendValue(even_blend);
|
|
if (!run_minimal)
|
|
{
|
|
downAnimIterator->SetBlendValue(down_blend);
|
|
upAnimIterator->SetBlendValue(up_blend);
|
|
leftAnimIterator->SetBlendValue(left_blend);
|
|
rightAnimIterator->SetBlendValue(right_blend);
|
|
}
|
|
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(evenAnimIterator);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(upAnimIterator);
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(downAnimIterator);
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(leftAnimIterator);
|
|
anim_state_engine->iteratorManager->AddAnimToCurrentLayer(rightAnimIterator);
|
|
|
|
}
|
|
anim_state_engine->iteratorManager->PopLayer();
|
|
|
|
if (startDelay == 0.0f)
|
|
{
|
|
carryOver = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
carryOver = currentTime - startDelay;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
|
|
void FullHeightPoseHolder::Que(Stuff::Scalar position, bool run_minimal)
|
|
{
|
|
#ifdef _ARMOR
|
|
Verify(evenAnimIterator != NULL);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
Verify(upAnimIterator != NULL);
|
|
Verify(downAnimIterator != NULL);
|
|
Verify(leftAnimIterator != NULL);
|
|
Verify(rightAnimIterator != NULL);
|
|
}
|
|
#endif
|
|
|
|
|
|
evenAnimIterator->SetPosition(targetPosition);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
upAnimIterator->SetPosition(targetPosition);
|
|
downAnimIterator->SetPosition(targetPosition);
|
|
leftAnimIterator->SetPosition(targetPosition);
|
|
rightAnimIterator->SetPosition(targetPosition);
|
|
}
|
|
|
|
|
|
currentTime = 0.0f;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void FullHeightPoseHolder::LoadIterators(bool run_minimal)
|
|
{
|
|
|
|
Verify(evenAnimIterator == NULL);
|
|
evenAnimIterator = new MW4Animation::AnimIterator(evenAnimInstance);
|
|
Register_Pointer(evenAnimIterator);
|
|
|
|
if (!run_minimal)
|
|
{
|
|
Verify(upAnimIterator == NULL);
|
|
upAnimIterator = new MW4Animation::AnimIterator(upAnimInstance);
|
|
Register_Pointer(upAnimIterator);
|
|
|
|
Verify(downAnimIterator == NULL);
|
|
downAnimIterator = new MW4Animation::AnimIterator(downAnimInstance);
|
|
Register_Pointer(downAnimIterator);
|
|
|
|
Verify(leftAnimIterator == NULL);
|
|
leftAnimIterator = new MW4Animation::AnimIterator(leftAnimInstance);
|
|
Register_Pointer(leftAnimIterator);
|
|
|
|
Verify(rightAnimIterator == NULL);
|
|
rightAnimIterator = new MW4Animation::AnimIterator(rightAnimInstance);
|
|
Register_Pointer(rightAnimIterator);
|
|
}
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
void FullHeightPoseHolder::UnloadIterators(void)
|
|
{
|
|
Verify(evenAnimIterator != NULL);
|
|
Unregister_Pointer(evenAnimIterator);
|
|
delete evenAnimIterator;
|
|
evenAnimIterator = NULL;
|
|
|
|
if (upAnimIterator != NULL)
|
|
{
|
|
Unregister_Pointer(upAnimIterator);
|
|
delete upAnimIterator;
|
|
upAnimIterator = NULL;
|
|
|
|
Verify(downAnimIterator != NULL);
|
|
Unregister_Pointer(downAnimIterator);
|
|
delete downAnimIterator;
|
|
downAnimIterator = NULL;
|
|
|
|
Verify(leftAnimIterator != NULL);
|
|
Unregister_Pointer(leftAnimIterator);
|
|
delete leftAnimIterator;
|
|
leftAnimIterator = NULL;
|
|
|
|
Verify(rightAnimIterator != NULL);
|
|
Unregister_Pointer(rightAnimIterator);
|
|
delete rightAnimIterator;
|
|
rightAnimIterator = NULL;
|
|
}
|
|
|
|
currentTime = -1.0f;
|
|
}
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
|
|
Stuff::Scalar FullHeightPoseHolder::GetCurrentPercentage()
|
|
{
|
|
Verify(evenAnimInstance != NULL);
|
|
|
|
if (startDelay == 0.0f)
|
|
{
|
|
return startPercentage;
|
|
}
|
|
|
|
Scalar percent = currentTime / startDelay;
|
|
|
|
percent *= percentageOfChain;
|
|
percent += startPercentage;
|
|
|
|
Verify(percent <= 1.0f);
|
|
Verify(percent >= 0.0f);
|
|
|
|
return percent;
|
|
|
|
}
|
|
|
|
|
|
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
//
|
|
|
|
|
|
Stuff::Scalar FullHeightPoseHolder::GetTimeTotal()
|
|
{
|
|
//Verify(animInstance != NULL);
|
|
return
|
|
0.0f + startDelay;
|
|
}
|
|
|
|
|