TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-02-13 03:33:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

animation update

Browse source 
updated how animations are handled from assimp
gltf timing now correct
This commit is contained in:
marauder2k7 2024-12-10 11:54:13 +00:00
parent 5f1c2a63e5
commit 28fcb8d68b
6 changed files with 161 additions and 160 deletions
Download patch file Download diff file Expand all files Collapse all files

113
Engine/source/ts/assimp/assimpAppSequence.cpp
View file

@ -12,94 +12,103 @@
#include "ts/assimp/assimpAppSequence.h"
#include "ts/assimp/assimpAppNode.h"
AssimpAppSequence::AssimpAppSequence(aiAnimation *a) :
seqStart(0.0f),
seqEnd(0.0f)
AssimpAppSequence::AssimpAppSequence(aiAnimation* a)
: seqStart(0.0f), seqEnd(0.0f), mTimeMultiplier(1.0f)
{
fps = 30.0f;
// Deep copy animation structure
mAnim = new aiAnimation(*a);
// Deep copy channels
mAnim->mChannels = new aiNodeAnim * [a->mNumChannels];
for (U32 i = 0; i < a->mNumChannels; ++i) {
mAnim->mChannels[i] = new aiNodeAnim(*a->mChannels[i]);
}
// Deep copy meshes
mAnim->mMeshChannels = new aiMeshAnim * [a->mNumMeshChannels];
for (U32 i = 0; i < a->mNumMeshChannels; ++i) {
mAnim->mMeshChannels[i] = new aiMeshAnim(*a->mMeshChannels[i]);
}
// Deep copy name
mAnim->mName = a->mName;
mSequenceName = mAnim->mName.C_Str();
if (mSequenceName.isEmpty())
mSequenceName = "ambient";
Con::printf("\n[Assimp] Adding %s animation", mSequenceName.c_str());
fps = (a->mTicksPerSecond > 0) ? a->mTicksPerSecond : 30.0f;
Con::printf("\n[Assimp] Adding animation: %s", mSequenceName.c_str());
if (a->mDuration > 0)
{
// torques seqEnd is in seconds, this then gets generated into frames in generateSequences()
seqEnd = (F32)a->mDuration / fps;
}
else
{
for (U32 i = 0; i < a->mNumChannels; ++i)
{
aiNodeAnim* nodeAnim = a->mChannels[i];
// Determine the maximum keyframe time for this animation
F32 maxKeyTime = 0.0f;
for (U32 k = 0; k < nodeAnim->mNumPositionKeys; k++) {
maxKeyTime = getMax(maxKeyTime, (F32)nodeAnim->mPositionKeys[k].mTime);
}
for (U32 k = 0; k < nodeAnim->mNumRotationKeys; k++) {
maxKeyTime = getMax(maxKeyTime, (F32)nodeAnim->mRotationKeys[k].mTime);
}
for (U32 k = 0; k < nodeAnim->mNumScalingKeys; k++) {
maxKeyTime = getMax(maxKeyTime, (F32)nodeAnim->mScalingKeys[k].mTime);
}
seqEnd = getMax(seqEnd, maxKeyTime);
}
}
mTimeMultiplier = 1.0f;
S32 timeFactor = ColladaUtils::getOptions().animTiming;
S32 fpsRequest = (S32)a->mTicksPerSecond;
if (timeFactor == 0)
{ // Timing specified in frames
fps = mClamp(fpsRequest, 5 /*TSShapeLoader::MinFrameRate*/, TSShapeLoader::MaxFrameRate);
mTimeMultiplier = 1.0f / fps;
}
else
{ // Timing specified in seconds or ms depending on format
if (seqEnd > 1000.0f || a->mDuration > 1000.0f)
timeFactor = 1000.0f; // If it's more than 1000 seconds, assume it's ms.
timeFactor = mClamp(timeFactor, 1, 1000);
mTimeMultiplier = 1.0f / timeFactor;
}
// Determine the FPS and Time Multiplier
determineTimeMultiplier(a);
// Calculate sequence end time based on keyframes and multiplier
calculateSequenceEnd(a);
}
AssimpAppSequence::~AssimpAppSequence()
{
}
void AssimpAppSequence::determineTimeMultiplier(aiAnimation* a)
{
// Set fps from the file or use default
fps = (a->mTicksPerSecond > 0) ? a->mTicksPerSecond : 30.0f;
if (fps >= 1000.0f) { // Indicates milliseconds (GLTF or similar formats)
mTimeMultiplier = 1.0f / 1000.0f; // Convert milliseconds to seconds
Con::printf("[Assimp] Detected milliseconds timing (FPS >= 1000). Time Multiplier: %f", mTimeMultiplier);
}
else if (fps > 0.0f) { // Standard FPS
fps = mClamp(fps, 5 /*TSShapeLoader::MinFrameRate*/, TSShapeLoader::MaxFrameRate);
mTimeMultiplier = 1.0f / fps;
Con::printf("[Assimp] Standard FPS detected. Time Multiplier: %f", mTimeMultiplier);
}
else {
// Fall back to 30 FPS as default
mTimeMultiplier = 1.0f / 30.0f;
Con::printf("[Assimp] FPS not specified. Using default 30 FPS. Time Multiplier: %f", mTimeMultiplier);
}
}
void AssimpAppSequence::calculateSequenceEnd(aiAnimation* a)
{
for (U32 i = 0; i < a->mNumChannels; ++i) {
aiNodeAnim* nodeAnim = a->mChannels[i];
F32 maxKeyTime = 0.0f;
// Calculate the maximum time across all keyframes for this channel
for (U32 k = 0; k < nodeAnim->mNumPositionKeys; ++k) {
maxKeyTime = getMax(maxKeyTime, (F32)nodeAnim->mPositionKeys[k].mTime);
}
for (U32 k = 0; k < nodeAnim->mNumRotationKeys; ++k) {
maxKeyTime = getMax(maxKeyTime, (F32)nodeAnim->mRotationKeys[k].mTime);
}
for (U32 k = 0; k < nodeAnim->mNumScalingKeys; ++k) {
maxKeyTime = getMax(maxKeyTime, (F32)nodeAnim->mScalingKeys[k].mTime);
}
// Use the multiplier to convert to real sequence time
seqEnd = mTimeMultiplier * getMax(seqEnd, maxKeyTime);
}
Con::printf("[Assimp] Sequence End Time: %f seconds", seqEnd);
}
void AssimpAppSequence::setActive(bool active)
{
if (active)
{
AssimpAppNode::sActiveSequence = mAnim;
AssimpAppNode::sTimeMultiplier = mTimeMultiplier;
Con::printf("[Assimp] Activating sequence: %s with Time Multiplier: %f", mSequenceName.c_str(), mTimeMultiplier);
}
else
{
if (AssimpAppNode::sActiveSequence == mAnim)
{
AssimpAppNode::sActiveSequence = NULL;
Con::printf("[Assimp] Deactivating sequence: %s", mSequenceName.c_str());
}
}
}