void MilkshapePlugin::doExportAnimations(msModel* pModel, Ogre::SkeletonPtr& ogreskel)
{
Ogre::LogManager& logMgr = Ogre::LogManager::getSingleton();
std::vector<SplitAnimationStruct> splitInfo;
Ogre::String msg;
int numFrames = msModel_GetTotalFrames(pModel);
msg = "Number of frames: " + Ogre::StringConverter::toString(numFrames);
logMgr.logMessage(msg);
if (splitAnimations)
{
// Explain
msg = "You have chosen to create multiple discrete animations by splitting up the frames in "
"the animation sequence. In order to do this, you must supply a simple text file "
"describing the separate animations, which has a single line per animation in the format: \n\n"
"startFrame,endFrame,animationName\n\nFor example: \n\n"
"1,20,Walk\n21,35,Run\n36,40,Shoot\n\n"
"..creates 3 separate animations (the frame numbers are inclusive)."
"You must browse to this file in the next dialog.";
MessageBox(0,msg.c_str(), "Splitting Animations",MB_ICONINFORMATION | MB_OK);
// Prompt for a file which contains animation splitting info
OPENFILENAME ofn;
memset (&ofn, 0, sizeof (OPENFILENAME));
char szFile[MS_MAX_PATH];
char szFileTitle[MS_MAX_PATH];
char szDefExt[32] = "skeleton";
char szFilter[128] = "All Files (*.*)\0*.*\0\0";
szFile[0] = '\0';
szFileTitle[0] = '\0';
ofn.lStructSize = sizeof (OPENFILENAME);
ofn.lpstrDefExt = szDefExt;
ofn.lpstrFilter = szFilter;
ofn.lpstrFile = szFile;
ofn.nMaxFile = MS_MAX_PATH;
ofn.lpstrFileTitle = szFileTitle;
ofn.nMaxFileTitle = MS_MAX_PATH;
ofn.Flags = OFN_HIDEREADONLY | OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
ofn.lpstrTitle = "Open animation split configuration file";
if (!::GetOpenFileName (&ofn))
{
msg = "Splitting aborted, generating a single animation called 'Default'";
MessageBox(0, msg.c_str(), "Info", MB_OK | MB_ICONWARNING);
SplitAnimationStruct split;
split.start = 1;
split.end = numFrames;
split.name = "Default";
splitInfo.push_back(split);
}
else
{
// Read file
Ogre::String sline;
char line[256];
SplitAnimationStruct newSplit;
std::ifstream istr;
istr.open(szFile);
while (!istr.eof())
{
istr.getline(line, 256);
sline = line;
// Ignore blanks & comments
if (sline == "" || sline.substr(0,2) == "//")
continue;
// Split on ','
std::vector<Ogre::String> svec = Ogre::StringUtil::split(line, ",\n");
// Basic validation on number of elements
if (svec.size() != 3)
{
MessageBox(0, "Warning: corrupt animation details in file. You should look into this. ",
"Corrupt animations file", MB_ICONWARNING | MB_OK);
continue;
}
// Remove any embedded spaces
Ogre::StringUtil::trim(svec[0]);
Ogre::StringUtil::trim(svec[1]);
Ogre::StringUtil::trim(svec[2]);
// Create split info
newSplit.start = atoi(svec[0].c_str());
newSplit.end = atoi(svec[1].c_str());
newSplit.name = svec[2];
splitInfo.push_back(newSplit);
}
}
}
else
{
// No splitting
SplitAnimationStruct split;
split.start = 1;
split.end = numFrames;
split.name = "Default";
splitInfo.push_back(split);
}
// Get animation length
// Map frames -> seconds, this can be changed in speed of animation anyway
int numBones = msModel_GetBoneCount(pModel);
unsigned int frameTime;
float realTime;
std::vector<SplitAnimationStruct>::iterator animsIt;
for (animsIt = splitInfo.begin(); animsIt != splitInfo.end(); ++animsIt)
{
SplitAnimationStruct& currSplit = *animsIt;
// Create animation
frameTime = currSplit.end - currSplit.start;
realTime = frameTime / fps;
Ogre::LogManager::getSingleton().stream()
<< "Trying to create Animation object for animation "
<< currSplit.name << " For Frames " << currSplit.start << " to "
<< currSplit.end << " inclusive. ";
Ogre::LogManager::getSingleton().stream()
<< "Frame time = "
<< frameTime << ", Seconds = " << realTime;
Ogre::Animation *ogreanim =
ogreskel->createAnimation(currSplit.name, realTime);
logMgr.logMessage("Animation object created.");
int i;
// Create all the animation tracks
for (i = 0; i < numBones; ++i)
{
msBone* bone = msModel_GetBoneAt(pModel, i);
Ogre::Bone* ogrebone = ogreskel->getBone(bone->szName);
// Create animation tracks
msg = "Creating AnimationTrack for bone " + Ogre::StringConverter::toString(i);
logMgr.logMessage(msg);
Ogre::NodeAnimationTrack *ogretrack = ogreanim->createNodeTrack(i, ogrebone);
logMgr.logMessage("Animation track created.");
// OGRE uses keyframes which are both position and rotation
// Milkshape separates them, but never seems to use the ability to
// have a different # of pos & rot keys
int numKeys = msBone_GetRotationKeyCount(bone);
msg = "Number of keyframes: " + Ogre::StringConverter::toString(numKeys);
logMgr.logMessage(msg);
int currKeyIdx;
msPositionKey* currPosKey;
msRotationKey* currRotKey;
for (currKeyIdx = 0; currKeyIdx < numKeys; ++currKeyIdx )
{
currPosKey = msBone_GetPositionKeyAt(bone, currKeyIdx);
currRotKey = msBone_GetRotationKeyAt(bone, currKeyIdx);
// Make sure keyframe is in current time frame (for splitting)
if (currRotKey->fTime >= currSplit.start && currRotKey->fTime <= currSplit.end)
{
msg = "Creating KeyFrame #" + Ogre::StringConverter::toString(currKeyIdx)
+ " for bone #" + Ogre::StringConverter::toString(i);
logMgr.logMessage(msg);
// Create keyframe
// Adjust for start time, and for the fact that frames are numbered from 1
frameTime = currRotKey->fTime - currSplit.start;
realTime = frameTime / fps;
Ogre::TransformKeyFrame *ogrekey = ogretrack->createNodeKeyFrame(realTime);
logMgr.logMessage("KeyFrame created");
Ogre::Vector3 kfPos;
// Imported milkshape animations may not have positions
// for all rotation keys
if ( currKeyIdx < bone->nNumPositionKeys ) {
kfPos.x = currPosKey->Position[0];
kfPos.y = currPosKey->Position[1];
kfPos.z = currPosKey->Position[2];
}
else {
kfPos.x = bone->Position[0];
kfPos.y = bone->Position[1];
kfPos.z = bone->Position[2];
}
Ogre::Quaternion qx, qy, qz, kfQ;
// Milkshape translations are local to own orientation, not parent
kfPos = ogrebone->getOrientation() * kfPos;
ogrekey->setTranslate(kfPos);
qx.FromAngleAxis(Ogre::Radian(currRotKey->Rotation[0]), Ogre::Vector3::UNIT_X);
qy.FromAngleAxis(Ogre::Radian(currRotKey->Rotation[1]), Ogre::Vector3::UNIT_Y);
qz.FromAngleAxis(Ogre::Radian(currRotKey->Rotation[2]), Ogre::Vector3::UNIT_Z);
kfQ = qz * qy * qx;
ogrekey->setRotation(kfQ);
Ogre::LogManager::getSingleton().stream()
<< "KeyFrame details: Adjusted Frame Time=" << frameTime
<< " Seconds: " << realTime << " Position=" << kfPos << " "
<< "Ms3d Rotation= {" << currRotKey->Rotation[0] << ", "
<< currRotKey->Rotation[1] << ", " << currRotKey->Rotation[2]
<< "} " << "Orientation=" << kfQ;
} // keyframe creation
} // keys
} //Bones
} // Animations
}
CalQuaternion CMilkBoneNode::GetRelativeRotation(float time)
{
// get the initial rotation component
msVec3 orientation;
msBone_GetRotation(m_pIBone, orientation);
// calculate the initial rotation component
CalQuaternion initialRotation;
initialRotation = ConvertToQuaternion(orientation);
// return if the initial state is requested or if there are no keyframes
if((time < 0.0f) || (msBone_GetRotationKeyCount(m_pIBone) == 0)) return initialRotation;
// calculate the real frame time
// REMEMBER: milkshape starts at 1.0!
float frameTime;
frameTime = 1.0f + time * (float)theExporter.GetInterface()->GetFps();
// find the keyframe just before the requested time
msRotationKey *pKeyBefore;
pKeyBefore = msBone_GetRotationKeyAt(m_pIBone, msBone_GetRotationKeyCount(m_pIBone) - 1);
int keyId;
for(keyId = 0; keyId < msBone_GetRotationKeyCount(m_pIBone); keyId++)
{
// get the keyframe
msRotationKey *pKey;
pKey = msBone_GetRotationKeyAt(m_pIBone, keyId);
// stop if we are over the requested time
if(pKey->fTime > frameTime) break;
pKeyBefore = pKey;
}
// get the keyframe just after the requested time
msRotationKey *pKeyAfter;
pKeyAfter = msBone_GetRotationKeyAt(m_pIBone, 0);
if(keyId < msBone_GetRotationKeyCount(m_pIBone))
{
pKeyAfter = msBone_GetRotationKeyAt(m_pIBone, keyId);
}
// calculate the "just before" rotation component
CalQuaternion rotationBefore;
if(pKeyBefore != 0)
{
rotationBefore = ConvertToQuaternion(pKeyBefore->Rotation);
// return if there is no key after this one
if(pKeyAfter == 0) return initialRotation * rotationBefore;
}
// calculate the "just after" rotation component
CalQuaternion rotationAfter;
if(pKeyAfter != 0)
{
rotationAfter = ConvertToQuaternion(pKeyAfter->Rotation);
// return if there is no key before this one
if(pKeyBefore == 0) return initialRotation * rotationAfter;
}
// return if both keys are actually the same
if(pKeyBefore == pKeyAfter) return initialRotation * rotationAfter;
// calculate the blending factor
float factor;
factor = (frameTime - pKeyBefore->fTime) / (pKeyAfter->fTime - pKeyBefore->fTime);
// blend the two rotation components
rotationBefore.blend(factor, rotationAfter);
return initialRotation * rotationBefore;
}
