Error Skeleton::load(const ResourceFilename& filename)
{
XmlDocument doc;
ANKI_CHECK(openFileParseXml(filename, doc));
XmlElement rootEl;
ANKI_CHECK(doc.getChildElement("skeleton", rootEl));
XmlElement bonesEl;
ANKI_CHECK(rootEl.getChildElement("bones", bonesEl));
// count the bones count
XmlElement boneEl;
U32 bonesCount = 0;
ANKI_CHECK(bonesEl.getChildElement("bone", boneEl));
ANKI_CHECK(boneEl.getSiblingElementsCount(bonesCount));
++bonesCount;
m_bones.create(getAllocator(), bonesCount);
// Load every bone
bonesCount = 0;
do
{
Bone& bone = m_bones[bonesCount++];
// <name>
XmlElement nameEl;
ANKI_CHECK(boneEl.getChildElement("name", nameEl));
CString tmp;
ANKI_CHECK(nameEl.getText(tmp));
bone.m_name.create(getAllocator(), tmp);
// <transform>
XmlElement trfEl;
ANKI_CHECK(boneEl.getChildElement("transform", trfEl));
ANKI_CHECK(trfEl.getMat4(bone.m_transform));
// Advance
ANKI_CHECK(boneEl.getNextSiblingElement("bone", boneEl));
} while(boneEl);
return ErrorCode::NONE;
}
//==============================================================================
Error Animation::load(const ResourceFilename& filename)
{
XmlElement el;
I64 tmp;
F64 ftmp;
m_startTime = MAX_F32;
F32 maxTime = MIN_F32;
// Document
XmlDocument doc;
ANKI_CHECK(openFileParseXml(filename, doc));
XmlElement rootel;
ANKI_CHECK(doc.getChildElement("animation", rootel));
// Count the number of identity keys. If all of the keys are identities
// drop a vector
U identPosCount = 0;
U identRotCount = 0;
U identScaleCount = 0;
// <repeat>
XmlElement repel;
ANKI_CHECK(rootel.getChildElementOptional("repeat", repel));
if(repel)
{
ANKI_CHECK(repel.getI64(tmp));
m_repeat = tmp;
}
else
{
m_repeat = false;
}
// <channels>
XmlElement channelsEl;
ANKI_CHECK(rootel.getChildElement("channels", channelsEl));
XmlElement chEl;
ANKI_CHECK(channelsEl.getChildElement("channel", chEl));
U32 channelCount = 0;
ANKI_CHECK(chEl.getSiblingElementsCount(channelCount));
if(channelCount == 0)
{
ANKI_LOGE("Didn't found any channels");
return ErrorCode::USER_DATA;
}
m_channels.create(getAllocator(), channelCount);
// For all channels
channelCount = 0;
do
{
AnimationChannel& ch = m_channels[channelCount];
// <name>
ANKI_CHECK(chEl.getChildElement("name", el));
CString strtmp;
ANKI_CHECK(el.getText(strtmp));
ch.m_name.create(getAllocator(), strtmp);
XmlElement keysEl, keyEl;
// <positionKeys>
ANKI_CHECK(chEl.getChildElementOptional("positionKeys", keysEl));
if(keysEl)
{
ANKI_CHECK(keysEl.getChildElement("key", keyEl));
U32 count = 0;
ANKI_CHECK(keyEl.getSiblingElementsCount(count));
ch.m_positions.create(getAllocator(), count);
count = 0;
do
{
Key<Vec3>& key = ch.m_positions[count++];
// <time>
ANKI_CHECK(keyEl.getChildElement("time", el));
ANKI_CHECK(el.getF64(ftmp));
key.m_time = ftmp;
m_startTime = std::min(m_startTime, key.m_time);
maxTime = std::max(maxTime, key.m_time);
// <value>
ANKI_CHECK(keyEl.getChildElement("value", el));
ANKI_CHECK(el.getVec3(key.m_value));
// Check ident
if(key.m_value == Vec3(0.0))
{
++identPosCount;
}
// Move to next
ANKI_CHECK(keyEl.getNextSiblingElement("key", keyEl));
} while(keyEl);
}
// <rotationKeys>
ANKI_CHECK(chEl.getChildElement("rotationKeys", keysEl));
if(keysEl)
{
ANKI_CHECK(keysEl.getChildElement("key", keyEl));
U32 count = 0;
ANKI_CHECK(keysEl.getSiblingElementsCount(count));
ch.m_rotations.create(getAllocator(), count);
count = 0;
do
{
Key<Quat>& key = ch.m_rotations[count++];
// <time>
ANKI_CHECK(keyEl.getChildElement("time", el));
ANKI_CHECK(el.getF64(ftmp));
key.m_time = ftmp;
m_startTime = std::min(m_startTime, key.m_time);
maxTime = std::max(maxTime, key.m_time);
// <value>
Vec4 tmp2;
ANKI_CHECK(keyEl.getChildElement("value", el));
ANKI_CHECK(el.getVec4(tmp2));
key.m_value = Quat(tmp2);
// Check ident
if(key.m_value == Quat::getIdentity())
{
++identRotCount;
}
// Move to next
ANKI_CHECK(keyEl.getNextSiblingElement("key", keyEl));
} while(keyEl);
}
// <scalingKeys>
ANKI_CHECK(chEl.getChildElementOptional("scalingKeys", keysEl));
if(keysEl)
{
ANKI_CHECK(keysEl.getChildElement("key", keyEl));
U32 count = 0;
ANKI_CHECK(keyEl.getSiblingElementsCount(count));
ch.m_scales.create(getAllocator(), count);
count = 0;
do
{
Key<F32>& key = ch.m_scales[count++];
// <time>
ANKI_CHECK(keyEl.getChildElement("time", el));
ANKI_CHECK(el.getF64(ftmp));
key.m_time = ftmp;
m_startTime = std::min(m_startTime, key.m_time);
maxTime = std::max(maxTime, key.m_time);
// <value>
ANKI_CHECK(keyEl.getChildElement("value", el));
ANKI_CHECK(el.getF64(ftmp));
key.m_value = ftmp;
// Check ident
if(isZero(key.m_value - 1.0))
{
++identScaleCount;
}
// Move to next
ANKI_CHECK(keyEl.getNextSiblingElement("key", keyEl));
} while(keyEl);
}
// Remove identity vectors
if(identPosCount == ch.m_positions.getSize())
{
ch.m_positions.destroy(getAllocator());
}
if(identRotCount == ch.m_rotations.getSize())
{
ch.m_rotations.destroy(getAllocator());
}
if(identScaleCount == ch.m_scales.getSize())
{
ch.m_scales.destroy(getAllocator());
}
// Move to next channel
++channelCount;
ANKI_CHECK(chEl.getNextSiblingElement("channel", chEl));
} while(chEl);
m_duration = maxTime - m_startTime;
return ErrorCode::NONE;
}
