void FCDocument::SetCurrentTime(float time)
{
for (FCDAnimatedSet::iterator itA = animatedValues.begin(); itA != animatedValues.end(); ++itA)
{
FCDAnimated* animated = (*itA).first;
animated->Evaluate(time);
}
// We must evaluate all our child documents as well!
for (size_t i = 0; i < externalReferenceManager->GetPlaceHolderCount(); i++)
{
FCDPlaceHolder* placeHolder = externalReferenceManager->GetPlaceHolder(i);
if (placeHolder->IsTargetLoaded()) placeHolder->GetTarget()->SetCurrentTime(time);
}
}
void FCDParameterListAnimatableT<TYPE, QUALIFIERS>::OnPotentialSizeChange()
{
size_t animatedCount = animateds.size();
if (animatedCount == 0) return;
// Check if the first FCDAnimated points to the correct values.
// If it does, then they all should be fine.
FCDAnimated* animated = animateds.front();
FUAssert((size_t) animated->GetArrayElement() < values.size(), return);
if (animated->GetValue(0) == (void*) &values[animated->GetArrayElement()]) return;
// Process all the animateds and set their value pointers.
// IMPORTANT: it is assumed that these values are FLOATS and ORDERED.
size_t stride = animated->GetValueCount();
for (size_t i = 0; i < animatedCount; ++i)
{
animated = animateds[i];
size_t arrayElement = animated->GetArrayElement();
FUAssert(arrayElement < values.size(), return);
for (size_t j = 0; j < stride; ++j)
{
animated->SetValue(j, (float*) (j * sizeof(float) + ((char*) &values[arrayElement])));
}
}
}
void GenerateSampledAnimation(FCDSceneNode* node)
{
sampleKeys.clear();
sampleValues.clear();
FCDAnimatedList animateds;
// Special case for rotation angles: need to check for changes that are greater than 180 degrees.
Int32List angleIndices;
// Collect all the animation curves
size_t transformCount = node->GetTransformCount();
for (size_t t = 0; t < transformCount; ++t)
{
FCDTransform* transform = node->GetTransform(t);
FCDAnimated* animated = transform->GetAnimated();
if (animated != NULL)
{
if (animated->HasCurve()) animateds.push_back(animated);
// Figure out whether this is a rotation and then, which animated value contains the angle.
if (!transform->HasType(FCDTRotation::GetClassType())) angleIndices.push_back(-1);
else angleIndices.push_back((int32) animated->FindQualifier(".ANGLE"));
}
}
if (animateds.empty()) return;
// Make a list of the ordered key times to sample
size_t animatedsCount = animateds.size();
for (size_t i = 0; i < animatedsCount; ++i)
{
FCDAnimated* animated = animateds[i];
int32 angleIndex = angleIndices[i];
const FCDAnimationCurveListList& allCurves = animated->GetCurves();
size_t valueCount = allCurves.size();
for (size_t curveIndex = 0; curveIndex < valueCount; ++curveIndex)
{
const FCDAnimationCurveTrackList& curves = allCurves[curveIndex];
if (curves.empty()) continue;
size_t curveKeyCount = curves.front()->GetKeyCount();
const FCDAnimationKey** curveKeys = curves.front()->GetKeys();
size_t sampleKeyCount = sampleKeys.size();
// Merge this curve's keys in with the sample keys
// This assumes both key lists are in increasing order
size_t s = 0, c = 0;
while (s < sampleKeyCount && c < curveKeyCount)
{
float sampleKey = sampleKeys[s], curveKey = curveKeys[c]->input;
if (IsEquivalent(sampleKey, curveKey)) { ++s; ++c; }
else if (sampleKey < curveKey) { ++s; }
else
{
// Add this curve key to the sampling key list
sampleKeys.insert(sampleKeys.begin() + (s++), curveKeys[c++]->input);
sampleKeyCount++;
}
}
// Add all the left-over curve keys to the sampling key list
while (c < curveKeyCount) sampleKeys.push_back(curveKeys[c++]->input);
// Check for large angular rotations..
if (angleIndex == (intptr_t) curveIndex)
{
for (size_t c = 1; c < curveKeyCount; ++c)
{
const FCDAnimationKey* previousKey = curveKeys[c - 1];
const FCDAnimationKey* currentKey = curveKeys[c];
float halfWrapAmount = (currentKey->output - previousKey->output) / 180.0f;
halfWrapAmount *= FMath::Sign(halfWrapAmount);
if (halfWrapAmount >= 1.0f)
{
// Need to add sample times.
size_t addSampleCount = (size_t) floorf(halfWrapAmount);
for (size_t d = 1; d <= addSampleCount; ++d)
{
float fd = (float) d;
float fid = (float) (addSampleCount + 1 - d);
float addSampleTime = (currentKey->input * fd + previousKey->input * fid) / (fd + fid);
// Sorted insert.
float* endIt = sampleKeys.end();
for (float* sampleKeyTime = sampleKeys.begin(); sampleKeyTime != endIt; ++sampleKeyTime)
{
if (IsEquivalent(*sampleKeyTime, addSampleTime)) break;
else if (*sampleKeyTime > addSampleTime)
{
sampleKeys.insert(sampleKeyTime, addSampleTime);
break;
}
}
}
}
}
}
}
}
size_t sampleKeyCount = sampleKeys.size();
if (sampleKeyCount == 0) return;
// Pre-allocate the value array;
sampleValues.reserve(sampleKeyCount);
// Sample the scene node transform
for (size_t i = 0; i < sampleKeyCount; ++i)
{
float sampleTime = sampleKeys[i];
for (FCDAnimatedList::iterator it = animateds.begin(); it != animateds.end(); ++it)
{
// Sample each animated, which changes the transform values directly
(*it)->Evaluate(sampleTime);
}
// Retrieve the new transform matrix for the COLLADA scene node
sampleValues.push_back(node->ToMatrix());
}
}
FMMatrix44 ColladaSceneNode::CalculateTransformForTime(FCDSceneNode * originalNode, float32 time)
{
FMMatrix44 colladaLocalMatrix;
colladaLocalMatrix = FMMatrix44::Identity;// = FMMatrix44::Identity();
for (int t = 0; t < (int)originalNode->GetTransformCount(); ++t)
{
FCDTransform * transform = originalNode->GetTransform(t);
if (transform->IsAnimated()) // process all animations to make CalculateWorldTransform work
{
FCDAnimated * animated = transform->GetAnimated();
animated->Evaluate(time);
}
if (transform->GetType() == FCDTransform::TRANSLATION)
{
FCDTTranslation * translation = dynamic_cast<FCDTTranslation*>(transform);
FMVector3 point = FMVector3(0.0f, 0.0f, 0.0f);
point = translation->GetTranslation();
if (transform->IsAnimated())
{
FCDAnimationCurve* curve;
// look for x animation
curve = transform->GetAnimated()->FindCurve(".X");
if (curve != 0)
point.x = curve->Evaluate(time);
// look for y animation
curve = transform->GetAnimated()->FindCurve(".Y");
if (curve != 0)
point.y = curve->Evaluate(time);
// look for z animation
curve = transform->GetAnimated()->FindCurve(".Z");
if (curve != 0)
point.z = curve->Evaluate(time);
}
colladaLocalMatrix = colladaLocalMatrix * FMMatrix44::TranslationMatrix(point);
}else if (transform->GetType() == FCDTransform::ROTATION)
{
FCDTRotation * rotation = dynamic_cast<FCDTRotation*>(transform);
FMVector3 axis = FMVector3(0.0f, 0.0f, 0.0f);
float angle = 0;
axis = rotation->GetAxis();
angle = rotation->GetAngle();
if (rotation->IsAnimated())
{
FCDAnimationCurve* curve;
// look for x animation
curve = rotation->GetAnimated()->FindCurve(".X");
if (curve != 0)
axis.x = curve->Evaluate(time);
// look for y animation
curve = rotation->GetAnimated()->FindCurve(".Y");
if (curve != 0)
axis.y = curve->Evaluate(time);
// look for z animation
curve = rotation->GetAnimated()->FindCurve(".Z");
if (curve != 0)
axis.z = curve->Evaluate(time);
// look for z animation
curve = rotation->GetAnimated()->FindCurve(".ANGLE");
if (curve != 0)
angle = curve->Evaluate(time);
}
colladaLocalMatrix = colladaLocalMatrix * FMMatrix44::AxisRotationMatrix(axis, angle * PI / 180.0f);
}else
{
colladaLocalMatrix = colladaLocalMatrix * transform->ToMatrix();
}
}
return colladaLocalMatrix;
}