//---------------------------------------------------------------------
size_t SkeletonSerializer::calcAnimationSize(const Skeleton* pSkel, const Animation* pAnim, SkeletonVersion ver)
{
size_t size = SSTREAM_OVERHEAD_SIZE;
// Name, including terminator
size += calcStringSize(pAnim->getName());
// length
size += sizeof(float);
if ((int)ver > (int)SKELETON_VERSION_1_0)
{
if (pAnim->getUseBaseKeyFrame())
{
size += SSTREAM_OVERHEAD_SIZE;
// char* baseAnimationName (including terminator)
size += calcStringSize(pAnim->getBaseKeyFrameAnimationName());
// float baseKeyFrameTime
size += sizeof(float);
}
}
// Nested animation tracks
Animation::NodeTrackIterator trackIt = pAnim->getNodeTrackIterator();
while(trackIt.hasMoreElements())
{
size += calcAnimationTrackSize(pSkel, trackIt.getNext());
}
return size;
}
//---------------------------------------------------------------------
void XMLSkeletonSerializer::writeAnimation(TiXmlElement* animsNode,
const Animation* anim)
{
TiXmlElement* animNode =
animsNode->InsertEndChild(TiXmlElement("animation"))->ToElement();
animNode->SetAttribute("name", anim->getName());
animNode->SetAttribute("length", StringConverter::toString(anim->getLength()));
// Optional base keyframe information
if (anim->getUseBaseKeyFrame())
{
TiXmlElement* baseInfoNode =
animNode->InsertEndChild(TiXmlElement("baseinfo"))->ToElement();
baseInfoNode->SetAttribute("baseanimationname", anim->getBaseKeyFrameAnimationName());
baseInfoNode->SetAttribute("basekeyframetime", StringConverter::toString(anim->getBaseKeyFrameTime()));
}
// Write all tracks
TiXmlElement* tracksNode =
animNode->InsertEndChild(TiXmlElement("tracks"))->ToElement();
Animation::NodeTrackIterator trackIt = anim->getNodeTrackIterator();
while (trackIt.hasMoreElements())
{
writeAnimationTrack(tracksNode, trackIt.getNext());
}
}
//---------------------------------------------------------------------
size_t SkeletonSerializer::calcAnimationSize(const Skeleton* pSkel,
const Animation* pAnim)
{
size_t size = STREAM_OVERHEAD_SIZE;
// Name, including terminator
size += pAnim->getName().length() + 1;
// length
size += sizeof(float);
// Nested animation tracks
Animation::NodeTrackIterator trackIt = pAnim->getNodeTrackIterator();
while(trackIt.hasMoreElements())
{
size += calcAnimationTrackSize(pSkel, trackIt.getNext());
}
return size;
}
//---------------------------------------------------------------------
void SkeletonSerializer::writeAnimation(const Skeleton* pSkel,
const Animation* anim)
{
writeChunkHeader(SKELETON_ANIMATION, calcAnimationSize(pSkel, anim));
// char* name : Name of the animation
writeString(anim->getName());
// float length : Length of the animation in seconds
float len = anim->getLength();
writeFloats(&len, 1);
// Write all tracks
Animation::NodeTrackIterator trackIt = anim->getNodeTrackIterator();
while(trackIt.hasMoreElements())
{
writeAnimationTrack(pSkel, trackIt.getNext());
}
}
//---------------------------------------------------------------------
void SkeletonSerializer::writeAnimation(const Skeleton* pSkel,
const Animation* anim, SkeletonVersion ver)
{
writeChunkHeader(SKELETON_ANIMATION, calcAnimationSize(pSkel, anim, ver));
// char* name : Name of the animation
writeString(anim->getName());
// float length : Length of the animation in seconds
float len = anim->getLength();
writeFloats(&len, 1);
pushInnerChunk(mStream);
{
if ((int)ver > (int)SKELETON_VERSION_1_0)
{
if (anim->getUseBaseKeyFrame())
{
size_t size = SSTREAM_OVERHEAD_SIZE;
// char* baseAnimationName (including terminator)
size += calcStringSize(anim->getBaseKeyFrameAnimationName());
// float baseKeyFrameTime
size += sizeof(float);
writeChunkHeader(SKELETON_ANIMATION_BASEINFO, size);
// char* baseAnimationName (blank for self)
writeString(anim->getBaseKeyFrameAnimationName());
// float baseKeyFrameTime
float t = (float)anim->getBaseKeyFrameTime();
writeFloats(&t, 1);
}
}
// Write all tracks
Animation::NodeTrackIterator trackIt = anim->getNodeTrackIterator();
while(trackIt.hasMoreElements())
{
writeAnimationTrack(pSkel, trackIt.getNext());
}
}
popInnerChunk(mStream);
}
//---------------------------------------------------------------------
void XMLSkeletonSerializer::writeAnimation(TiXmlElement* animsNode,
const Animation* anim)
{
TiXmlElement* animNode =
animsNode->InsertEndChild(TiXmlElement("animation"))->ToElement();
animNode->SetAttribute("name", anim->getName());
animNode->SetAttribute("length", StringConverter::toString(anim->getLength()));
// Write all tracks
TiXmlElement* tracksNode =
animNode->InsertEndChild(TiXmlElement("tracks"))->ToElement();
Animation::NodeTrackIterator trackIt = anim->getNodeTrackIterator();
while (trackIt.hasMoreElements())
{
writeAnimationTrack(tracksNode, trackIt.getNext());
}
}
void OgreSample19App::tweakSneakAnim()
{
SkeletonPtr skel = SkeletonManager::getSingleton().load("jaiqua.skeleton",ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
Animation * anim = skel->getAnimation("Sneak");
Animation::NodeTrackIterator tracks = anim->getNodeTrackIterator();
while(tracks.hasMoreElements())
{
NodeAnimationTrack * track = tracks.getNext();
TransformKeyFrame oldKf(0,0);
track->getInterpolatedKeyFrame(ANIM_CHOP,&oldKf);
while (track->getKeyFrame(track->getNumKeyFrames()-1)->getTime() >= ANIM_CHOP - 0.3f)
{
track->removeKeyFrame(track->getNumKeyFrames()-1);
}
TransformKeyFrame * newKf = track->createNodeKeyFrame(ANIM_CHOP);
TransformKeyFrame * startKf = track->getNodeKeyFrame(0);
Bone * bone = skel->getBone(track->getHandle());
if (bone->getName() == "Spineroot")
{
mSneakStartPos = startKf->getTranslate() + bone->getInitialPosition();
mSneakEndPos = oldKf.getTranslate() + bone->getInitialPosition();
mSneakStartPos.y = mSneakEndPos.y;
newKf->setTranslate(oldKf.getTranslate());
newKf->setRotation(oldKf.getRotation());
newKf->setScale(oldKf.getScale());
}
else
{
newKf->setTranslate(startKf->getTranslate());
newKf->setRotation(startKf->getRotation());
newKf->setScale(startKf->getScale());
}
}
}
void ModelConverter::ExportSkeleton( const Ogre::Skeleton* pSkeleton, const Ogre::String& filename )
{
LogManager::getSingleton().logMessage("Populating DOM...");
// Write main skeleton data
LogManager::getSingleton().logMessage("Exporting bones..");
DiMotionPtr mt = Demi::DiAssetManager::GetInstancePtr(
)->CreateOrReplaceAsset<DiMotion>(pSkeleton->getName().c_str());
DiSkeleton* skeleton = mt->CreateSkeleton();
// save bones
WriteSkeleton(pSkeleton,skeleton);
LogManager::getSingleton().logMessage("Bones exported.");
unsigned short numAnims = pSkeleton->getNumAnimations();
String msg = "Exporting animations, count=" + StringConverter::toString(numAnims);
LogManager::getSingleton().logMessage(msg);
// save animations
for (unsigned short i = 0; i < numAnims; ++i)
{
Animation* pAnim = pSkeleton->getAnimation(i);
msg = "Exporting animation: " + pAnim->getName();
LogManager::getSingleton().logMessage(msg);
Demi::DiAnimation* anim = mt->CreateAnimation(
pAnim->getName().c_str(), pAnim->getLength());
// save tracks
Animation::NodeTrackIterator trackIt = pAnim->getNodeTrackIterator();
size_t count = 0;
while (trackIt.hasMoreElements())
{
NodeAnimationTrack* track = trackIt.getNext();
Bone* bone = (Bone*)track->getAssociatedNode();
Demi::DiNodeClip* clip = anim->CreateNodeClip(count++,skeleton->GetBone(bone->getHandle()));
// save key frames
for (unsigned short i = 0; i < track->getNumKeyFrames(); ++i)
{
TransformKeyFrame* kf = track->getNodeKeyFrame(i);
Demi::DiTransformKeyFrame* pKeyframe = clip->CreateNodeKeyFrame(kf->getTime());
pKeyframe->SetTranslate(Demi::DiVec3(kf->getTranslate().x,
kf->getTranslate().y,kf->getTranslate().z));
pKeyframe->SetRotation(Demi::DiQuat(kf->getRotation().w,
kf->getRotation().x,kf->getRotation().y,kf->getRotation().z));
pKeyframe->SetScale(Demi::DiVec3(kf->getScale().x,
kf->getScale().y,kf->getScale().z));
}
}
LogManager::getSingleton().logMessage("Animation exported.");
}
if (mt)
{
// save to file
DiMotionSerializer ms;
ms.ExportMotion(mt,filename);
}
}
