EReturn getVector(const tinyxml2::XMLElement & xml_vector,
Eigen::VectorXd & eigen_vector)
{
//!< Temporaries
double temp_entry;
int i = 0;
if (!xml_vector.GetText())
{
INDICATE_FAILURE
;
eigen_vector = Eigen::VectorXd(); //!< Null matrix again
return PAR_ERR;
}
std::istringstream text_parser(xml_vector.GetText());
//!< Initialise looping
text_parser >> temp_entry;
while (!(text_parser.fail() || text_parser.bad())) //!< No commenting!
{
eigen_vector.conservativeResize(++i); //!< Allocate storage for this entry (by increasing i)
eigen_vector(i - 1) = temp_entry;
text_parser >> temp_entry;
}
return (i > 0) ? SUCCESS : PAR_ERR;
}
EReturn getMatrix(const tinyxml2::XMLElement & xml_matrix,
Eigen::MatrixXd & eigen_matrix)
{
int dimension = 0;
if (xml_matrix.QueryIntAttribute("dim", &dimension)
!= tinyxml2::XML_NO_ERROR)
{
INDICATE_FAILURE
;
eigen_matrix = Eigen::MatrixXd(); //!< Null matrix again
return PAR_ERR;
}
if (dimension < 1)
{
INDICATE_FAILURE
;
eigen_matrix = Eigen::MatrixXd(); //!< Null matrix again
return PAR_ERR;
}
eigen_matrix.resize(dimension, dimension);
if (!xml_matrix.GetText())
{
INDICATE_FAILURE
;
eigen_matrix = Eigen::MatrixXd(); //!< Null matrix again
return PAR_ERR;
}
std::istringstream text_parser(xml_matrix.GetText());
double temp_entry;
for (int i = 0; i < dimension; i++) //!< Note that this does not handle comments!
{
for (int j = 0; j < dimension; j++)
{
text_parser >> temp_entry;
if (text_parser.fail() || text_parser.bad()) //!< If a failure other than end of file
{
INDICATE_FAILURE
;
eigen_matrix.resize(0, 0);
return PAR_ERR;
}
else
{
eigen_matrix(i, j) = temp_entry;
}
}
}
return SUCCESS;
}
EReturn getStdVector(const tinyxml2::XMLElement & xml_vector,
std::vector<double> & std_vector)
{
//!< Temporaries
double temp_entry;
std_vector.resize(0);
if (!xml_vector.GetText())
{
INDICATE_FAILURE
return PAR_ERR;
}
void XML::ParseTinyXmlElement(const tinyxml2::XMLElement& element)
{
//Parse this
const char* text = element.GetText();
if(text)
m_data = text;
//Parse attributes
for(const tinyxml2::XMLAttribute* attribute = element.FirstAttribute(); attribute; attribute = attribute->Next())
{
m_attributes.insert(std::make_pair(string::ToLower(attribute->Name()), std::string(attribute->Value())));
}
//Parse children
for(const tinyxml2::XMLElement* childElement = element.FirstChildElement(); childElement; childElement = childElement->NextSiblingElement())
{
XML* childNode = AddChild(childElement->Name());
childNode->ParseTinyXmlElement(*childElement);
}
}
/** sample ParaEngine mesh xml file
<mesh version=1 type=0>
<boundingbox minx=0 miny=0 minz=0 maxx=1 maxy=1 maxz=1/>
<shader index=3/>
<submesh loddist=10 filename="LOD_10.x"/>
<submesh loddist=50 filename="LOD_50.x"/>
</mesh>
*/
bool ParaEngine::CParaMeshXMLFile::LoadFromBuffer(const char* pData, int nSize)
{
#ifdef PARAENGINE_MOBILE
namespace TXML = tinyxml2;
try
{
TXML::XMLDocument doc(true, TXML::COLLAPSE_WHITESPACE);
doc.Parse(pData, nSize);
TXML::XMLElement* pRoot = doc.RootElement();
if (pRoot)
{
pRoot->QueryIntAttribute("version", &m_nVersion);
if (m_nVersion < SUPPORTED_MESH_FILE_VERSION)
{
OUTPUT_LOG("can not load para mesh xml file. because of a lower file version.\n");
}
int nType = 0;
pRoot->QueryIntAttribute("type", &nType);
m_nType = (ParaMeshXMLType)nType;
for (TXML::XMLNode* pChild = pRoot->FirstChild(); pChild != 0; pChild = pChild->NextSibling())
{
TXML::XMLElement* pElement = pChild->ToElement();
if (pElement)
{
std::string tagName = pElement->Name();
if (tagName == "boundingbox")
{
pElement->QueryFloatAttribute("minx", &m_vMinPos.x);
pElement->QueryFloatAttribute("miny", &m_vMinPos.y);
pElement->QueryFloatAttribute("minz", &m_vMinPos.z);
pElement->QueryFloatAttribute("maxx", &m_vMaxPos.x);
pElement->QueryFloatAttribute("maxy", &m_vMaxPos.y);
pElement->QueryFloatAttribute("maxz", &m_vMaxPos.z);
}
else if (tagName == "shader")
{
pElement->QueryIntAttribute("index", &m_nPrimaryShader);
// TODO: for shader parameters
for (TXML::XMLNode* pSubChild = pElement->FirstChild(); pSubChild != 0; pSubChild = pSubChild->NextSibling())
{
TXML::XMLElement* pParamElement = pSubChild->ToElement();
if (pParamElement)
{
std::string tagName = pParamElement->Name();
if (tagName == "params")
{
CParameter p;
// param name
p.SetName(pParamElement->Attribute("name", ""));
p.SetTypeByString(pParamElement->Attribute("type", ""));
p.SetValueByString(pParamElement->GetText());
m_paramBlock.AddParameter(p);
}
}
}
}
else if (tagName == "submesh")
{
CSubMesh meshInfo;
pElement->QueryFloatAttribute("loddist", &meshInfo.m_fToCameraDist);
std::string filepath = pElement->Attribute("filename");
// check if it is relative path or absolute path
if (filepath.find('/') != string::npos || filepath.find('\\') != string::npos)
meshInfo.m_sFileName = filepath;
else
meshInfo.m_sFileName = m_sParentDirectory + filepath;
m_SubMeshes.push_back(meshInfo);
}
}
}
}
}
catch (...)
{
OUTPUT_LOG("error parsing xml file %s**.xml \n", m_sParentDirectory.c_str());
return false;
}
return m_SubMeshes.size() > 0;
#else
TiXmlDocument doc;
try
{
doc.Parse(pData, 0, TIXML_DEFAULT_ENCODING);
TiXmlElement* pRoot = doc.RootElement();
{
// get mesh file version
TinyXPath::xpath_processor xpathProc(pRoot, "/mesh/@version");
TinyXPath::expression_result res = xpathProc.er_compute_xpath();
TinyXPath::node_set* pNodeSet = res.nsp_get_node_set();
if(pNodeSet!=0 && pNodeSet->u_get_nb_node_in_set()>0)
{
const TiXmlAttribute* att = pNodeSet->XAp_get_attribute_in_set(0);
m_nVersion = att->IntValue();
}
}
if(m_nVersion < SUPPORTED_MESH_FILE_VERSION)
{
OUTPUT_LOG("can not load para mesh xml file. because of a lower file version.\n");
}
{
// get mesh type
TinyXPath::xpath_processor xpathProc(pRoot, "/mesh/@type");
TinyXPath::expression_result res = xpathProc.er_compute_xpath();
TinyXPath::node_set* pNodeSet = res.nsp_get_node_set();
if(pNodeSet!=0 && pNodeSet->u_get_nb_node_in_set()>0)
{
const TiXmlAttribute* att = pNodeSet->XAp_get_attribute_in_set(0);
m_nType = (ParaMeshXMLType)att->IntValue();
}
}
{
// get mesh bounding box
TinyXPath::xpath_processor xpathProc(pRoot, "/mesh/boundingbox");
TinyXPath::expression_result res = xpathProc.er_compute_xpath();
TinyXPath::node_set* pNodeSet = res.nsp_get_node_set();
if(pNodeSet!=0 && pNodeSet->u_get_nb_node_in_set()>0)
{
const TiXmlElement* pElem = pNodeSet->XNp_get_node_in_set(0)->ToElement();
// parse attributes
const TiXmlAttribute* pAttr = pElem->FirstAttribute();
if (pAttr) {
m_bHasBoundingBox = true;
for (; pAttr; pAttr = pAttr->Next())
{
string sName = pAttr->Name();
if(sName == "minx")
{
m_vMinPos.x = (float)(pAttr->DoubleValue());
}
else if(sName == "miny")
{
m_vMinPos.y = (float)(pAttr->DoubleValue());
}
else if(sName == "minz")
{
m_vMinPos.z = (float)(pAttr->DoubleValue());
}
else if(sName == "maxx")
{
m_vMaxPos.x = (float)(pAttr->DoubleValue());
}
else if(sName == "maxy")
{
m_vMaxPos.y = (float)(pAttr->DoubleValue());
}
else if(sName == "maxz")
{
m_vMaxPos.z = (float)(pAttr->DoubleValue());
}
}
}
}
}
{
// get shader index.
TinyXPath::xpath_processor xpathProc(pRoot, "/mesh/shader/@index");
TinyXPath::expression_result res = xpathProc.er_compute_xpath();
TinyXPath::node_set* pNodeSet = res.nsp_get_node_set();
if(pNodeSet!=0 && pNodeSet->u_get_nb_node_in_set()>0)
{
const TiXmlAttribute* att = pNodeSet->XAp_get_attribute_in_set(0);
m_nPrimaryShader = att->IntValue();
}
}
{
// get shader parameters.
TinyXPath::xpath_processor xpathProc(pRoot, "/mesh/shader/param");
TinyXPath::expression_result res = xpathProc.er_compute_xpath();
TinyXPath::node_set* pNodeSet = res.nsp_get_node_set();
if(pNodeSet!=0 && pNodeSet->u_get_nb_node_in_set()>0)
{
int nCount = pNodeSet->u_get_nb_node_in_set();
for(int i=0; i<nCount; ++i)
{
// for each parameter
const TiXmlNode* node = pNodeSet->XNp_get_node_in_set(i);
CParameter p;
{
// param name
TinyXPath::xpath_processor xpathProc1(node->ToElement(), "@name");
TinyXPath::expression_result res1 = xpathProc1.er_compute_xpath();
TinyXPath::node_set* pNodeSet1 = res1.nsp_get_node_set();
if(pNodeSet1!=0 && pNodeSet1->u_get_nb_node_in_set()>0)
{
const TiXmlAttribute* att = pNodeSet1->XAp_get_attribute_in_set(0);
p.SetName(att->Value());
}
}
{
// get type
TinyXPath::xpath_processor xpathProc1(node->ToElement(), "@type");
TinyXPath::expression_result res1 = xpathProc1.er_compute_xpath();
TinyXPath::node_set* pNodeSet1 = res1.nsp_get_node_set();
if(pNodeSet1!=0 && pNodeSet1->u_get_nb_node_in_set()>0)
{
const TiXmlAttribute* att = pNodeSet1->XAp_get_attribute_in_set(0);
p.SetTypeByString(att->Value());
}
}
const TiXmlElement * pParamElement = node->ToElement();
if(pParamElement)
{
// get text value
p.SetValueByString(pParamElement->GetText());
m_paramBlock.AddParameter(p);
}
}
}
}
{
// get mesh info.
TinyXPath::xpath_processor xpathProc(pRoot, "/mesh/submesh");
TinyXPath::expression_result res = xpathProc.er_compute_xpath();
TinyXPath::node_set* pNodeSet = res.nsp_get_node_set();
if(pNodeSet!=0 && pNodeSet->u_get_nb_node_in_set()>0)
{
int nCount = pNodeSet->u_get_nb_node_in_set();
m_SubMeshes.resize(nCount);
for(int i=0; i<nCount; ++i)
{
// for each sub meshes
const TiXmlNode* node = pNodeSet->XNp_get_node_in_set(i);
CSubMesh& meshInfo = m_SubMeshes[i];
{
// LOD to camera distance
TinyXPath::xpath_processor xpathProc1(node->ToElement(), "@loddist");
TinyXPath::expression_result res1 = xpathProc1.er_compute_xpath();
TinyXPath::node_set* pNodeSet1 = res1.nsp_get_node_set();
if(pNodeSet1!=0 && pNodeSet1->u_get_nb_node_in_set()>0)
{
const TiXmlAttribute* att = pNodeSet1->XAp_get_attribute_in_set(0);
meshInfo.m_fToCameraDist = (float)(att->DoubleValue());
}
}
{
// file name of the mesh
TinyXPath::xpath_processor xpathProc1(node->ToElement(), "@filename");
TinyXPath::expression_result res1 = xpathProc1.er_compute_xpath();
TinyXPath::node_set* pNodeSet1 = res1.nsp_get_node_set();
if(pNodeSet1!=0 && pNodeSet1->u_get_nb_node_in_set()>0)
{
const TiXmlAttribute* att = pNodeSet1->XAp_get_attribute_in_set(0);
string filepath = att->Value();
// check if it is relative path or absolute path
if(filepath.find('/')!=string::npos || filepath.find('\\')!=string::npos)
meshInfo.m_sFileName = filepath;
else
meshInfo.m_sFileName = m_sParentDirectory + filepath;
}
}
}
}
}
}
catch (...)
{
OUTPUT_LOG("error parsing xml file %s**.xml \n", m_sParentDirectory.c_str());
return false;
}
return true;
#endif
}