v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Ogre: fix xml migration.

pull/2966/head
Kim Kulling 2020-09-27 09:36:38 +02:00
parent d6892b3f58
commit 9234fee35e
2 changed files with 65 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
code/AssetLib/Ogre/OgreXmlSerializer.cpp
View File

@ -131,7 +131,6 @@ bool OgreXmlSerializer::ReadAttribute<bool>(XmlNode &xmlNode, const char *name)
return false; return false;
} }
// Mesh XML constants // Mesh XML constants
// <mesh> // <mesh>
@ -226,17 +225,26 @@ MeshXml *OgreXmlSerializer::ImportMesh(XmlParser *parser) {
void OgreXmlSerializer::ReadMesh(MeshXml *mesh) { void OgreXmlSerializer::ReadMesh(MeshXml *mesh) {
XmlNode root = mParser->getRootNode(); XmlNode root = mParser->getRootNode();
if (nullptr == root || std::string(nnMesh) != root.name()) { if (nullptr == root) {
throw DeadlyImportError("Root node is <" + std::string(root.name()) + "> expecting <mesh>"); throw DeadlyImportError("Root node is <" + std::string(root.name()) + "> expecting <mesh>");
} }
for (XmlNode currentNode : root.children()) { XmlNode startNode = root.child(nnMesh);
if (startNode.empty()) {
throw DeadlyImportError("Root node is <" + std::string(root.name()) + "> expecting <mesh>");
}
for (XmlNode currentNode : startNode.children()) {
const std::string currentName = currentNode.name(); const std::string currentName = currentNode.name();
if (currentName == nnSharedGeometry) { if (currentName == nnSharedGeometry) {
mesh->sharedVertexData = new VertexDataXml(); mesh->sharedVertexData = new VertexDataXml();
ReadGeometry(currentNode, mesh->sharedVertexData); ReadGeometry(currentNode, mesh->sharedVertexData);
} else if (currentName == nnSubMesh) { } else if (currentName == nnSubMeshes) {
ReadSubMesh(currentNode, mesh); for (XmlNode &subMeshesNode : currentNode.children()) {
const std::string &currentSMName = subMeshesNode.name();
if (currentSMName == nnSubMesh) {
ReadSubMesh(subMeshesNode, mesh);
}
}
} else if (currentName == nnBoneAssignments) { } else if (currentName == nnBoneAssignments) {
ReadBoneAssignments(currentNode, mesh->sharedVertexData); ReadBoneAssignments(currentNode, mesh->sharedVertexData);
} else if (currentName == nnSkeletonLink) { } else if (currentName == nnSkeletonLink) {
@ -289,35 +297,37 @@ void OgreXmlSerializer::ReadGeometryVertexBuffer(XmlNode &node, VertexDataXml *d
} }
} }
for (XmlNode currentNode : node.children()) { for (XmlNode currentNode : node.children("vertex")) {
const std::string &currentName = currentNode.name(); for (XmlNode vertexNode : currentNode.children()) {
const std::string &currentName = vertexNode.name();
if (positions && currentName == nnPosition) { if (positions && currentName == nnPosition) {
aiVector3D pos; aiVector3D pos;
pos.x = ReadAttribute<float>(currentNode, anX); pos.x = ReadAttribute<float>(vertexNode, anX);
pos.y = ReadAttribute<float>(currentNode, anY); pos.y = ReadAttribute<float>(vertexNode, anY);
pos.z = ReadAttribute<float>(currentNode, anZ); pos.z = ReadAttribute<float>(vertexNode, anZ);
dest->positions.push_back(pos); dest->positions.push_back(pos);
} else if (normals && currentName == nnNormal) { } else if (normals && currentName == nnNormal) {
aiVector3D normal; aiVector3D normal;
normal.x = ReadAttribute<float>(currentNode, anX); normal.x = ReadAttribute<float>(vertexNode, anX);
normal.y = ReadAttribute<float>(currentNode, anY); normal.y = ReadAttribute<float>(vertexNode, anY);
normal.z = ReadAttribute<float>(currentNode, anZ); normal.z = ReadAttribute<float>(vertexNode, anZ);
dest->normals.push_back(normal); dest->normals.push_back(normal);
} else if (tangents && currentName == nnTangent) { } else if (tangents && currentName == nnTangent) {
aiVector3D tangent; aiVector3D tangent;
tangent.x = ReadAttribute<float>(currentNode, anX); tangent.x = ReadAttribute<float>(vertexNode, anX);
tangent.y = ReadAttribute<float>(currentNode, anY); tangent.y = ReadAttribute<float>(vertexNode, anY);
tangent.z = ReadAttribute<float>(currentNode, anZ); tangent.z = ReadAttribute<float>(vertexNode, anZ);
dest->tangents.push_back(tangent); dest->tangents.push_back(tangent);
} else if (uvs > 0 && currentName == nnTexCoord) { } else if (uvs > 0 && currentName == nnTexCoord) {
for (auto &curUvs : dest->uvs) { for (auto &curUvs : dest->uvs) {
aiVector3D uv; aiVector3D uv;
uv.x = ReadAttribute<float>(currentNode, "u"); uv.x = ReadAttribute<float>(vertexNode, "u");
uv.y = (ReadAttribute<float>(currentNode, "v") * -1) + 1; // Flip UV from Ogre to Assimp form uv.y = (ReadAttribute<float>(vertexNode, "v") * -1) + 1; // Flip UV from Ogre to Assimp form
curUvs.push_back(uv); curUvs.push_back(uv);
} }
} }
} }
}
// Sanity checks // Sanity checks
if (dest->positions.size() != dest->count) { if (dest->positions.size() != dest->count) {
@ -371,7 +381,7 @@ void OgreXmlSerializer::ReadSubMesh(XmlNode &node, MeshXml *mesh) {
submesh->indexData->faceCount = ReadAttribute<uint32_t>(currentNode, anCount); submesh->indexData->faceCount = ReadAttribute<uint32_t>(currentNode, anCount);
submesh->indexData->faces.reserve(submesh->indexData->faceCount); submesh->indexData->faces.reserve(submesh->indexData->faceCount);
for (XmlNode currentChildNode : currentNode.children()) { for (XmlNode currentChildNode : currentNode.children()) {
const std::string &currentChildName = currentNode.name(); const std::string &currentChildName = currentChildNode.name();
if (currentChildName == nnFace) { if (currentChildName == nnFace) {
aiFace face; aiFace face;
face.mNumIndices = 3; face.mNumIndices = 3;
@ -384,6 +394,7 @@ void OgreXmlSerializer::ReadSubMesh(XmlNode &node, MeshXml *mesh) {
ASSIMP_LOG_WARN("Submesh <face> has quads with <v4>, only triangles are supported at the moment!"); ASSIMP_LOG_WARN("Submesh <face> has quads with <v4>, only triangles are supported at the moment!");
quadWarned = true; quadWarned = true;
} }
submesh->indexData->faces.push_back(face);
} }
} }
if (submesh->indexData->faces.size() == submesh->indexData->faceCount) { if (submesh->indexData->faces.size() == submesh->indexData->faceCount) {
@ -561,14 +572,14 @@ void OgreXmlSerializer::ReadAnimations(XmlNode &node, Skeleton *skeleton) {
if (currentName == nnAnimation) { if (currentName == nnAnimation) {
Animation *anim = new Animation(skeleton); Animation *anim = new Animation(skeleton);
anim->name = ReadAttribute<std::string>(currentNode, "name"); anim->name = ReadAttribute<std::string>(currentNode, "name");
anim->length = ReadAttribute<float>(currentNode , "length"); anim->length = ReadAttribute<float>(currentNode, "length");
for (XmlNode &currentChildNode : currentNode.children()) { for (XmlNode &currentChildNode : currentNode.children()) {
const std::string currentChildName = currentNode.name(); const std::string currentChildName = currentNode.name();
if (currentChildName == nnTracks) { if (currentChildName == nnTracks) {
ReadAnimationTracks(currentChildNode, anim); ReadAnimationTracks(currentChildNode, anim);
skeleton->animations.push_back(anim); skeleton->animations.push_back(anim);
} else { } else {
throw DeadlyImportError( "No <tracks> found in <animation> ", anim->name); throw DeadlyImportError("No <tracks> found in <animation> ", anim->name);
} }
} }
} }
@ -588,10 +599,9 @@ void OgreXmlSerializer::ReadAnimationTracks(XmlNode &node, Animation *dest) {
ReadAnimationKeyFrames(currentChildNode, dest, &track); ReadAnimationKeyFrames(currentChildNode, dest, &track);
dest->tracks.push_back(track); dest->tracks.push_back(track);
} else { } else {
throw DeadlyImportError( "No <keyframes> found in <track> ", dest->name); throw DeadlyImportError("No <keyframes> found in <track> ", dest->name);
} }
} }
} }
} }
} }
@ -631,9 +641,7 @@ void OgreXmlSerializer::ReadAnimationKeyFrames(XmlNode &node, Animation *anim, V
keyframe.scale.x = ReadAttribute<float>(currentChildNode, anX); keyframe.scale.x = ReadAttribute<float>(currentChildNode, anX);
keyframe.scale.y = ReadAttribute<float>(currentChildNode, anY); keyframe.scale.y = ReadAttribute<float>(currentChildNode, anY);
keyframe.scale.z = ReadAttribute<float>(currentChildNode, anZ); keyframe.scale.z = ReadAttribute<float>(currentChildNode, anZ);
} }
} }
} }
dest->transformKeyFrames.push_back(keyframe); dest->transformKeyFrames.push_back(keyframe);
@ -704,7 +712,7 @@ void OgreXmlSerializer::ReadBones(XmlNode &node, Skeleton *skeleton) {
bone->rotation = aiQuaternion(axis, angle); bone->rotation = aiQuaternion(axis, angle);
} else { } else {
throw DeadlyImportError( "No axis specified for bone rotation in bone ", bone->id); throw DeadlyImportError("No axis specified for bone rotation in bone ", bone->id);
} }
} }
} else if (currentChildName == nnScale) { } else if (currentChildName == nnScale) {

36
code/AssetLib/X3D/X3DImporter.hpp
View File

@ -47,15 +47,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#ifndef INCLUDED_AI_X3D_IMPORTER_H #ifndef INCLUDED_AI_X3D_IMPORTER_H
#define INCLUDED_AI_X3D_IMPORTER_H #define INCLUDED_AI_X3D_IMPORTER_H
// Header files, Assimp. // Header files, Assimp.
#include <assimp/DefaultLogger.hpp>
#include <assimp/importerdesc.h>
#include <assimp/ProgressHandler.hpp>
#include <assimp/types.h>
#include <assimp/BaseImporter.h> #include <assimp/BaseImporter.h>
#include <assimp/XmlParser.h> #include <assimp/XmlParser.h>
#include <assimp/importerdesc.h>
#include <assimp/scene.h> #include <assimp/scene.h>
#include <assimp/types.h>
#include <assimp/DefaultLogger.hpp>
#include <assimp/ProgressHandler.hpp>
#include <list> #include <list>
@ -102,8 +101,6 @@ inline void LogInfo(const std::string &message) {
DefaultLogger::get()->info(message); DefaultLogger::get()->info(message);
} }
/// \class X3DImporter /// \class X3DImporter
/// Class that holding scene graph which include: groups, geometry, metadata etc. /// Class that holding scene graph which include: groups, geometry, metadata etc.
/// ///
@ -289,16 +286,11 @@ struct X3DNodeElementBase {
X3DElemType Type; X3DElemType Type;
}; };
class X3DImporter : public BaseImporter class X3DImporter : public BaseImporter {
{
public: public:
std::list<X3DNodeElementBase*> NodeElement_List;///< All elements of scene graph. std::list<X3DNodeElementBase *> NodeElement_List; ///< All elements of scene graph.
public: public:
/***********************************************/
/****************** Functions ******************/
/***********************************************/
/// Default constructor. /// Default constructor.
X3DImporter(); X3DImporter();
@ -313,20 +305,20 @@ public:
/// Also exception can be thrown if trouble will found. /// Also exception can be thrown if trouble will found.
/// \param [in] pFile - name of file to be parsed. /// \param [in] pFile - name of file to be parsed.
/// \param [in] pIOHandler - pointer to IO helper object. /// \param [in] pIOHandler - pointer to IO helper object.
void ParseFile( const std::string& pFile, IOSystem* pIOHandler ); void ParseFile(const std::string &pFile, IOSystem *pIOHandler);
bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool pCheckSig ) const; bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool pCheckSig) const;
void GetExtensionList( std::set<std::string>& pExtensionList ); void GetExtensionList(std::set<std::string> &pExtensionList);
void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler ); void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler);
const aiImporterDesc* GetInfo()const; const aiImporterDesc *GetInfo() const;
void Clear(); void Clear();
private: private:
static const aiImporterDesc Description; static const aiImporterDesc Description;
X3DNodeElementBase* mNodeElementCur;///< Current element. X3DNodeElementBase *mNodeElementCur; ///< Current element.
XmlParser *mXmlParser; XmlParser *mXmlParser;
IOSystem *mpIOHandler; IOSystem *mpIOHandler;
};// class X3DImporter }; // class X3DImporter
}// namespace Assimp } // namespace Assimp
#endif // INCLUDED_AI_X3D_IMPORTER_H #endif // INCLUDED_AI_X3D_IMPORTER_H