1006 lines
33 KiB
C++
1006 lines
33 KiB
C++
/*
|
|
Open Asset Import Library (assimp)
|
|
----------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2017, assimp team
|
|
|
|
All rights reserved.
|
|
|
|
Redistribution and use of this software in source and binary forms,
|
|
with or without modification, are permitted provided that the
|
|
following conditions are met:
|
|
|
|
* Redistributions of source code must retain the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer in the documentation and/or other
|
|
materials provided with the distribution.
|
|
|
|
* Neither the name of the assimp team, nor the names of its
|
|
contributors may be used to endorse or promote products
|
|
derived from this software without specific prior
|
|
written permission of the assimp team.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
----------------------------------------------------------------------
|
|
*/
|
|
|
|
#include "OgreXmlSerializer.h"
|
|
#include "OgreBinarySerializer.h"
|
|
#include "OgreParsingUtils.h"
|
|
|
|
#include "TinyFormatter.h"
|
|
#include <assimp/DefaultLogger.hpp>
|
|
#include <memory>
|
|
|
|
#ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER
|
|
|
|
// Define as 1 to get verbose logging.
|
|
#define OGRE_XML_SERIALIZER_DEBUG 0
|
|
|
|
namespace Assimp
|
|
{
|
|
namespace Ogre
|
|
{
|
|
|
|
AI_WONT_RETURN void ThrowAttibuteError(const XmlReader* reader, const std::string &name, const std::string &error = "") AI_WONT_RETURN_SUFFIX;
|
|
AI_WONT_RETURN void ThrowAttibuteError(const XmlReader* reader, const std::string &name, const std::string &error)
|
|
{
|
|
if (!error.empty())
|
|
{
|
|
throw DeadlyImportError(error + " in node '" + std::string(reader->getNodeName()) + "' and attribute '" + name + "'");
|
|
}
|
|
else
|
|
{
|
|
throw DeadlyImportError("Attribute '" + name + "' does not exist in node '" + std::string(reader->getNodeName()) + "'");
|
|
}
|
|
}
|
|
|
|
template<>
|
|
int32_t OgreXmlSerializer::ReadAttribute<int32_t>(const std::string &name) const
|
|
{
|
|
if (HasAttribute(name.c_str()))
|
|
{
|
|
return static_cast<int32_t>(m_reader->getAttributeValueAsInt(name.c_str()));
|
|
}
|
|
else
|
|
{
|
|
ThrowAttibuteError(m_reader, name);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
template<>
|
|
uint32_t OgreXmlSerializer::ReadAttribute<uint32_t>(const std::string &name) const
|
|
{
|
|
if (HasAttribute(name.c_str()))
|
|
{
|
|
/** @note This is hackish. But we are never expecting unsigned values that go outside the
|
|
int32_t range. Just monitor for negative numbers and kill the import. */
|
|
int32_t temp = ReadAttribute<int32_t>(name);
|
|
if (temp >= 0)
|
|
{
|
|
return static_cast<uint32_t>(temp);
|
|
}
|
|
else
|
|
{
|
|
ThrowAttibuteError(m_reader, name, "Found a negative number value where expecting a uint32_t value");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ThrowAttibuteError(m_reader, name);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
template<>
|
|
uint16_t OgreXmlSerializer::ReadAttribute<uint16_t>(const std::string &name) const
|
|
{
|
|
if (HasAttribute(name.c_str()))
|
|
{
|
|
return static_cast<uint16_t>(ReadAttribute<uint32_t>(name));
|
|
}
|
|
else
|
|
{
|
|
ThrowAttibuteError(m_reader, name);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
template<>
|
|
float OgreXmlSerializer::ReadAttribute<float>(const std::string &name) const
|
|
{
|
|
if (HasAttribute(name.c_str()))
|
|
{
|
|
return m_reader->getAttributeValueAsFloat(name.c_str());
|
|
}
|
|
else
|
|
{
|
|
ThrowAttibuteError(m_reader, name);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
template<>
|
|
std::string OgreXmlSerializer::ReadAttribute<std::string>(const std::string &name) const
|
|
{
|
|
const char* value = m_reader->getAttributeValue(name.c_str());
|
|
if (value)
|
|
{
|
|
return std::string(value);
|
|
}
|
|
else
|
|
{
|
|
ThrowAttibuteError(m_reader, name);
|
|
return "";
|
|
}
|
|
}
|
|
|
|
template<>
|
|
bool OgreXmlSerializer::ReadAttribute<bool>(const std::string &name) const
|
|
{
|
|
std::string value = Ogre::ToLower(ReadAttribute<std::string>(name));
|
|
if (ASSIMP_stricmp(value, "true") == 0)
|
|
{
|
|
return true;
|
|
}
|
|
else if (ASSIMP_stricmp(value, "false") == 0)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
ThrowAttibuteError(m_reader, name, "Boolean value is expected to be 'true' or 'false', encountered '" + value + "'");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool OgreXmlSerializer::HasAttribute(const std::string &name) const
|
|
{
|
|
return (m_reader->getAttributeValue(name.c_str()) != 0);
|
|
}
|
|
|
|
std::string &OgreXmlSerializer::NextNode()
|
|
{
|
|
do
|
|
{
|
|
if (!m_reader->read())
|
|
{
|
|
m_currentNodeName = "";
|
|
return m_currentNodeName;
|
|
}
|
|
}
|
|
while(m_reader->getNodeType() != irr::io::EXN_ELEMENT);
|
|
|
|
CurrentNodeName(true);
|
|
#if (OGRE_XML_SERIALIZER_DEBUG == 1)
|
|
DefaultLogger::get()->debug("<" + m_currentNodeName + ">");
|
|
#endif
|
|
return m_currentNodeName;
|
|
}
|
|
|
|
bool OgreXmlSerializer::CurrentNodeNameEquals(const std::string &name) const
|
|
{
|
|
return (ASSIMP_stricmp(m_currentNodeName, name) == 0);
|
|
}
|
|
|
|
std::string OgreXmlSerializer::CurrentNodeName(bool forceRead)
|
|
{
|
|
if (forceRead)
|
|
m_currentNodeName = std::string(m_reader->getNodeName());
|
|
return m_currentNodeName;
|
|
}
|
|
|
|
std::string &OgreXmlSerializer::SkipCurrentNode()
|
|
{
|
|
#if (OGRE_XML_SERIALIZER_DEBUG == 1)
|
|
DefaultLogger::get()->debug("Skipping node <" + m_currentNodeName + ">");
|
|
#endif
|
|
|
|
for(;;)
|
|
{
|
|
if (!m_reader->read())
|
|
{
|
|
m_currentNodeName = "";
|
|
return m_currentNodeName;
|
|
}
|
|
if (m_reader->getNodeType() != irr::io::EXN_ELEMENT_END)
|
|
continue;
|
|
else if (std::string(m_reader->getNodeName()) == m_currentNodeName)
|
|
break;
|
|
}
|
|
return NextNode();
|
|
}
|
|
|
|
// Mesh XML constants
|
|
|
|
// <mesh>
|
|
const std::string nnMesh = "mesh";
|
|
const std::string nnSharedGeometry = "sharedgeometry";
|
|
const std::string nnSubMeshes = "submeshes";
|
|
const std::string nnSubMesh = "submesh";
|
|
const std::string nnSubMeshNames = "submeshnames";
|
|
const std::string nnSkeletonLink = "skeletonlink";
|
|
const std::string nnLOD = "levelofdetail";
|
|
const std::string nnExtremes = "extremes";
|
|
const std::string nnPoses = "poses";
|
|
const std::string nnAnimations = "animations";
|
|
|
|
// <submesh>
|
|
const std::string nnFaces = "faces";
|
|
const std::string nnFace = "face";
|
|
const std::string nnGeometry = "geometry";
|
|
const std::string nnTextures = "textures";
|
|
|
|
// <mesh/submesh>
|
|
const std::string nnBoneAssignments = "boneassignments";
|
|
|
|
// <sharedgeometry/geometry>
|
|
const std::string nnVertexBuffer = "vertexbuffer";
|
|
|
|
// <vertexbuffer>
|
|
const std::string nnVertex = "vertex";
|
|
const std::string nnPosition = "position";
|
|
const std::string nnNormal = "normal";
|
|
const std::string nnTangent = "tangent";
|
|
const std::string nnBinormal = "binormal";
|
|
const std::string nnTexCoord = "texcoord";
|
|
const std::string nnColorDiffuse = "colour_diffuse";
|
|
const std::string nnColorSpecular = "colour_specular";
|
|
|
|
// <boneassignments>
|
|
const std::string nnVertexBoneAssignment = "vertexboneassignment";
|
|
|
|
// Skeleton XML constants
|
|
|
|
// <skeleton>
|
|
const std::string nnSkeleton = "skeleton";
|
|
const std::string nnBones = "bones";
|
|
const std::string nnBoneHierarchy = "bonehierarchy";
|
|
const std::string nnAnimationLinks = "animationlinks";
|
|
|
|
// <bones>
|
|
const std::string nnBone = "bone";
|
|
const std::string nnRotation = "rotation";
|
|
const std::string nnAxis = "axis";
|
|
const std::string nnScale = "scale";
|
|
|
|
// <bonehierarchy>
|
|
const std::string nnBoneParent = "boneparent";
|
|
|
|
// <animations>
|
|
const std::string nnAnimation = "animation";
|
|
const std::string nnTracks = "tracks";
|
|
|
|
// <tracks>
|
|
const std::string nnTrack = "track";
|
|
const std::string nnKeyFrames = "keyframes";
|
|
const std::string nnKeyFrame = "keyframe";
|
|
const std::string nnTranslate = "translate";
|
|
const std::string nnRotate = "rotate";
|
|
|
|
// Common XML constants
|
|
|
|
const std::string anX = "x";
|
|
const std::string anY = "y";
|
|
const std::string anZ = "z";
|
|
|
|
// Mesh
|
|
|
|
MeshXml *OgreXmlSerializer::ImportMesh(XmlReader *reader)
|
|
{
|
|
OgreXmlSerializer serializer(reader);
|
|
|
|
MeshXml *mesh = new MeshXml();
|
|
serializer.ReadMesh(mesh);
|
|
return mesh;
|
|
}
|
|
|
|
void OgreXmlSerializer::ReadMesh(MeshXml *mesh)
|
|
{
|
|
if (NextNode() != nnMesh) {
|
|
throw DeadlyImportError("Root node is <" + m_currentNodeName + "> expecting <mesh>");
|
|
}
|
|
|
|
DefaultLogger::get()->debug("Reading Mesh");
|
|
|
|
NextNode();
|
|
|
|
// Root level nodes
|
|
while(m_currentNodeName == nnSharedGeometry ||
|
|
m_currentNodeName == nnSubMeshes ||
|
|
m_currentNodeName == nnSkeletonLink ||
|
|
m_currentNodeName == nnBoneAssignments ||
|
|
m_currentNodeName == nnLOD ||
|
|
m_currentNodeName == nnSubMeshNames ||
|
|
m_currentNodeName == nnExtremes ||
|
|
m_currentNodeName == nnPoses ||
|
|
m_currentNodeName == nnAnimations)
|
|
{
|
|
if (m_currentNodeName == nnSharedGeometry)
|
|
{
|
|
mesh->sharedVertexData = new VertexDataXml();
|
|
ReadGeometry(mesh->sharedVertexData);
|
|
}
|
|
else if (m_currentNodeName == nnSubMeshes)
|
|
{
|
|
NextNode();
|
|
while(m_currentNodeName == nnSubMesh) {
|
|
ReadSubMesh(mesh);
|
|
}
|
|
}
|
|
else if (m_currentNodeName == nnBoneAssignments)
|
|
{
|
|
ReadBoneAssignments(mesh->sharedVertexData);
|
|
}
|
|
else if (m_currentNodeName == nnSkeletonLink)
|
|
{
|
|
mesh->skeletonRef = ReadAttribute<std::string>("name");
|
|
DefaultLogger::get()->debug("Read skeleton link " + mesh->skeletonRef);
|
|
NextNode();
|
|
}
|
|
// Assimp incompatible/ignored nodes
|
|
else
|
|
SkipCurrentNode();
|
|
}
|
|
}
|
|
|
|
void OgreXmlSerializer::ReadGeometry(VertexDataXml *dest)
|
|
{
|
|
dest->count = ReadAttribute<uint32_t>("vertexcount");
|
|
DefaultLogger::get()->debug(Formatter::format() << " - Reading geometry of " << dest->count << " vertices");
|
|
|
|
NextNode();
|
|
while(m_currentNodeName == nnVertexBuffer) {
|
|
ReadGeometryVertexBuffer(dest);
|
|
}
|
|
}
|
|
|
|
void OgreXmlSerializer::ReadGeometryVertexBuffer(VertexDataXml *dest)
|
|
{
|
|
bool positions = (HasAttribute("positions") && ReadAttribute<bool>("positions"));
|
|
bool normals = (HasAttribute("normals") && ReadAttribute<bool>("normals"));
|
|
bool tangents = (HasAttribute("tangents") && ReadAttribute<bool>("tangents"));
|
|
uint32_t uvs = (HasAttribute("texture_coords") ? ReadAttribute<uint32_t>("texture_coords") : 0);
|
|
|
|
// Not having positions is a error only if a previous vertex buffer did not have them.
|
|
if (!positions && !dest->HasPositions()) {
|
|
throw DeadlyImportError("Vertex buffer does not contain positions!");
|
|
}
|
|
|
|
if (positions)
|
|
{
|
|
DefaultLogger::get()->debug(" - Contains positions");
|
|
dest->positions.reserve(dest->count);
|
|
}
|
|
if (normals)
|
|
{
|
|
DefaultLogger::get()->debug(" - Contains normals");
|
|
dest->normals.reserve(dest->count);
|
|
}
|
|
if (tangents)
|
|
{
|
|
DefaultLogger::get()->debug(" - Contains tangents");
|
|
dest->tangents.reserve(dest->count);
|
|
}
|
|
if (uvs > 0)
|
|
{
|
|
DefaultLogger::get()->debug(Formatter::format() << " - Contains " << uvs << " texture coords");
|
|
dest->uvs.resize(uvs);
|
|
for(size_t i=0, len=dest->uvs.size(); i<len; ++i) {
|
|
dest->uvs[i].reserve(dest->count);
|
|
}
|
|
}
|
|
|
|
bool warnBinormal = true;
|
|
bool warnColorDiffuse = true;
|
|
bool warnColorSpecular = true;
|
|
|
|
NextNode();
|
|
|
|
while(m_currentNodeName == nnVertex ||
|
|
m_currentNodeName == nnPosition ||
|
|
m_currentNodeName == nnNormal ||
|
|
m_currentNodeName == nnTangent ||
|
|
m_currentNodeName == nnBinormal ||
|
|
m_currentNodeName == nnTexCoord ||
|
|
m_currentNodeName == nnColorDiffuse ||
|
|
m_currentNodeName == nnColorSpecular)
|
|
{
|
|
if (m_currentNodeName == nnVertex) {
|
|
NextNode();
|
|
}
|
|
|
|
/// @todo Implement nnBinormal, nnColorDiffuse and nnColorSpecular
|
|
|
|
if (positions && m_currentNodeName == nnPosition)
|
|
{
|
|
aiVector3D pos;
|
|
pos.x = ReadAttribute<float>(anX);
|
|
pos.y = ReadAttribute<float>(anY);
|
|
pos.z = ReadAttribute<float>(anZ);
|
|
dest->positions.push_back(pos);
|
|
}
|
|
else if (normals && m_currentNodeName == nnNormal)
|
|
{
|
|
aiVector3D normal;
|
|
normal.x = ReadAttribute<float>(anX);
|
|
normal.y = ReadAttribute<float>(anY);
|
|
normal.z = ReadAttribute<float>(anZ);
|
|
dest->normals.push_back(normal);
|
|
}
|
|
else if (tangents && m_currentNodeName == nnTangent)
|
|
{
|
|
aiVector3D tangent;
|
|
tangent.x = ReadAttribute<float>(anX);
|
|
tangent.y = ReadAttribute<float>(anY);
|
|
tangent.z = ReadAttribute<float>(anZ);
|
|
dest->tangents.push_back(tangent);
|
|
}
|
|
else if (uvs > 0 && m_currentNodeName == nnTexCoord)
|
|
{
|
|
for(auto &uvs : dest->uvs)
|
|
{
|
|
if (m_currentNodeName != nnTexCoord) {
|
|
throw DeadlyImportError("Vertex buffer declared more UVs than can be found in a vertex");
|
|
}
|
|
|
|
aiVector3D uv;
|
|
uv.x = ReadAttribute<float>("u");
|
|
uv.y = (ReadAttribute<float>("v") * -1) + 1; // Flip UV from Ogre to Assimp form
|
|
uvs.push_back(uv);
|
|
|
|
NextNode();
|
|
}
|
|
// Continue main loop as above already read next node
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
/// @todo Remove this stuff once implemented. We only want to log warnings once per element.
|
|
bool warn = true;
|
|
if (m_currentNodeName == nnBinormal)
|
|
{
|
|
if (warnBinormal)
|
|
{
|
|
warnBinormal = false;
|
|
}
|
|
else
|
|
{
|
|
warn = false;
|
|
}
|
|
}
|
|
else if (m_currentNodeName == nnColorDiffuse)
|
|
{
|
|
if (warnColorDiffuse)
|
|
{
|
|
warnColorDiffuse = false;
|
|
}
|
|
else
|
|
{
|
|
warn = false;
|
|
}
|
|
}
|
|
else if (m_currentNodeName == nnColorSpecular)
|
|
{
|
|
if (warnColorSpecular)
|
|
{
|
|
warnColorSpecular = false;
|
|
}
|
|
else
|
|
{
|
|
warn = false;
|
|
}
|
|
}
|
|
if (warn) {
|
|
DefaultLogger::get()->warn("Vertex buffer attribute read not implemented for element: " + m_currentNodeName);
|
|
}
|
|
}
|
|
|
|
// Advance
|
|
NextNode();
|
|
}
|
|
|
|
// Sanity checks
|
|
if (dest->positions.size() != dest->count) {
|
|
throw DeadlyImportError(Formatter::format() << "Read only " << dest->positions.size() << " positions when should have read " << dest->count);
|
|
}
|
|
if (normals && dest->normals.size() != dest->count) {
|
|
throw DeadlyImportError(Formatter::format() << "Read only " << dest->normals.size() << " normals when should have read " << dest->count);
|
|
}
|
|
if (tangents && dest->tangents.size() != dest->count) {
|
|
throw DeadlyImportError(Formatter::format() << "Read only " << dest->tangents.size() << " tangents when should have read " << dest->count);
|
|
}
|
|
for(unsigned int i=0; i<dest->uvs.size(); ++i)
|
|
{
|
|
if (dest->uvs[i].size() != dest->count) {
|
|
throw DeadlyImportError(Formatter::format() << "Read only " << dest->uvs[i].size()
|
|
<< " uvs for uv index " << i << " when should have read " << dest->count);
|
|
}
|
|
}
|
|
}
|
|
|
|
void OgreXmlSerializer::ReadSubMesh(MeshXml *mesh)
|
|
{
|
|
static const std::string anMaterial = "material";
|
|
static const std::string anUseSharedVertices = "usesharedvertices";
|
|
static const std::string anCount = "count";
|
|
static const std::string anV1 = "v1";
|
|
static const std::string anV2 = "v2";
|
|
static const std::string anV3 = "v3";
|
|
static const std::string anV4 = "v4";
|
|
|
|
SubMeshXml* submesh = new SubMeshXml();
|
|
|
|
if (HasAttribute(anMaterial)) {
|
|
submesh->materialRef = ReadAttribute<std::string>(anMaterial);
|
|
}
|
|
if (HasAttribute(anUseSharedVertices)) {
|
|
submesh->usesSharedVertexData = ReadAttribute<bool>(anUseSharedVertices);
|
|
}
|
|
|
|
DefaultLogger::get()->debug(Formatter::format() << "Reading SubMesh " << mesh->subMeshes.size());
|
|
DefaultLogger::get()->debug(Formatter::format() << " - Material: '" << submesh->materialRef << "'");
|
|
DefaultLogger::get()->debug(Formatter::format() << " - Uses shared geometry: " << (submesh->usesSharedVertexData ? "true" : "false"));
|
|
|
|
// TODO: maybe we have always just 1 faces and 1 geometry and always in this order. this loop will only work correct, when the order
|
|
// of faces and geometry changed, and not if we have more than one of one
|
|
/// @todo Fix above comment with better read logic below
|
|
|
|
bool quadWarned = false;
|
|
|
|
NextNode();
|
|
while(m_currentNodeName == nnFaces ||
|
|
m_currentNodeName == nnGeometry ||
|
|
m_currentNodeName == nnTextures ||
|
|
m_currentNodeName == nnBoneAssignments)
|
|
{
|
|
if (m_currentNodeName == nnFaces)
|
|
{
|
|
submesh->indexData->faceCount = ReadAttribute<uint32_t>(anCount);
|
|
submesh->indexData->faces.reserve(submesh->indexData->faceCount);
|
|
|
|
NextNode();
|
|
while(m_currentNodeName == nnFace)
|
|
{
|
|
aiFace face;
|
|
face.mNumIndices = 3;
|
|
face.mIndices = new unsigned int[3];
|
|
face.mIndices[0] = ReadAttribute<uint32_t>(anV1);
|
|
face.mIndices[1] = ReadAttribute<uint32_t>(anV2);
|
|
face.mIndices[2] = ReadAttribute<uint32_t>(anV3);
|
|
|
|
/// @todo Support quads if Ogre even supports them in XML (I'm not sure but I doubt it)
|
|
if (!quadWarned && HasAttribute(anV4)) {
|
|
DefaultLogger::get()->warn("Submesh <face> has quads with <v4>, only triangles are supported at the moment!");
|
|
quadWarned = true;
|
|
}
|
|
|
|
submesh->indexData->faces.push_back(face);
|
|
|
|
// Advance
|
|
NextNode();
|
|
}
|
|
|
|
if (submesh->indexData->faces.size() == submesh->indexData->faceCount)
|
|
{
|
|
DefaultLogger::get()->debug(Formatter::format() << " - Faces " << submesh->indexData->faceCount);
|
|
}
|
|
else
|
|
{
|
|
throw DeadlyImportError(Formatter::format() << "Read only " << submesh->indexData->faces.size() << " faces when should have read " << submesh->indexData->faceCount);
|
|
}
|
|
}
|
|
else if (m_currentNodeName == nnGeometry)
|
|
{
|
|
if (submesh->usesSharedVertexData) {
|
|
throw DeadlyImportError("Found <geometry> in <submesh> when use shared geometry is true. Invalid mesh file.");
|
|
}
|
|
|
|
submesh->vertexData = new VertexDataXml();
|
|
ReadGeometry(submesh->vertexData);
|
|
}
|
|
else if (m_currentNodeName == nnBoneAssignments)
|
|
{
|
|
ReadBoneAssignments(submesh->vertexData);
|
|
}
|
|
// Assimp incompatible/ignored nodes
|
|
else
|
|
SkipCurrentNode();
|
|
}
|
|
|
|
submesh->index = static_cast<unsigned int>(mesh->subMeshes.size());
|
|
mesh->subMeshes.push_back(submesh);
|
|
}
|
|
|
|
void OgreXmlSerializer::ReadBoneAssignments(VertexDataXml *dest)
|
|
{
|
|
if (!dest) {
|
|
throw DeadlyImportError("Cannot read bone assignments, vertex data is null.");
|
|
}
|
|
|
|
static const std::string anVertexIndex = "vertexindex";
|
|
static const std::string anBoneIndex = "boneindex";
|
|
static const std::string anWeight = "weight";
|
|
|
|
std::set<uint32_t> influencedVertices;
|
|
|
|
NextNode();
|
|
while(m_currentNodeName == nnVertexBoneAssignment)
|
|
{
|
|
VertexBoneAssignment ba;
|
|
ba.vertexIndex = ReadAttribute<uint32_t>(anVertexIndex);
|
|
ba.boneIndex = ReadAttribute<uint16_t>(anBoneIndex);
|
|
ba.weight = ReadAttribute<float>(anWeight);
|
|
|
|
dest->boneAssignments.push_back(ba);
|
|
influencedVertices.insert(ba.vertexIndex);
|
|
|
|
NextNode();
|
|
}
|
|
|
|
/** Normalize bone weights.
|
|
Some exporters won't care if the sum of all bone weights
|
|
for a single vertex equals 1 or not, so validate here. */
|
|
const float epsilon = 0.05f;
|
|
for (const uint32_t vertexIndex : influencedVertices)
|
|
{
|
|
float sum = 0.0f;
|
|
for (VertexBoneAssignmentList::const_iterator baIter=dest->boneAssignments.begin(), baEnd=dest->boneAssignments.end(); baIter != baEnd; ++baIter)
|
|
{
|
|
if (baIter->vertexIndex == vertexIndex)
|
|
sum += baIter->weight;
|
|
}
|
|
if ((sum < (1.0f - epsilon)) || (sum > (1.0f + epsilon)))
|
|
{
|
|
for (auto &boneAssign : dest->boneAssignments)
|
|
{
|
|
if (boneAssign.vertexIndex == vertexIndex)
|
|
boneAssign.weight /= sum;
|
|
}
|
|
}
|
|
}
|
|
|
|
DefaultLogger::get()->debug(Formatter::format() << " - " << dest->boneAssignments.size() << " bone assignments");
|
|
}
|
|
|
|
// Skeleton
|
|
|
|
bool OgreXmlSerializer::ImportSkeleton(Assimp::IOSystem *pIOHandler, MeshXml *mesh)
|
|
{
|
|
if (!mesh || mesh->skeletonRef.empty())
|
|
return false;
|
|
|
|
// Highly unusual to see in read world cases but support
|
|
// XML mesh referencing a binary skeleton file.
|
|
if (EndsWith(mesh->skeletonRef, ".skeleton", false))
|
|
{
|
|
if (OgreBinarySerializer::ImportSkeleton(pIOHandler, mesh))
|
|
return true;
|
|
|
|
/** Last fallback if .skeleton failed to be read. Try reading from
|
|
.skeleton.xml even if the XML file referenced a binary skeleton.
|
|
@note This logic was in the previous version and I don't want to break
|
|
old code that might depends on it. */
|
|
mesh->skeletonRef = mesh->skeletonRef + ".xml";
|
|
}
|
|
|
|
XmlReaderPtr reader = OpenReader(pIOHandler, mesh->skeletonRef);
|
|
if (!reader.get())
|
|
return false;
|
|
|
|
Skeleton *skeleton = new Skeleton();
|
|
OgreXmlSerializer serializer(reader.get());
|
|
serializer.ReadSkeleton(skeleton);
|
|
mesh->skeleton = skeleton;
|
|
return true;
|
|
}
|
|
|
|
bool OgreXmlSerializer::ImportSkeleton(Assimp::IOSystem *pIOHandler, Mesh *mesh)
|
|
{
|
|
if (!mesh || mesh->skeletonRef.empty())
|
|
return false;
|
|
|
|
XmlReaderPtr reader = OpenReader(pIOHandler, mesh->skeletonRef);
|
|
if (!reader.get())
|
|
return false;
|
|
|
|
Skeleton *skeleton = new Skeleton();
|
|
OgreXmlSerializer serializer(reader.get());
|
|
serializer.ReadSkeleton(skeleton);
|
|
mesh->skeleton = skeleton;
|
|
return true;
|
|
}
|
|
|
|
XmlReaderPtr OgreXmlSerializer::OpenReader(Assimp::IOSystem *pIOHandler, const std::string &filename)
|
|
{
|
|
if (!EndsWith(filename, ".skeleton.xml", false))
|
|
{
|
|
DefaultLogger::get()->error("Imported Mesh is referencing to unsupported '" + filename + "' skeleton file.");
|
|
return XmlReaderPtr();
|
|
}
|
|
|
|
if (!pIOHandler->Exists(filename))
|
|
{
|
|
DefaultLogger::get()->error("Failed to find skeleton file '" + filename + "' that is referenced by imported Mesh.");
|
|
return XmlReaderPtr();
|
|
}
|
|
|
|
std::unique_ptr<IOStream> file(pIOHandler->Open(filename));
|
|
if (!file.get()) {
|
|
throw DeadlyImportError("Failed to open skeleton file " + filename);
|
|
}
|
|
|
|
std::unique_ptr<CIrrXML_IOStreamReader> stream(new CIrrXML_IOStreamReader(file.get()));
|
|
XmlReaderPtr reader = XmlReaderPtr(irr::io::createIrrXMLReader(stream.get()));
|
|
if (!reader.get()) {
|
|
throw DeadlyImportError("Failed to create XML reader for skeleton file " + filename);
|
|
}
|
|
return reader;
|
|
}
|
|
|
|
void OgreXmlSerializer::ReadSkeleton(Skeleton *skeleton)
|
|
{
|
|
if (NextNode() != nnSkeleton) {
|
|
throw DeadlyImportError("Root node is <" + m_currentNodeName + "> expecting <skeleton>");
|
|
}
|
|
|
|
DefaultLogger::get()->debug("Reading Skeleton");
|
|
|
|
// Optional blend mode from root node
|
|
if (HasAttribute("blendmode")) {
|
|
skeleton->blendMode = (ToLower(ReadAttribute<std::string>("blendmode")) == "cumulative"
|
|
? Skeleton::ANIMBLEND_CUMULATIVE : Skeleton::ANIMBLEND_AVERAGE);
|
|
}
|
|
|
|
NextNode();
|
|
|
|
// Root level nodes
|
|
while(m_currentNodeName == nnBones ||
|
|
m_currentNodeName == nnBoneHierarchy ||
|
|
m_currentNodeName == nnAnimations ||
|
|
m_currentNodeName == nnAnimationLinks)
|
|
{
|
|
if (m_currentNodeName == nnBones)
|
|
ReadBones(skeleton);
|
|
else if (m_currentNodeName == nnBoneHierarchy)
|
|
ReadBoneHierarchy(skeleton);
|
|
else if (m_currentNodeName == nnAnimations)
|
|
ReadAnimations(skeleton);
|
|
else
|
|
SkipCurrentNode();
|
|
}
|
|
}
|
|
|
|
void OgreXmlSerializer::ReadAnimations(Skeleton *skeleton)
|
|
{
|
|
if (skeleton->bones.empty()) {
|
|
throw DeadlyImportError("Cannot read <animations> for a Skeleton without bones");
|
|
}
|
|
|
|
DefaultLogger::get()->debug(" - Animations");
|
|
|
|
NextNode();
|
|
while(m_currentNodeName == nnAnimation)
|
|
{
|
|
Animation *anim = new Animation(skeleton);
|
|
anim->name = ReadAttribute<std::string>("name");
|
|
anim->length = ReadAttribute<float>("length");
|
|
|
|
if (NextNode() != nnTracks) {
|
|
throw DeadlyImportError(Formatter::format() << "No <tracks> found in <animation> " << anim->name);
|
|
}
|
|
|
|
ReadAnimationTracks(anim);
|
|
skeleton->animations.push_back(anim);
|
|
|
|
DefaultLogger::get()->debug(Formatter::format() << " " << anim->name << " (" << anim->length << " sec, " << anim->tracks.size() << " tracks)");
|
|
}
|
|
}
|
|
|
|
void OgreXmlSerializer::ReadAnimationTracks(Animation *dest)
|
|
{
|
|
NextNode();
|
|
while(m_currentNodeName == nnTrack)
|
|
{
|
|
VertexAnimationTrack track;
|
|
track.type = VertexAnimationTrack::VAT_TRANSFORM;
|
|
track.boneName = ReadAttribute<std::string>("bone");
|
|
|
|
if (NextNode() != nnKeyFrames) {
|
|
throw DeadlyImportError(Formatter::format() << "No <keyframes> found in <track> " << dest->name);
|
|
}
|
|
|
|
ReadAnimationKeyFrames(dest, &track);
|
|
|
|
dest->tracks.push_back(track);
|
|
}
|
|
}
|
|
|
|
void OgreXmlSerializer::ReadAnimationKeyFrames(Animation *anim, VertexAnimationTrack *dest)
|
|
{
|
|
const aiVector3D zeroVec(0.f, 0.f, 0.f);
|
|
|
|
NextNode();
|
|
while(m_currentNodeName == nnKeyFrame)
|
|
{
|
|
TransformKeyFrame keyframe;
|
|
keyframe.timePos = ReadAttribute<float>("time");
|
|
|
|
NextNode();
|
|
while(m_currentNodeName == nnTranslate || m_currentNodeName == nnRotate || m_currentNodeName == nnScale)
|
|
{
|
|
if (m_currentNodeName == nnTranslate)
|
|
{
|
|
keyframe.position.x = ReadAttribute<float>(anX);
|
|
keyframe.position.y = ReadAttribute<float>(anY);
|
|
keyframe.position.z = ReadAttribute<float>(anZ);
|
|
}
|
|
else if (m_currentNodeName == nnRotate)
|
|
{
|
|
float angle = ReadAttribute<float>("angle");
|
|
|
|
if (NextNode() != nnAxis) {
|
|
throw DeadlyImportError("No axis specified for keyframe rotation in animation " + anim->name);
|
|
}
|
|
|
|
aiVector3D axis;
|
|
axis.x = ReadAttribute<float>(anX);
|
|
axis.y = ReadAttribute<float>(anY);
|
|
axis.z = ReadAttribute<float>(anZ);
|
|
if (axis.Equal(zeroVec))
|
|
{
|
|
axis.x = 1.0f;
|
|
if (angle != 0) {
|
|
DefaultLogger::get()->warn("Found invalid a key frame with a zero rotation axis in animation: " + anim->name);
|
|
}
|
|
}
|
|
keyframe.rotation = aiQuaternion(axis, angle);
|
|
}
|
|
else if (m_currentNodeName == nnScale)
|
|
{
|
|
keyframe.scale.x = ReadAttribute<float>(anX);
|
|
keyframe.scale.y = ReadAttribute<float>(anY);
|
|
keyframe.scale.z = ReadAttribute<float>(anZ);
|
|
}
|
|
|
|
NextNode();
|
|
}
|
|
|
|
dest->transformKeyFrames.push_back(keyframe);
|
|
}
|
|
}
|
|
|
|
void OgreXmlSerializer::ReadBoneHierarchy(Skeleton *skeleton)
|
|
{
|
|
if (skeleton->bones.empty()) {
|
|
throw DeadlyImportError("Cannot read <bonehierarchy> for a Skeleton without bones");
|
|
}
|
|
|
|
while(NextNode() == nnBoneParent)
|
|
{
|
|
const std::string name = ReadAttribute<std::string>("bone");
|
|
const std::string parentName = ReadAttribute<std::string>("parent");
|
|
|
|
Bone *bone = skeleton->BoneByName(name);
|
|
Bone *parent = skeleton->BoneByName(parentName);
|
|
|
|
if (bone && parent)
|
|
parent->AddChild(bone);
|
|
else
|
|
throw DeadlyImportError("Failed to find bones for parenting: Child " + name + " for parent " + parentName);
|
|
}
|
|
|
|
// Calculate bone matrices for root bones. Recursively calculates their children.
|
|
for (size_t i=0, len=skeleton->bones.size(); i<len; ++i)
|
|
{
|
|
Bone *bone = skeleton->bones[i];
|
|
if (!bone->IsParented())
|
|
bone->CalculateWorldMatrixAndDefaultPose(skeleton);
|
|
}
|
|
}
|
|
|
|
bool BoneCompare(Bone *a, Bone *b)
|
|
{
|
|
return (a->id < b->id);
|
|
}
|
|
|
|
void OgreXmlSerializer::ReadBones(Skeleton *skeleton)
|
|
{
|
|
DefaultLogger::get()->debug(" - Bones");
|
|
|
|
NextNode();
|
|
while(m_currentNodeName == nnBone)
|
|
{
|
|
Bone *bone = new Bone();
|
|
bone->id = ReadAttribute<uint16_t>("id");
|
|
bone->name = ReadAttribute<std::string>("name");
|
|
|
|
NextNode();
|
|
while(m_currentNodeName == nnPosition ||
|
|
m_currentNodeName == nnRotation ||
|
|
m_currentNodeName == nnScale)
|
|
{
|
|
if (m_currentNodeName == nnPosition)
|
|
{
|
|
bone->position.x = ReadAttribute<float>(anX);
|
|
bone->position.y = ReadAttribute<float>(anY);
|
|
bone->position.z = ReadAttribute<float>(anZ);
|
|
}
|
|
else if (m_currentNodeName == nnRotation)
|
|
{
|
|
float angle = ReadAttribute<float>("angle");
|
|
|
|
if (NextNode() != nnAxis) {
|
|
throw DeadlyImportError(Formatter::format() << "No axis specified for bone rotation in bone " << bone->id);
|
|
}
|
|
|
|
aiVector3D axis;
|
|
axis.x = ReadAttribute<float>(anX);
|
|
axis.y = ReadAttribute<float>(anY);
|
|
axis.z = ReadAttribute<float>(anZ);
|
|
|
|
bone->rotation = aiQuaternion(axis, angle);
|
|
}
|
|
else if (m_currentNodeName == nnScale)
|
|
{
|
|
/// @todo Implement taking scale into account in matrix/pose calculations!
|
|
if (HasAttribute("factor"))
|
|
{
|
|
float factor = ReadAttribute<float>("factor");
|
|
bone->scale.Set(factor, factor, factor);
|
|
}
|
|
else
|
|
{
|
|
if (HasAttribute(anX))
|
|
bone->scale.x = ReadAttribute<float>(anX);
|
|
if (HasAttribute(anY))
|
|
bone->scale.y = ReadAttribute<float>(anY);
|
|
if (HasAttribute(anZ))
|
|
bone->scale.z = ReadAttribute<float>(anZ);
|
|
}
|
|
}
|
|
|
|
NextNode();
|
|
}
|
|
|
|
skeleton->bones.push_back(bone);
|
|
}
|
|
|
|
// Order bones by Id
|
|
std::sort(skeleton->bones.begin(), skeleton->bones.end(), BoneCompare);
|
|
|
|
// Validate that bone indexes are not skipped.
|
|
/** @note Left this from original authors code, but not sure if this is strictly necessary
|
|
as per the Ogre skeleton spec. It might be more that other (later) code in this imported does not break. */
|
|
for (size_t i=0, len=skeleton->bones.size(); i<len; ++i)
|
|
{
|
|
Bone *b = skeleton->bones[i];
|
|
DefaultLogger::get()->debug(Formatter::format() << " " << b->id << " " << b->name);
|
|
|
|
if (b->id != static_cast<uint16_t>(i)) {
|
|
throw DeadlyImportError(Formatter::format() << "Bone ids are not in sequence starting from 0. Missing index " << i);
|
|
}
|
|
}
|
|
}
|
|
|
|
} // Ogre
|
|
} // Assimp
|
|
|
|
#endif // ASSIMP_BUILD_NO_OGRE_IMPORTER
|