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

xml-migration: migration of XGLImporter.

pull/2966/head
Kim Kulling 2020-02-05 22:51:39 +01:00
parent 1a8d5667b6
commit 979153522c
12 changed files with 788 additions and 1021 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
code/AMF/AMFImporter.cpp
View File

@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2020, assimp team Copyright (c) 2006-2020, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -90,9 +88,9 @@ void AMFImporter::Clear() {
} }
AMFImporter::~AMFImporter() { AMFImporter::~AMFImporter() {
if (mReader != nullptr) { if (mXmlParser != nullptr) {
delete mReader; delete mXmlParser;
mReader = nullptr; mXmlParser = nullptr;
} }
// Clear() is accounting if data already is deleted. So, just check again if all data is deleted. // Clear() is accounting if data already is deleted. So, just check again if all data is deleted.
@ -106,7 +104,9 @@ AMFImporter::~AMFImporter() {
bool AMFImporter::Find_NodeElement(const std::string &pID, const CAMFImporter_NodeElement::EType pType, CAMFImporter_NodeElement **pNodeElement) const { bool AMFImporter::Find_NodeElement(const std::string &pID, const CAMFImporter_NodeElement::EType pType, CAMFImporter_NodeElement **pNodeElement) const {
for (CAMFImporter_NodeElement *ne : mNodeElement_List) { for (CAMFImporter_NodeElement *ne : mNodeElement_List) {
if ((ne->ID == pID) && (ne->Type == pType)) { if ((ne->ID == pID) && (ne->Type == pType)) {
if (pNodeElement != nullptr) *pNodeElement = ne; if (pNodeElement != nullptr) {
*pNodeElement = ne;
}
return true; return true;
} }
@ -173,10 +173,9 @@ void AMFImporter::Throw_ID_NotFound(const std::string &pID) const {
/************************************************************* Functions: XML set ************************************************************/ /************************************************************* Functions: XML set ************************************************************/
/*********************************************************************************************************************************************/ /*********************************************************************************************************************************************/
void AMFImporter::XML_CheckNode_MustHaveChildren( XmlNode *node ) { void AMFImporter::XML_CheckNode_MustHaveChildren( XmlNode &node ) {
//if (mReader->isEmptyElement()) throw DeadlyImportError(std::string("Node <") + mReader->getNodeName() + "> must have children."); if (node.children().begin() == node.children().end()) {
if (node->getNode()->children().begin() == node->getNode()->children().end()) { throw DeadlyImportError(std::string("Node <") + std::string(node.name()) + "> must have children.");
throw DeadlyImportError(std::string("Node <") + std::string(node->getNode()->name()) + "> must have children.");
} }
} }
@ -221,20 +220,23 @@ casu_cres:
} }
} }
*/ */
bool AMFImporter::XML_SearchNode(const std::string &pNodeName) { bool AMFImporter::XML_SearchNode(const std::string &nodeName) {
XmlNode *root = mXmlParser->getRootNode();
mReader->while (mReader->read()) { if (nullptr == root) {
//if((mReader->getNodeType() == irr::io::EXN_ELEMENT) && XML_CheckNode_NameEqual(pNodeName)) return true; return false;
if ((mReader->getNodeType() == pugi::node_element) && XML_CheckNode_NameEqual(pNodeName)) { }
return true;
}
}
return false; find_node_by_name_predicate predicate(nodeName);
XmlNode node = root->find_node(predicate);
if (node.empty()) {
return false;
}
return true;
} }
bool AMFImporter::XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx) { bool AMFImporter::XML_ReadNode_GetAttrVal_AsBool (const int pAttrIdx) {
std::string val(mReader->getAttributeValue(pAttrIdx)); std::string val(mXmlParser->getAttributeValue(pAttrIdx));
if ((val == "false") || (val == "0")) if ((val == "false") || (val == "0"))
return false; return false;
@ -248,42 +250,42 @@ float AMFImporter::XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx) {
std::string val; std::string val;
float tvalf; float tvalf;
ParseHelper_FixTruncatedFloatString(mReader->getAttributeValue(pAttrIdx), val); ParseHelper_FixTruncatedFloatString(mXmlParser->getAttributeValue(pAttrIdx), val);
fast_atoreal_move(val.c_str(), tvalf, false); fast_atoreal_move(val.c_str(), tvalf, false);
return tvalf; return tvalf;
} }
uint32_t AMFImporter::XML_ReadNode_GetAttrVal_AsU32(const int pAttrIdx) { uint32_t AMFImporter::XML_ReadNode_GetAttrVal_AsU32(const int pAttrIdx) {
return strtoul10(mReader->getAttributeValue(pAttrIdx)); return strtoul10(mXmlParser->getAttributeValue(pAttrIdx));
} }
float AMFImporter::XML_ReadNode_GetVal_AsFloat() { float AMFImporter::XML_ReadNode_GetVal_AsFloat() {
std::string val; std::string val;
float tvalf; float tvalf;
if (!mReader->read()) throw DeadlyImportError("XML_ReadNode_GetVal_AsFloat. No data, seems file is corrupt."); if (!mXmlParser->read()) throw DeadlyImportError("XML_ReadNode_GetVal_AsFloat. No data, seems file is corrupt.");
if (mReader->getNodeType() != irr::io::EXN_TEXT) throw DeadlyImportError("XML_ReadNode_GetVal_AsFloat. Invalid type of XML element, seems file is corrupt."); if (mXmlParser->getNodeType() != irr::io::EXN_TEXT) throw DeadlyImportError("XML_ReadNode_GetVal_AsFloat. Invalid type of XML element, seems file is corrupt.");
ParseHelper_FixTruncatedFloatString(mReader->getNodeData(), val); ParseHelper_FixTruncatedFloatString(mXmlParser->getNodeData(), val);
fast_atoreal_move(val.c_str(), tvalf, false); fast_atoreal_move(val.c_str(), tvalf, false);
return tvalf; return tvalf;
} }
uint32_t AMFImporter::XML_ReadNode_GetVal_AsU32() { uint32_t AMFImporter::XML_ReadNode_GetVal_AsU32() {
if (!mReader->read()) throw DeadlyImportError("XML_ReadNode_GetVal_AsU32. No data, seems file is corrupt."); if (!mXmlParser->read()) throw DeadlyImportError("XML_ReadNode_GetVal_AsU32. No data, seems file is corrupt.");
if (mReader->getNodeType() != irr::io::EXN_TEXT) throw DeadlyImportError("XML_ReadNode_GetVal_AsU32. Invalid type of XML element, seems file is corrupt."); if (mXmlParser->getNodeType() != irr::io::EXN_TEXT) throw DeadlyImportError("XML_ReadNode_GetVal_AsU32. Invalid type of XML element, seems file is corrupt.");
return strtoul10(mReader->getNodeData()); return strtoul10(mXmlParser->getNodeData());
} }
void AMFImporter::XML_ReadNode_GetVal_AsString(std::string &pValue) { void AMFImporter::XML_ReadNode_GetVal_AsString(std::string &pValue) {
if (!mReader->read()) throw DeadlyImportError("XML_ReadNode_GetVal_AsString. No data, seems file is corrupt."); if (!mXmlParser->read()) throw DeadlyImportError("XML_ReadNode_GetVal_AsString. No data, seems file is corrupt.");
if (mReader->getNodeType() != irr::io::EXN_TEXT) if (mXmlParser->getNodeType() != irr::io::EXN_TEXT)
throw DeadlyImportError("XML_ReadNode_GetVal_AsString. Invalid type of XML element, seems file is corrupt."); throw DeadlyImportError("XML_ReadNode_GetVal_AsString. Invalid type of XML element, seems file is corrupt.");
pValue = mReader->getNodeData(); pValue = mXmlParser->getNodeData();
} }
/*********************************************************************************************************************************************/ /*********************************************************************************************************************************************/
@ -383,8 +385,8 @@ void AMFImporter::ParseFile(const std::string &pFile, IOSystem *pIOHandler) {
throw DeadlyImportError("Failed to open AMF file " + pFile + "."); throw DeadlyImportError("Failed to open AMF file " + pFile + ".");
} }
mReader = new XmlParser; mXmlParser = new XmlParser;
XmlNode *root = mReader->parse(file.get()); XmlNode *root = mXmlParser->parse(file.get());
if (nullptr == root) { if (nullptr == root) {
throw DeadlyImportError("Failed to create XML reader for file" + pFile + "."); throw DeadlyImportError("Failed to create XML reader for file" + pFile + ".");
} }
@ -398,8 +400,8 @@ void AMFImporter::ParseFile(const std::string &pFile, IOSystem *pIOHandler) {
ParseNode_Root(root); ParseNode_Root(root);
delete mReader; delete mXmlParser;
mReader = nullptr; mXmlParser = nullptr;
} }
// <amf // <amf
@ -502,7 +504,7 @@ void AMFImporter::ParseNode_Constellation() {
// Read attributes for node <constellation>. // Read attributes for node <constellation>.
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECK_RET("id", id, mReader->getAttributeValue); MACRO_ATTRREAD_CHECK_RET("id", id, mXmlParser->getAttributeValue);
MACRO_ATTRREAD_LOOPEND; MACRO_ATTRREAD_LOOPEND;
// create and if needed - define new grouping object. // create and if needed - define new grouping object.
@ -512,7 +514,7 @@ void AMFImporter::ParseNode_Constellation() {
if (!id.empty()) als.ID = id; if (!id.empty()) als.ID = id;
// Check for child nodes // Check for child nodes
if (!mReader->isEmptyElement()) { if (!mXmlParser->isEmptyElement()) {
ParseHelper_Node_Enter(ne); ParseHelper_Node_Enter(ne);
MACRO_NODECHECK_LOOPBEGIN("constellation"); MACRO_NODECHECK_LOOPBEGIN("constellation");
if (XML_CheckNode_NameEqual("instance")) { if (XML_CheckNode_NameEqual("instance")) {
@ -546,7 +548,7 @@ void AMFImporter::ParseNode_Instance() {
// Read attributes for node <constellation>. // Read attributes for node <constellation>.
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECK_RET("objectid", objectid, mReader->getAttributeValue); MACRO_ATTRREAD_CHECK_RET("objectid", objectid, mXmlParser->getAttributeValue);
MACRO_ATTRREAD_LOOPEND; MACRO_ATTRREAD_LOOPEND;
// used object id must be defined, check that. // used object id must be defined, check that.
@ -558,7 +560,7 @@ void AMFImporter::ParseNode_Instance() {
als.ObjectID = objectid; als.ObjectID = objectid;
// Check for child nodes // Check for child nodes
if (!mReader->isEmptyElement()) { if (!mXmlParser->isEmptyElement()) {
bool read_flag[6] = { false, false, false, false, false, false }; bool read_flag[6] = { false, false, false, false, false, false };
als.Delta.Set(0, 0, 0); als.Delta.Set(0, 0, 0);
@ -625,7 +627,7 @@ void AMFImporter::ParseNode_Object(XmlNode *nodeInst) {
ParseNode_Metadata(*it); ParseNode_Metadata(*it);
} }
} }
if (!mReader->isEmptyElement()) { if (!mXmlParser->isEmptyElement()) {
bool col_read = false; bool col_read = false;
ParseHelper_Node_Enter(ne); ParseHelper_Node_Enter(ne);
@ -682,10 +684,10 @@ void AMFImporter::ParseNode_Metadata() {
// read attribute // read attribute
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECK_RET("type", type, mReader->getAttributeValue); MACRO_ATTRREAD_CHECK_RET("type", type, mXmlParser->getAttributeValue);
MACRO_ATTRREAD_LOOPEND; MACRO_ATTRREAD_LOOPEND;
// and value of node. // and value of node.
value = mReader->getNodeData(); value = mXmlParser->getNodeData();
// Create node element and assign read data. // Create node element and assign read data.
ne = new CAMFImporter_NodeElement_Metadata(mNodeElement_Cur); ne = new CAMFImporter_NodeElement_Metadata(mNodeElement_Cur);
((CAMFImporter_NodeElement_Metadata *)ne)->Type = type; ((CAMFImporter_NodeElement_Metadata *)ne)->Type = type;

38
code/AMF/AMFImporter.hpp
View File

@ -63,8 +63,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
namespace Assimp { namespace Assimp {
class XmlNode;
/// \class AMFImporter /// \class AMFImporter
/// Class that holding scene graph which include: geometry, metadata, materials etc. /// Class that holding scene graph which include: geometry, metadata, materials etc.
/// ///
@ -280,7 +278,7 @@ private:
void Throw_ID_NotFound(const std::string& pID) const; void Throw_ID_NotFound(const std::string& pID) const;
/// Check if current node have children: <node>...</node>. If not then exception will thrown. /// Check if current node have children: <node>...</node>. If not then exception will thrown.
void XML_CheckNode_MustHaveChildren(XmlNode *node); void XML_CheckNode_MustHaveChildren( XmlNode &node);
/// Check if current node name is equal to pNodeName. /// Check if current node name is equal to pNodeName.
/// \param [in] pNodeName - name for checking. /// \param [in] pNodeName - name for checking.
@ -345,49 +343,49 @@ private:
void ParseHelper_Decode_Base64(const std::string& pInputBase64, std::vector<uint8_t>& pOutputData) const; void ParseHelper_Decode_Base64(const std::string& pInputBase64, std::vector<uint8_t>& pOutputData) const;
/// Parse <AMF> node of the file. /// Parse <AMF> node of the file.
void ParseNode_Root(XmlNode *root); void ParseNode_Root(XmlNode &root);
/// Parse <constellation> node of the file. /// Parse <constellation> node of the file.
void ParseNode_Constellation(XmlNode *node); void ParseNode_Constellation(XmlNode &node);
/// Parse <instance> node of the file. /// Parse <instance> node of the file.
void ParseNode_Instance(XmlNode *node); void ParseNode_Instance(XmlNode &node);
/// Parse <material> node of the file. /// Parse <material> node of the file.
void ParseNode_Material(XmlNode *node); void ParseNode_Material(XmlNode &node);
/// Parse <metadata> node. /// Parse <metadata> node.
void ParseNode_Metadata(XmlNode *node); void ParseNode_Metadata(XmlNode &node);
/// Parse <object> node of the file. /// Parse <object> node of the file.
void ParseNode_Object(XmlNode *node); void ParseNode_Object(XmlNode &node);
/// Parse <texture> node of the file. /// Parse <texture> node of the file.
void ParseNode_Texture(XmlNode *node); void ParseNode_Texture(XmlNode &node);
/// Parse <coordinates> node of the file. /// Parse <coordinates> node of the file.
void ParseNode_Coordinates(XmlNode *node); void ParseNode_Coordinates(XmlNode &node);
/// Parse <edge> node of the file. /// Parse <edge> node of the file.
void ParseNode_Edge(XmlNode *node); void ParseNode_Edge(XmlNode &node);
/// Parse <mesh> node of the file. /// Parse <mesh> node of the file.
void ParseNode_Mesh(XmlNode *node); void ParseNode_Mesh(XmlNode &node);
/// Parse <triangle> node of the file. /// Parse <triangle> node of the file.
void ParseNode_Triangle(XmlNode *node); void ParseNode_Triangle(XmlNode &node);
/// Parse <vertex> node of the file. /// Parse <vertex> node of the file.
void ParseNode_Vertex(XmlNode *node); void ParseNode_Vertex(XmlNode &node);
/// Parse <vertices> node of the file. /// Parse <vertices> node of the file.
void ParseNode_Vertices(XmlNode *node); void ParseNode_Vertices(XmlNode &node);
/// Parse <volume> node of the file. /// Parse <volume> node of the file.
void ParseNode_Volume(XmlNode *node); void ParseNode_Volume(XmlNode &node);
/// Parse <color> node of the file. /// Parse <color> node of the file.
void ParseNode_Color(XmlNode *node); void ParseNode_Color(XmlNode &node);
/// Parse <texmap> of <map> node of the file. /// Parse <texmap> of <map> node of the file.
/// \param [in] pUseOldName - if true then use old name of node(and children) - <map>, instead of new name - <texmap>. /// \param [in] pUseOldName - if true then use old name of node(and children) - <map>, instead of new name - <texmap>.
@ -397,7 +395,7 @@ public:
/// Default constructor. /// Default constructor.
AMFImporter() AI_NO_EXCEPT AMFImporter() AI_NO_EXCEPT
: mNodeElement_Cur(nullptr) : mNodeElement_Cur(nullptr)
, mReader(nullptr) { , mXmlParser(nullptr) {
// empty // empty
} }
@ -423,7 +421,7 @@ private:
CAMFImporter_NodeElement* mNodeElement_Cur;///< Current element. CAMFImporter_NodeElement* mNodeElement_Cur;///< Current element.
std::list<CAMFImporter_NodeElement*> mNodeElement_List;///< All elements of scene graph. std::list<CAMFImporter_NodeElement*> mNodeElement_List;///< All elements of scene graph.
XmlParser *mReader; XmlParser *mXmlParser;
//irr::io::IrrXMLReader* mReader;///< Pointer to XML-reader object //irr::io::IrrXMLReader* mReader;///< Pointer to XML-reader object
std::string mUnit; std::string mUnit;
std::list<SPP_Material> mMaterial_Converted;///< List of converted materials for postprocessing step. std::list<SPP_Material> mMaterial_Converted;///< List of converted materials for postprocessing step.

16
code/AMF/AMFImporter_Geometry.cpp
View File

@ -66,7 +66,7 @@ void AMFImporter::ParseNode_Mesh()
// create new mesh object. // create new mesh object.
ne = new CAMFImporter_NodeElement_Mesh(mNodeElement_Cur); ne = new CAMFImporter_NodeElement_Mesh(mNodeElement_Cur);
// Check for child nodes // Check for child nodes
if(!mReader->isEmptyElement()) if(!mXmlParser->isEmptyElement())
{ {
bool vert_read = false; bool vert_read = false;
@ -107,7 +107,7 @@ CAMFImporter_NodeElement* ne;
// create new mesh object. // create new mesh object.
ne = new CAMFImporter_NodeElement_Vertices(mNodeElement_Cur); ne = new CAMFImporter_NodeElement_Vertices(mNodeElement_Cur);
// Check for child nodes // Check for child nodes
if(!mReader->isEmptyElement()) if(!mXmlParser->isEmptyElement())
{ {
ParseHelper_Node_Enter(ne); ParseHelper_Node_Enter(ne);
MACRO_NODECHECK_LOOPBEGIN("vertices"); MACRO_NODECHECK_LOOPBEGIN("vertices");
@ -135,7 +135,7 @@ CAMFImporter_NodeElement* ne;
// create new mesh object. // create new mesh object.
ne = new CAMFImporter_NodeElement_Vertex(mNodeElement_Cur); ne = new CAMFImporter_NodeElement_Vertex(mNodeElement_Cur);
// Check for child nodes // Check for child nodes
if(!mReader->isEmptyElement()) if(!mXmlParser->isEmptyElement())
{ {
bool col_read = false; bool col_read = false;
bool coord_read = false; bool coord_read = false;
@ -196,7 +196,7 @@ CAMFImporter_NodeElement* ne;
CAMFImporter_NodeElement_Coordinates& als = *((CAMFImporter_NodeElement_Coordinates*)ne);// alias for convenience CAMFImporter_NodeElement_Coordinates& als = *((CAMFImporter_NodeElement_Coordinates*)ne);// alias for convenience
// Check for child nodes // Check for child nodes
if(!mReader->isEmptyElement()) if(!mXmlParser->isEmptyElement())
{ {
bool read_flag[3] = { false, false, false }; bool read_flag[3] = { false, false, false };
@ -236,8 +236,8 @@ CAMFImporter_NodeElement* ne;
// Read attributes for node <color>. // Read attributes for node <color>.
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECK_RET("materialid", materialid, mReader->getAttributeValue); MACRO_ATTRREAD_CHECK_RET("materialid", materialid, mXmlParser->getAttributeValue);
MACRO_ATTRREAD_CHECK_RET("type", type, mReader->getAttributeValue); MACRO_ATTRREAD_CHECK_RET("type", type, mXmlParser->getAttributeValue);
MACRO_ATTRREAD_LOOPEND; MACRO_ATTRREAD_LOOPEND;
// create new object. // create new object.
@ -246,7 +246,7 @@ CAMFImporter_NodeElement* ne;
((CAMFImporter_NodeElement_Volume*)ne)->MaterialID = materialid; ((CAMFImporter_NodeElement_Volume*)ne)->MaterialID = materialid;
((CAMFImporter_NodeElement_Volume*)ne)->Type = type; ((CAMFImporter_NodeElement_Volume*)ne)->Type = type;
// Check for child nodes // Check for child nodes
if(!mReader->isEmptyElement()) if(!mXmlParser->isEmptyElement())
{ {
bool col_read = false; bool col_read = false;
@ -296,7 +296,7 @@ CAMFImporter_NodeElement* ne;
CAMFImporter_NodeElement_Triangle& als = *((CAMFImporter_NodeElement_Triangle*)ne);// alias for convenience CAMFImporter_NodeElement_Triangle& als = *((CAMFImporter_NodeElement_Triangle*)ne);// alias for convenience
// Check for child nodes // Check for child nodes
if(!mReader->isEmptyElement()) if(!mXmlParser->isEmptyElement())
{ {
bool col_read = false, tex_read = false; bool col_read = false, tex_read = false;
bool read_flag[3] = { false, false, false }; bool read_flag[3] = { false, false, false };

44
code/AMF/AMFImporter_Material.cpp
View File

@ -74,7 +74,7 @@ void AMFImporter::ParseNode_Color() {
// Read attributes for node <color>. // Read attributes for node <color>.
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECK_RET("profile", profile, mReader->getAttributeValue); MACRO_ATTRREAD_CHECK_RET("profile", profile, mXmlParser->getAttributeValue);
MACRO_ATTRREAD_LOOPEND; MACRO_ATTRREAD_LOOPEND;
// create new color object. // create new color object.
@ -84,7 +84,7 @@ void AMFImporter::ParseNode_Color() {
als.Profile = profile; als.Profile = profile;
// Check for child nodes // Check for child nodes
if(!mReader->isEmptyElement()) if(!mXmlParser->isEmptyElement())
{ {
bool read_flag[4] = { false, false, false, false }; bool read_flag[4] = { false, false, false, false };
@ -128,7 +128,7 @@ void AMFImporter::ParseNode_Material() {
// Read attributes for node <color>. // Read attributes for node <color>.
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECK_RET("id", id, mReader->getAttributeValue); MACRO_ATTRREAD_CHECK_RET("id", id, mXmlParser->getAttributeValue);
MACRO_ATTRREAD_LOOPEND; MACRO_ATTRREAD_LOOPEND;
// create new object. // create new object.
@ -138,7 +138,7 @@ void AMFImporter::ParseNode_Material() {
((CAMFImporter_NodeElement_Material*)ne)->ID = id; ((CAMFImporter_NodeElement_Material*)ne)->ID = id;
// Check for child nodes // Check for child nodes
if(!mReader->isEmptyElement()) if(!mXmlParser->isEmptyElement())
{ {
bool col_read = false; bool col_read = false;
@ -183,25 +183,13 @@ void AMFImporter::ParseNode_Material() {
// then layer by layer. // then layer by layer.
// Multi elements - Yes. // Multi elements - Yes.
// Parent element - <amf>. // Parent element - <amf>.
void AMFImporter::ParseNode_Texture() void AMFImporter::ParseNode_Texture(XmlNode &node) {
{ std::string id = node.attribute("id").as_string();
std::string id; uint32_t width = node.attribute("width").as_uint();
uint32_t width = 0; uint32_t height = node.attribute("height").as_uint();
uint32_t height = 0; uint32_t depth = node.attribute("depth").as_uint();
uint32_t depth = 1; std::string type = node.attribute("type").as_string();
std::string type; bool tiled = node.attribute("tiled").as_bool();
bool tiled = false;
std::string enc64_data;
// Read attributes for node <color>.
MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECK_RET("id", id, mReader->getAttributeValue);
MACRO_ATTRREAD_CHECK_RET("width", width, XML_ReadNode_GetAttrVal_AsU32);
MACRO_ATTRREAD_CHECK_RET("height", height, XML_ReadNode_GetAttrVal_AsU32);
MACRO_ATTRREAD_CHECK_RET("depth", depth, XML_ReadNode_GetAttrVal_AsU32);
MACRO_ATTRREAD_CHECK_RET("type", type, mReader->getAttributeValue);
MACRO_ATTRREAD_CHECK_RET("tiled", tiled, XML_ReadNode_GetAttrVal_AsBool);
MACRO_ATTRREAD_LOOPEND;
// create new texture object. // create new texture object.
CAMFImporter_NodeElement *ne = new CAMFImporter_NodeElement_Texture(mNodeElement_Cur); CAMFImporter_NodeElement *ne = new CAMFImporter_NodeElement_Texture(mNodeElement_Cur);
@ -209,7 +197,7 @@ void AMFImporter::ParseNode_Texture()
CAMFImporter_NodeElement_Texture& als = *((CAMFImporter_NodeElement_Texture*)ne);// alias for convenience CAMFImporter_NodeElement_Texture& als = *((CAMFImporter_NodeElement_Texture*)ne);// alias for convenience
// Check for child nodes // Check for child nodes
if (!mReader->isEmptyElement()) { if (!mXmlParser->isEmptyElement()) {
XML_ReadNode_GetVal_AsString(enc64_data); XML_ReadNode_GetVal_AsString(enc64_data);
} }
@ -268,10 +256,10 @@ void AMFImporter::ParseNode_TexMap(const bool pUseOldName) {
// Read attributes for node <color>. // Read attributes for node <color>.
MACRO_ATTRREAD_LOOPBEG; MACRO_ATTRREAD_LOOPBEG;
MACRO_ATTRREAD_CHECK_RET("rtexid", rtexid, mReader->getAttributeValue); MACRO_ATTRREAD_CHECK_RET("rtexid", rtexid, mXmlParser->getAttributeValue);
MACRO_ATTRREAD_CHECK_RET("gtexid", gtexid, mReader->getAttributeValue); MACRO_ATTRREAD_CHECK_RET("gtexid", gtexid, mXmlParser->getAttributeValue);
MACRO_ATTRREAD_CHECK_RET("btexid", btexid, mReader->getAttributeValue); MACRO_ATTRREAD_CHECK_RET("btexid", btexid, mXmlParser->getAttributeValue);
MACRO_ATTRREAD_CHECK_RET("atexid", atexid, mReader->getAttributeValue); MACRO_ATTRREAD_CHECK_RET("atexid", atexid, mXmlParser->getAttributeValue);
MACRO_ATTRREAD_LOOPEND; MACRO_ATTRREAD_LOOPEND;
// create new texture coordinates object. // create new texture coordinates object.

27
code/Collada/ColladaParser.cpp
View File

@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2020, assimp team Copyright (c) 2006-2020, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -68,11 +66,8 @@ using namespace Assimp::Formatter;
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer // Constructor to be privately used by Importer
ColladaParser::ColladaParser(IOSystem* pIOHandler, const std::string& pFile) ColladaParser::ColladaParser(IOSystem* pIOHandler, const std::string& pFile) :
: mFileName(pFile) mFileName(pFile), mXmlParser(nullptr), mDataLibrary(), mAccessorLibrary()
, mReader(nullptr)
, mDataLibrary()
, mAccessorLibrary()
, mMeshLibrary() , mMeshLibrary()
, mNodeLibrary() , mNodeLibrary()
, mImageLibrary() , mImageLibrary()
@ -1532,7 +1527,7 @@ void ColladaParser::ReadLight(Collada::Light& pLight)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Reads a camera entry into the given light // Reads a camera entry into the given light
void ColladaParser::ReadCamera(Collada::Camera& pCamera) void ColladaParser::ReadCamera(Collada::Camera& camera)
{ {
while (mReader->read()) while (mReader->read())
{ {
@ -1541,26 +1536,26 @@ void ColladaParser::ReadCamera(Collada::Camera& pCamera)
SkipElement(); SkipElement();
} }
else if (IsElement("orthographic")) { else if (IsElement("orthographic")) {
pCamera.mOrtho = true; camera.mOrtho = true;
} }
else if (IsElement("xfov") || IsElement("xmag")) { else if (IsElement("xfov") || IsElement("xmag")) {
pCamera.mHorFov = ReadFloatFromTextContent(); camera.mHorFov = ReadFloatFromTextContent();
TestClosing((pCamera.mOrtho ? "xmag" : "xfov")); TestClosing((camera.mOrtho ? "xmag" : "xfov"));
} }
else if (IsElement("yfov") || IsElement("ymag")) { else if (IsElement("yfov") || IsElement("ymag")) {
pCamera.mVerFov = ReadFloatFromTextContent(); camera.mVerFov = ReadFloatFromTextContent();
TestClosing((pCamera.mOrtho ? "ymag" : "yfov")); TestClosing((camera.mOrtho ? "ymag" : "yfov"));
} }
else if (IsElement("aspect_ratio")) { else if (IsElement("aspect_ratio")) {
pCamera.mAspect = ReadFloatFromTextContent(); camera.mAspect = ReadFloatFromTextContent();
TestClosing("aspect_ratio"); TestClosing("aspect_ratio");
} }
else if (IsElement("znear")) { else if (IsElement("znear")) {
pCamera.mZNear = ReadFloatFromTextContent(); camera.mZNear = ReadFloatFromTextContent();
TestClosing("znear"); TestClosing("znear");
} }
else if (IsElement("zfar")) { else if (IsElement("zfar")) {
pCamera.mZFar = ReadFloatFromTextContent(); camera.mZFar = ReadFloatFromTextContent();
TestClosing("zfar"); TestClosing("zfar");
} }
} }

42
code/Collada/ColladaParser.h
View File

@ -4,7 +4,6 @@
Copyright (c) 2006-2020, assimp team Copyright (c) 2006-2020, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -55,6 +54,7 @@
namespace Assimp namespace Assimp
{ {
class ZipArchiveIOSystem; class ZipArchiveIOSystem;
class XmlParser;
// ------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------
/** Parser helper class for the Collada loader. /** Parser helper class for the Collada loader.
@ -112,7 +112,7 @@ namespace Assimp
/** Reads an animation into the given parent structure */ /** Reads an animation into the given parent structure */
void ReadAnimation( Collada::Animation* pParent); void ReadAnimation( Collada::Animation* pParent);
/** Reads an animation sampler into the given anim channel */ /** Reads an animation sampler into the given animation channel */
void ReadAnimationSampler( Collada::AnimationChannel& pChannel); void ReadAnimationSampler( Collada::AnimationChannel& pChannel);
/** Reads the skeleton controller library */ /** Reads the skeleton controller library */
@ -157,16 +157,16 @@ namespace Assimp
/** Reads an effect entry into the given effect*/ /** Reads an effect entry into the given effect*/
void ReadEffect( Collada::Effect& pEffect); void ReadEffect( Collada::Effect& pEffect);
/** Reads an COMMON effect profile */ /// Reads an COMMON effect profile
void ReadEffectProfileCommon( Collada::Effect& pEffect); void ReadEffectProfileCommon( Collada::Effect& pEffect);
/** Read sampler properties */ /// Read sampler properties
void ReadSamplerProperties( Collada::Sampler& pSampler); void ReadSamplerProperties( Collada::Sampler& pSampler);
/** Reads an effect entry containing a color or a texture defining that color */ /// Reads an effect entry containing a color or a texture defining that color
void ReadEffectColor( aiColor4D& pColor, Collada::Sampler& pSampler); void ReadEffectColor( aiColor4D& pColor, Collada::Sampler& pSampler);
/** Reads an effect entry containing a float */ /// Reads an effect entry containing a float
void ReadEffectFloat( ai_real& pFloat); void ReadEffectFloat( ai_real& pFloat);
/** Reads an effect parameter specification of any kind */ /** Reads an effect parameter specification of any kind */
@ -182,7 +182,7 @@ namespace Assimp
void ReadMesh( Collada::Mesh* pMesh); void ReadMesh( Collada::Mesh* pMesh);
/** Reads a source element - a combination of raw data and an accessor defining /** Reads a source element - a combination of raw data and an accessor defining
* things that should not be redefinable. Yes, that's another rant. * things that should not be re-definable. Yes, that's another rant.
*/ */
void ReadSource(); void ReadSource();
@ -214,7 +214,7 @@ namespace Assimp
Collada::Mesh* pMesh, std::vector<Collada::InputChannel>& pPerIndexChannels, Collada::Mesh* pMesh, std::vector<Collada::InputChannel>& pPerIndexChannels,
size_t currentPrimitive, const std::vector<size_t>& indices); size_t currentPrimitive, const std::vector<size_t>& indices);
/** Reads one triangle of a tristrip into the mesh */ /** Reads one triangle of a triangle-strip into the mesh */
void ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Collada::Mesh* pMesh, void ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Collada::Mesh* pMesh,
std::vector<Collada::InputChannel>& pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t>& indices); std::vector<Collada::InputChannel>& pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t>& indices);
@ -298,7 +298,8 @@ namespace Assimp
std::string mFileName; std::string mFileName;
/** XML reader, member for everyday use */ /** XML reader, member for everyday use */
irr::io::IrrXMLReader* mReader; //irr::io::IrrXMLReader* mReader;
XmlParser *mXmlParser;
/** All data arrays found in the file by ID. Might be referred to by actually /** All data arrays found in the file by ID. Might be referred to by actually
everyone. Collada, you are a steaming pile of indirection. */ everyone. Collada, you are a steaming pile of indirection. */
@ -359,19 +360,24 @@ namespace Assimp
/** Size unit: how large compared to a meter */ /** Size unit: how large compared to a meter */
ai_real mUnitSize; ai_real mUnitSize;
/** Which is the up vector */ /// Which is the up vector.
enum { UP_X, UP_Y, UP_Z } mUpDirection; enum {
UP_X,
UP_Y,
UP_Z
} mUpDirection;
/** Asset metadata (global for scene) */ /// Asset metadata (global for scene)
StringMetaData mAssetMetaData; StringMetaData mAssetMetaData;
/** Collada file format version */ /// Collada file format version
Collada::FormatVersion mFormat; Collada::FormatVersion mFormat;
}; };
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Check for element match // Check for element match
inline bool ColladaParser::IsElement( const char* pName) const inline
bool ColladaParser::IsElement( const char* pName) const
{ {
ai_assert( mReader->getNodeType() == irr::io::EXN_ELEMENT); ai_assert( mReader->getNodeType() == irr::io::EXN_ELEMENT);
return ::strcmp( mReader->getNodeName(), pName) == 0; return ::strcmp( mReader->getNodeName(), pName) == 0;
@ -380,11 +386,11 @@ namespace Assimp
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Finds the item in the given library by its reference, throws if not found // Finds the item in the given library by its reference, throws if not found
template <typename Type> template <typename Type>
const Type& ColladaParser::ResolveLibraryReference( const std::map<std::string, Type>& pLibrary, const std::string& pURL) const const Type& ColladaParser::ResolveLibraryReference( const std::map<std::string, Type>& library, const std::string& url) const
{ {
typename std::map<std::string, Type>::const_iterator it = pLibrary.find( pURL); typename std::map<std::string, Type>::const_iterator it = library.find( url);
if( it == pLibrary.end()) if( it == library.end())
ThrowException( Formatter::format() << "Unable to resolve library reference \"" << pURL << "\"." ); ThrowException( Formatter::format() << "Unable to resolve library reference \"" << url << "\"." );
return it->second; return it->second;
} }

33
code/Irr/IRRLoader.h
View File

@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2020, assimp team Copyright (c) 2006-2020, assimp team
All rights reserved. All rights reserved.
Redistribution and use of this software in source and binary forms, Redistribution and use of this software in source and binary forms,
@ -40,7 +39,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------- ----------------------------------------------------------------------
*/ */
/** @file IRRLoader.h /** @file IRRLoader.h
* @brief Declaration of the .irrMesh (Irrlight Engine Mesh Format) * @brief Declaration of the .irrMesh (Irrlight Engine Mesh Format)
* importer class. * importer class.
@ -83,7 +81,7 @@ protected:
private: private:
/** Data structure for a scenegraph node animator /** Data structure for a scene-graph node animator
*/ */
struct Animator { struct Animator {
// Type of the animator // Type of the animator
@ -129,7 +127,7 @@ private:
int timeForWay; int timeForWay;
}; };
/** Data structure for a scenegraph node in an IRR file /** Data structure for a scene-graph node in an IRR file
*/ */
struct Node struct Node
{ {
@ -227,8 +225,7 @@ private:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Fill the scenegraph recursively /// Fill the scene-graph recursively
*/
void GenerateGraph(Node* root,aiNode* rootOut ,aiScene* scene, void GenerateGraph(Node* root,aiNode* rootOut ,aiScene* scene,
BatchLoader& batch, BatchLoader& batch,
std::vector<aiMesh*>& meshes, std::vector<aiMesh*>& meshes,
@ -237,27 +234,22 @@ private:
std::vector<aiMaterial*>& materials, std::vector<aiMaterial*>& materials,
unsigned int& defaultMatIdx); unsigned int& defaultMatIdx);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Generate a mesh that consists of just a single quad /// Generate a mesh that consists of just a single quad
*/
aiMesh* BuildSingleQuadMesh(const SkyboxVertex& v1, aiMesh* BuildSingleQuadMesh(const SkyboxVertex& v1,
const SkyboxVertex& v2, const SkyboxVertex& v2,
const SkyboxVertex& v3, const SkyboxVertex& v3,
const SkyboxVertex& v4); const SkyboxVertex& v4);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Build a skybox /// Build a sky-box
* ///
* @param meshes Receives 6 output meshes /// @param meshes Receives 6 output meshes
* @param materials The last 6 materials are assigned to the newly /// @param materials The last 6 materials are assigned to the newly
* created meshes. The names of the materials are adjusted. /// created meshes. The names of the materials are adjusted.
*/
void BuildSkybox(std::vector<aiMesh*>& meshes, void BuildSkybox(std::vector<aiMesh*>& meshes,
std::vector<aiMaterial*> materials); std::vector<aiMaterial*> materials);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Copy a material for a mesh to the output material list /** Copy a material for a mesh to the output material list
* *
@ -271,7 +263,6 @@ private:
unsigned int& defMatIdx, unsigned int& defMatIdx,
aiMesh* mesh); aiMesh* mesh);
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Compute animations for a specific node /** Compute animations for a specific node
* *
@ -281,13 +272,11 @@ private:
void ComputeAnimations(Node* root, aiNode* real, void ComputeAnimations(Node* root, aiNode* real,
std::vector<aiNodeAnim*>& anims); std::vector<aiNodeAnim*>& anims);
private: private:
/// Configuration option: desired output FPS
/** Configuration option: desired output FPS */
double fps; double fps;
/** Configuration option: speed flag was set? */ /// Configuration option: speed flag was set?
bool configSpeedFlag; bool configSpeedFlag;
}; };

83
code/X3D/X3DExporter.cpp
View File

@ -14,23 +14,14 @@
#include <assimp/Exporter.hpp> #include <assimp/Exporter.hpp>
#include <assimp/IOSystem.hpp> #include <assimp/IOSystem.hpp>
using namespace std; namespace Assimp {
namespace Assimp void ExportSceneX3D(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties) {
{
void ExportSceneX3D(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
{
X3DExporter exporter(pFile, pIOSystem, pScene, pProperties); X3DExporter exporter(pFile, pIOSystem, pScene, pProperties);
} }
}// namespace Assimp
namespace Assimp void X3DExporter::IndentationStringSet(const size_t pNewLevel) {
{
void X3DExporter::IndentationStringSet(const size_t pNewLevel)
{
if(pNewLevel > mIndentationString.size()) if(pNewLevel > mIndentationString.size())
{ {
if(pNewLevel > mIndentationString.capacity()) mIndentationString.reserve(pNewLevel + 1); if(pNewLevel > mIndentationString.capacity()) mIndentationString.reserve(pNewLevel + 1);
@ -43,31 +34,33 @@ void X3DExporter::IndentationStringSet(const size_t pNewLevel)
} }
} }
void X3DExporter::XML_Write(const string& pData) void X3DExporter::XML_Write(const std::string& pData) {
{ if (pData.empty() ) {
if(pData.size() == 0) return; return;
if(mOutFile->Write((void*)pData.data(), pData.length(), 1) != 1) throw DeadlyExportError("Failed to write scene data!"); }
if (mOutFile->Write((void *)pData.data(), pData.length(), 1) != 1) {
throw DeadlyExportError("Failed to write scene data!");
}
} }
aiMatrix4x4 X3DExporter::Matrix_GlobalToCurrent(const aiNode& pNode) const aiMatrix4x4 X3DExporter::Matrix_GlobalToCurrent(const aiNode& pNode) const {
{ aiNode *cur_node;
aiNode* cur_node; std::list<aiMatrix4x4> matr;
std::list<aiMatrix4x4> matr; aiMatrix4x4 out_matr;
aiMatrix4x4 out_matr;
// starting walk from current element to root // starting walk from current element to root
matr.push_back(pNode.mTransformation); matr.push_back(pNode.mTransformation);
cur_node = pNode.mParent; cur_node = pNode.mParent;
if(cur_node != nullptr) if(cur_node != nullptr)
{ {
do do {
{
matr.push_back(cur_node->mTransformation); matr.push_back(cur_node->mTransformation);
cur_node = cur_node->mParent; cur_node = cur_node->mParent;
} while(cur_node != nullptr); } while(cur_node != nullptr);
} }
// multiplicate all matrices in reverse order // Multiplication of all matrices in reverse order
for(std::list<aiMatrix4x4>::reverse_iterator rit = matr.rbegin(); rit != matr.rend(); ++rit) out_matr = out_matr * (*rit); for(std::list<aiMatrix4x4>::reverse_iterator rit = matr.rbegin(); rit != matr.rend(); ++rit) out_matr = out_matr * (*rit);
return out_matr; return out_matr;
@ -142,7 +135,7 @@ void X3DExporter::AttrHelper_Col3DArrToString(const aiColor3D* pArray, const siz
void X3DExporter::AttrHelper_Color3ToAttrList(std::list<SAttribute>& pList, const std::string& pName, const aiColor3D& pValue, const aiColor3D& pDefaultValue) void X3DExporter::AttrHelper_Color3ToAttrList(std::list<SAttribute>& pList, const std::string& pName, const aiColor3D& pValue, const aiColor3D& pDefaultValue)
{ {
string tstr; string tstr;
if(pValue == pDefaultValue) return; if(pValue == pDefaultValue) return;
@ -152,7 +145,7 @@ string tstr;
void X3DExporter::AttrHelper_FloatToAttrList(std::list<SAttribute>& pList, const string& pName, const float pValue, const float pDefaultValue) void X3DExporter::AttrHelper_FloatToAttrList(std::list<SAttribute>& pList, const string& pName, const float pValue, const float pDefaultValue)
{ {
string tstr; string tstr;
if(pValue == pDefaultValue) return; if(pValue == pDefaultValue) return;
@ -183,7 +176,7 @@ void X3DExporter::NodeHelper_OpenNode(const string& pNodeName, const size_t pTab
void X3DExporter::NodeHelper_OpenNode(const string& pNodeName, const size_t pTabLevel, const bool pEmptyElement) void X3DExporter::NodeHelper_OpenNode(const string& pNodeName, const size_t pTabLevel, const bool pEmptyElement)
{ {
const list<SAttribute> attr_list; const list<SAttribute> attr_list;
NodeHelper_OpenNode(pNodeName, pTabLevel, pEmptyElement, attr_list); NodeHelper_OpenNode(pNodeName, pTabLevel, pEmptyElement, attr_list);
} }
@ -199,8 +192,8 @@ void X3DExporter::NodeHelper_CloseNode(const string& pNodeName, const size_t pTa
void X3DExporter::Export_Node(const aiNode *pNode, const size_t pTabLevel) void X3DExporter::Export_Node(const aiNode *pNode, const size_t pTabLevel)
{ {
bool transform = false; bool transform = false;
list<SAttribute> attr_list; list<SAttribute> attr_list;
// In Assimp lights is stored in next way: light source store in mScene->mLights and in node tree must present aiNode with name same as // In Assimp lights is stored in next way: light source store in mScene->mLights and in node tree must present aiNode with name same as
// light source has. Considering it we must compare every aiNode name with light sources names. Why not to look where ligths is present // light source has. Considering it we must compare every aiNode name with light sources names. Why not to look where ligths is present
@ -303,11 +296,11 @@ list<SAttribute> attr_list;
void X3DExporter::Export_Mesh(const size_t pIdxMesh, const size_t pTabLevel) void X3DExporter::Export_Mesh(const size_t pIdxMesh, const size_t pTabLevel)
{ {
const char* NodeName_IFS = "IndexedFaceSet"; const char* NodeName_IFS = "IndexedFaceSet";
const char* NodeName_Shape = "Shape"; const char* NodeName_Shape = "Shape";
list<SAttribute> attr_list; list<SAttribute> attr_list;
aiMesh& mesh = *mScene->mMeshes[pIdxMesh];// create alias for conveniance. aiMesh& mesh = *mScene->mMeshes[pIdxMesh];// create alias for conveniance.
// Check if mesh already defined early. // Check if mesh already defined early.
if(mDEF_Map_Mesh.find(pIdxMesh) != mDEF_Map_Mesh.end()) if(mDEF_Map_Mesh.find(pIdxMesh) != mDEF_Map_Mesh.end())
@ -407,10 +400,10 @@ aiMesh& mesh = *mScene->mMeshes[pIdxMesh];// create alias for conveniance.
void X3DExporter::Export_Material(const size_t pIdxMaterial, const size_t pTabLevel) void X3DExporter::Export_Material(const size_t pIdxMaterial, const size_t pTabLevel)
{ {
const char* NodeName_A = "Appearance"; const char* NodeName_A = "Appearance";
list<SAttribute> attr_list; list<SAttribute> attr_list;
aiMaterial& material = *mScene->mMaterials[pIdxMaterial];// create alias for conveniance. aiMaterial& material = *mScene->mMaterials[pIdxMaterial];// create alias for conveniance.
// Check if material already defined early. // Check if material already defined early.
if(mDEF_Map_Material.find(pIdxMaterial) != mDEF_Map_Material.end()) if(mDEF_Map_Material.find(pIdxMaterial) != mDEF_Map_Material.end())
@ -564,7 +557,7 @@ aiMaterial& material = *mScene->mMaterials[pIdxMaterial];// create alias for con
void X3DExporter::Export_MetadataBoolean(const aiString& pKey, const bool pValue, const size_t pTabLevel) void X3DExporter::Export_MetadataBoolean(const aiString& pKey, const bool pValue, const size_t pTabLevel)
{ {
list<SAttribute> attr_list; list<SAttribute> attr_list;
attr_list.push_back({"name", pKey.C_Str()}); attr_list.push_back({"name", pKey.C_Str()});
attr_list.push_back({"value", pValue ? "true" : "false"}); attr_list.push_back({"value", pValue ? "true" : "false"});
@ -573,7 +566,7 @@ list<SAttribute> attr_list;
void X3DExporter::Export_MetadataDouble(const aiString& pKey, const double pValue, const size_t pTabLevel) void X3DExporter::Export_MetadataDouble(const aiString& pKey, const double pValue, const size_t pTabLevel)
{ {
list<SAttribute> attr_list; list<SAttribute> attr_list;
attr_list.push_back({"name", pKey.C_Str()}); attr_list.push_back({"name", pKey.C_Str()});
attr_list.push_back({"value", to_string(pValue)}); attr_list.push_back({"value", to_string(pValue)});
@ -582,7 +575,7 @@ list<SAttribute> attr_list;
void X3DExporter::Export_MetadataFloat(const aiString& pKey, const float pValue, const size_t pTabLevel) void X3DExporter::Export_MetadataFloat(const aiString& pKey, const float pValue, const size_t pTabLevel)
{ {
list<SAttribute> attr_list; list<SAttribute> attr_list;
attr_list.push_back({"name", pKey.C_Str()}); attr_list.push_back({"name", pKey.C_Str()});
attr_list.push_back({"value", to_string(pValue)}); attr_list.push_back({"value", to_string(pValue)});
@ -591,7 +584,7 @@ list<SAttribute> attr_list;
void X3DExporter::Export_MetadataInteger(const aiString& pKey, const int32_t pValue, const size_t pTabLevel) void X3DExporter::Export_MetadataInteger(const aiString& pKey, const int32_t pValue, const size_t pTabLevel)
{ {
list<SAttribute> attr_list; list<SAttribute> attr_list;
attr_list.push_back({"name", pKey.C_Str()}); attr_list.push_back({"name", pKey.C_Str()});
attr_list.push_back({"value", to_string(pValue)}); attr_list.push_back({"value", to_string(pValue)});
@ -600,7 +593,7 @@ list<SAttribute> attr_list;
void X3DExporter::Export_MetadataString(const aiString& pKey, const aiString& pValue, const size_t pTabLevel) void X3DExporter::Export_MetadataString(const aiString& pKey, const aiString& pValue, const size_t pTabLevel)
{ {
list<SAttribute> attr_list; list<SAttribute> attr_list;
attr_list.push_back({"name", pKey.C_Str()}); attr_list.push_back({"name", pKey.C_Str()});
attr_list.push_back({"value", pValue.C_Str()}); attr_list.push_back({"value", pValue.C_Str()});
@ -609,7 +602,7 @@ list<SAttribute> attr_list;
bool X3DExporter::CheckAndExport_Light(const aiNode& pNode, const size_t pTabLevel) bool X3DExporter::CheckAndExport_Light(const aiNode& pNode, const size_t pTabLevel)
{ {
list<SAttribute> attr_list; list<SAttribute> attr_list;
auto Vec3ToAttrList = [&](const string& pAttrName, const aiVector3D& pAttrValue, const aiVector3D& pAttrDefaultValue) auto Vec3ToAttrList = [&](const string& pAttrName, const aiVector3D& pAttrValue, const aiVector3D& pAttrDefaultValue)
{ {
@ -622,8 +615,8 @@ auto Vec3ToAttrList = [&](const string& pAttrName, const aiVector3D& pAttrValue,
} }
}; };
size_t idx_light; size_t idx_light;
bool found = false; bool found = false;
// Name of the light source can not be empty. // Name of the light source can not be empty.
if(pNode.mName.length == 0) return false; if(pNode.mName.length == 0) return false;
@ -699,7 +692,7 @@ bool found = false;
X3DExporter::X3DExporter(const char* pFileName, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/) X3DExporter::X3DExporter(const char* pFileName, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
: mScene(pScene) : mScene(pScene)
{ {
list<SAttribute> attr_list; list<SAttribute> attr_list;
mOutFile = pIOSystem->Open(pFileName, "wt"); mOutFile = pIOSystem->Open(pFileName, "wt");
if(mOutFile == nullptr) throw DeadlyExportError("Could not open output .x3d file: " + string(pFileName)); if(mOutFile == nullptr) throw DeadlyExportError("Could not open output .x3d file: " + string(pFileName));

2
code/X3D/X3DExporter.hpp
View File

@ -47,6 +47,8 @@ namespace Assimp
/// ///
class X3DExporter class X3DExporter
{ {
using AttrubuteList = std::list<SAttribute>;
/***********************************************/ /***********************************************/
/******************** Types ********************/ /******************** Types ********************/
/***********************************************/ /***********************************************/

1289
code/XGL/XGLLoader.cpp
View File

File diff suppressed because it is too large Load Diff

46
code/XGL/XGLLoader.h
View File

@ -53,6 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/Importer.hpp> #include <assimp/Importer.hpp>
#include <assimp/mesh.h> #include <assimp/mesh.h>
#include <assimp/light.h> #include <assimp/light.h>
#include <memory> #include <memory>
#include <map> #include <map>
@ -65,16 +66,11 @@ namespace Assimp {
* *
* Spec: http://vizstream.aveva.com/release/vsplatform/XGLSpec.htm * Spec: http://vizstream.aveva.com/release/vsplatform/XGLSpec.htm
*/ */
class XGLImporter : public BaseImporter, public LogFunctions<XGLImporter> class XGLImporter : public BaseImporter, public LogFunctions<XGLImporter> {
{
public: public:
XGLImporter(); XGLImporter();
~XGLImporter(); ~XGLImporter();
public:
// ------------------------------------------------------------------- // -------------------------------------------------------------------
/** Returns whether the class can handle the format of the given file. /** Returns whether the class can handle the format of the given file.
* See BaseImporter::CanRead() for details. */ * See BaseImporter::CanRead() for details. */
@ -95,8 +91,6 @@ protected:
IOSystem* pIOHandler); IOSystem* pIOHandler);
private: private:
struct TempScope struct TempScope
{ {
TempScope() TempScope()
@ -180,34 +174,30 @@ private:
}; };
private: private:
void Cleanup(); void Cleanup();
std::string GetElementName(); unsigned int ReadIDAttr(XmlNode &node);
bool ReadElement();
bool ReadElementUpToClosing(const char* closetag);
bool SkipToText();
unsigned int ReadIDAttr();
void ReadWorld(TempScope& scope); void ReadWorld(TempScope& scope);
void ReadLighting(TempScope& scope); void ReadLighting(XmlNode &node, TempScope &scope);
aiLight* ReadDirectionalLight(); aiLight *ReadDirectionalLight(XmlNode &node);
aiNode* ReadObject(TempScope& scope,bool skipFirst = false,const char* closetag = "object"); aiNode *ReadObject(XmlNode &node, TempScope &scope, bool skipFirst = false, const char *closetag = "object");
bool ReadMesh(TempScope& scope); bool ReadMesh(XmlNode &node, TempScope &scope);
void ReadMaterial(TempScope& scope); void ReadMaterial(XmlNode &node, TempScope &scope);
aiVector2D ReadVec2(); aiVector2D ReadVec2(XmlNode &node );
aiVector3D ReadVec3(); aiVector3D ReadVec3(XmlNode &node );
aiColor3D ReadCol3(); aiColor3D ReadCol3(XmlNode &node );
aiMatrix4x4 ReadTrafo(); aiMatrix4x4 ReadTrafo(XmlNode &node );
unsigned int ReadIndexFromText(); unsigned int ReadIndexFromText(XmlNode &node);
float ReadFloat(); float ReadFloat(XmlNode &node );
aiMesh* ToOutputMesh(const TempMaterialMesh& m); aiMesh* ToOutputMesh(const TempMaterialMesh& m);
void ReadFaceVertex(const TempMesh& t, TempFace& out); void ReadFaceVertex(XmlNode &node, const TempMesh &t, TempFace &out);
unsigned int ResolveMaterialRef(TempScope& scope); unsigned int ResolveMaterialRef(XmlNode &node, TempScope &scope);
private: private:
std::shared_ptr<irr::io::IrrXMLReader> m_reader; //std::shared_ptr<irr::io::IrrXMLReader> m_reader;
XmlParser *m_xmlParser;
aiScene* m_scene; aiScene* m_scene;
}; };

101
include/assimp/XmlParser.h
View File

@ -51,96 +51,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
namespace Assimp { namespace Assimp {
// ---------------------------------------------------------------------------------
/** @brief Utility class to make IrrXML work together with our custom IO system
* See the IrrXML docs for more details.
*
* Construct IrrXML-Reader in BaseImporter::InternReadFile():
* @code
* // open the file
* std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
* if( file.get() == NULL) {
* throw DeadlyImportError( "Failed to open file " + pFile + ".");
* }
*
* // generate a XML reader for it
* std::unique_ptr<CIrrXML_IOStreamReader> mIOWrapper( new CIrrXML_IOStreamReader( file.get()));
* mReader = irr::io::createIrrXMLReader( mIOWrapper.get());
* if( !mReader) {
* ThrowException( "xxxx: Unable to open file.");
* }
* @endcode
**/
/*class CIrrXML_IOStreamReader : public irr::io::IFileReadCallBack {
public:
// ----------------------------------------------------------------------------------
//! Construction from an existing IOStream
explicit CIrrXML_IOStreamReader(IOStream* _stream)
: stream (_stream)
, t (0)
{
// Map the buffer into memory and convert it to UTF8. IrrXML provides its
// own conversion, which is merely a cast from uintNN_t to uint8_t. Thus,
// it is not suitable for our purposes and we have to do it BEFORE IrrXML
// gets the buffer. Sadly, this forces us to map the whole file into
// memory.
data.resize(stream->FileSize());
stream->Read(&data[0],data.size(),1);
// Remove null characters from the input sequence otherwise the parsing will utterly fail
// std::find is usually much faster than manually iterating
// It is very unlikely that there will be any null characters
auto null_char_iter = std::find(data.begin(), data.end(), '\0');
while (null_char_iter != data.end())
{
null_char_iter = data.erase(null_char_iter);
null_char_iter = std::find(null_char_iter, data.end(), '\0');
}
BaseImporter::ConvertToUTF8(data);
}
// ----------------------------------------------------------------------------------
//! Virtual destructor
virtual ~CIrrXML_IOStreamReader() {}*/
// ----------------------------------------------------------------------------------
//! Reads an amount of bytes from the file.
/** @param buffer: Pointer to output buffer.
* @param sizeToRead: Amount of bytes to read
* @return Returns how much bytes were read. */
/*virtual int read(void* buffer, int sizeToRead) {
if(sizeToRead<0) {
return 0;
}
if(t+sizeToRead>data.size()) {
sizeToRead = static_cast<int>(data.size()-t);
}
memcpy(buffer,&data.front()+t,sizeToRead);
t += sizeToRead;
return sizeToRead;
}
// ----------------------------------------------------------------------------------
//! Returns size of file in bytes
virtual int getSize() {
return (int)data.size();
}
private:
IOStream* stream;
std::vector<char> data;
size_t t;
}; // ! class CIrrXML_IOStreamReader
*/
struct find_node_by_name_predicate { struct find_node_by_name_predicate {
std::string mName; std::string mName;
find_node_by_name_predicate(const std::string &name) : find_node_by_name_predicate(const std::string &name) :
@ -153,6 +63,14 @@ struct find_node_by_name_predicate {
} }
}; };
template<class TNodeType>
struct NodeConverter {
public:
static int to_int(TNodeType &node, const char *attribName ) {
ai_assert(nullptr != attribName);
return node.attribute(attribName).to_int();
}
};
template<class TNodeType> template<class TNodeType>
class TXmlParser { class TXmlParser {
@ -177,6 +95,7 @@ public:
if (name.empty()) { if (name.empty()) {
return nullptr; return nullptr;
} }
if (nullptr == mDoc) { if (nullptr == mDoc) {
return nullptr; return nullptr;
} }
@ -187,6 +106,7 @@ public:
return nullptr; return nullptr;
} }
return &node;
} }
TNodeType *parse(IOStream *stream) { TNodeType *parse(IOStream *stream) {
@ -220,6 +140,7 @@ private:
}; };
using XmlParser = TXmlParser<pugi::xml_node>; using XmlParser = TXmlParser<pugi::xml_node>;
using XmlNode = pugi::xml_node;
} // namespace Assimp } // namespace Assimp