C++ XMLText::Value方法代码示例

Matrix COLLADAImporter::LoadXMLMatrix(tinyxml2::XMLElement* matrix)
{
	XMLText* text = matrix->FirstChild()->ToText();
	if(text == NULL)
		return mat4::IdentityMatrix();
	std::vector<float> elements = StringHelper::ConvertStringToTArray<float>(text->Value());
	if(elements.size() != 16)
		return mat4::IdentityMatrix();
	mat4 mat;
	mat(0,0) = elements[0];
	mat(0,1) = elements[1];
	mat(0,2) = elements[2];
	mat(0,3) = elements[3];
	mat(1,0) = elements[4];
	mat(1,1) = elements[5];
	mat(1,2) = elements[6];
	mat(1,3) = elements[7];
	mat(2,0) = elements[8];
	mat(2,1) = elements[9];
	mat(2,2) = elements[10];
	mat(2,3) = elements[11];
	mat(3,0) = elements[12];
	mat(3,1) = elements[13];
	mat(3,2) = elements[14];
	mat(3,3) = elements[15];
	return Matrix(mat);
}

Scale COLLADAImporter::LoadXMLScale(tinyxml2::XMLElement* scale)
{
	XMLText* text = scale->FirstChild()->ToText();
	if(text == NULL)
		return Scale();
	std::vector<float> elements = StringHelper::ConvertStringToTArray<float>(text->Value());
	if(elements.size() != 3)
		return Scale();
	vec3 t(elements[0],elements[1],elements[2]);
	return Scale(t);
}

Rotate COLLADAImporter::LoadXMLRotation(tinyxml2::XMLElement* rotation)
{
	XMLText* text = rotation->FirstChild()->ToText();
	if(text == NULL)
		return Rotate();
	std::vector<float> elements = StringHelper::ConvertStringToTArray<float>(text->Value());
	if(elements.size() != 4)
		return Rotate();
	vec3 axis(elements[0],elements[1],elements[2]);	
	return Rotate(axis,elements[3]);
}

bool TextVisitor::Visit(const XMLText& text)
{
	std::string t = " ";
	t = text.Value();	

	// break text strings into 57 character lengths to fit on the screen.
	for (unsigned int i = 0; i < t.length(); i += 57)
	{
		bookText.push_back(t.substr(i, 57));
	}
	
	return true;
}

int example_3()
{
	static const char* xml =
		"<?xml version=\"1.0\"?>"
		"<!DOCTYPE PLAY SYSTEM \"play.dtd\">"
		"<PLAY>"
		"<TITLE>A Midsummer Night's Dream</TITLE>"
		"</PLAY>";

	XMLDocument doc;
	doc.Parse( xml );

	XMLElement* titleElement = doc.FirstChildElement( "PLAY" )->FirstChildElement( "TITLE" );
	const char* title = titleElement->GetText();
	printf( "Name of play (1): %s\n", title );

	XMLText* textNode = titleElement->FirstChild()->ToText();
	title = textNode->Value();
	printf( "Name of play (2): %s\n", title );

	return doc.ErrorID();
}

void COLLADAImporter::LoadFloatArrays(XMLElement *geometryNode, boost::unordered_map<std::string, std::vector<float> >& map)
{	 
	std::vector<XMLElement *> geometries = XMLHelper::GetChildElements(geometryNode,"geometry");
	std::vector<XMLElement *> meshes;
	for(std::vector<XMLElement *>::const_iterator it = geometries.begin(); it != geometries.end(); it++) {
		XMLElement *mesh;
		if((mesh = XMLHelper::GetChildElement(*it,"mesh")) != NULL) {
			meshes.push_back(mesh);
		}
	}

	std::string id;
	for(std::vector<XMLElement *>::const_iterator mit = meshes.begin(); mit != meshes.end(); mit++){
		std::vector<XMLElement *> sources = XMLHelper::GetChildElements(*mit,"source");		
		for(std::vector<XMLElement *>::const_iterator it = sources.begin(); it != sources.end(); it++) {
			XMLElement *float_array = XMLHelper::GetChildElement(*it,"float_array");
			if(float_array != NULL) {
				if(XMLHelper::GetElementAttribute(float_array,"id",id)) {
					XMLText *innerText = float_array->FirstChild()->ToText();
					std::string farray(innerText->Value());
					std::vector<float> fvalues;
					//fvalues = StringHelper::ConvertStringToFloatArray(farray);
					fvalues = StringHelper::ConvertStringToTArray<float>(farray);
				
					int arraycount;
					if(!StringHelper::from_string<int>(arraycount,float_array->Attribute("count"))) {
						continue;					
					}

					while(fvalues.size() < arraycount) {
						fvalues.push_back(0.0f);
					}

					map[id] = fvalues;
				}
			}
		}
	}
}

int main() {
    XMLDocument doc;
	//bii://examples/tinyxml2/dream.xml
    doc.LoadFile( "examples/tinyxml2/dream.xml" );

    // Structure of the XML file:
    // - Element "PLAY"      the root Element, which is the 
    //                       FirstChildElement of the Document
    // - - Element "TITLE"   child of the root PLAY Element
    // - - - Text            child of the TITLE Element

    // Navigate to the title, using the convenience function,
    // with a dangerous lack of error checking.
    const char* title = doc.FirstChildElement( "PLAY" )->FirstChildElement( "TITLE" )->GetText();
    printf( "Name of play (1): %s\n", title );

    // Text is just another Node to TinyXML-2. The more
    // general way to get to the XMLText:
    XMLText* textNode = doc.FirstChildElement( "PLAY" )->FirstChildElement( "TITLE" )->FirstChild()->ToText();
    title = textNode->Value();
    printf( "Name of play (2): %s\n", title );
}

	bool XMLPrinter::Visit( const XMLText& text )
	{
		PushText( text.Value(), text.CData() );
		return true;
	}

//.........这里部分代码省略.........
		XMLElement* newElement = doc.NewElement( "Subelement" );
		root->InsertEndChild( newElement );
		doc.Print();
	}
	{
		XMLDocument* doc = new XMLDocument();
		static const char* test = "<element><sub/></element>";
		doc->Parse( test );
		delete doc;
	}
	{
		// Test: Programmatic DOM
		// Build:
		//		<element>
		//			<!--comment-->
		//			<sub attrib="1" />
		//			<sub attrib="2" />
		//			<sub attrib="3" >& Text!</sub>
		//		<element>

		XMLDocument* doc = new XMLDocument();
		XMLNode* element = doc->InsertEndChild( doc->NewElement( "element" ) );

		XMLElement* sub[3] = { doc->NewElement( "sub" ), doc->NewElement( "sub" ), doc->NewElement( "sub" ) };
		for( int i=0; i<3; ++i ) {
			sub[i]->SetAttribute( "attrib", i );
		}
		element->InsertEndChild( sub[2] );
		XMLNode* comment = element->InsertFirstChild( doc->NewComment( "comment" ) );
		element->InsertAfterChild( comment, sub[0] );
		element->InsertAfterChild( sub[0], sub[1] );
		sub[2]->InsertFirstChild( doc->NewText( "& Text!" ));
		doc->Print();
		XMLTest( "Programmatic DOM", "comment", doc->FirstChildElement( "element" )->FirstChild()->Value() );
		XMLTest( "Programmatic DOM", "0", doc->FirstChildElement( "element" )->FirstChildElement()->Attribute( "attrib" ) );
		XMLTest( "Programmatic DOM", 2, doc->FirstChildElement()->LastChildElement( "sub" )->IntAttribute( "attrib" ) );
		XMLTest( "Programmatic DOM", "& Text!",
				 doc->FirstChildElement()->LastChildElement( "sub" )->FirstChild()->ToText()->Value() );

		// And now deletion:
		element->DeleteChild( sub[2] );
		doc->DeleteNode( comment );

		element->FirstChildElement()->SetAttribute( "attrib", true );
		element->LastChildElement()->DeleteAttribute( "attrib" );

		XMLTest( "Programmatic DOM", true, doc->FirstChildElement()->FirstChildElement()->BoolAttribute( "attrib" ) );
		int value = 10;
		int result = doc->FirstChildElement()->LastChildElement()->QueryIntAttribute( "attrib", &value );
		XMLTest( "Programmatic DOM", result, (int)XML_NO_ATTRIBUTE );
		XMLTest( "Programmatic DOM", value, 10 );

		doc->Print();

		{
			XMLPrinter streamer;
			doc->Print( &streamer );
			printf( "%s", streamer.CStr() );
		}
		{
			XMLPrinter streamer( 0, true );
			doc->Print( &streamer );
			XMLTest( "Compact mode", "<element><sub attrib=\"1\"/><sub/></element>", streamer.CStr(), false );
		}
		doc->SaveFile( "./resources/out/pretty.xml" );
		doc->SaveFile( "./resources/out/compact.xml", true );

int main( int /*argc*/, const char ** /*argv*/ )
{
	#if defined( _MSC_VER ) && defined( DEBUG )
		_CrtMemCheckpoint( &startMemState );
	#endif	

	#if defined(_MSC_VER)
	#pragma warning ( push )
	#pragma warning ( disable : 4996 )		// Fail to see a compelling reason why this should be deprecated.
	#endif

	FILE* fp = fopen( "dream.xml", "r" );
	if ( !fp ) {
		printf( "Error opening test file 'dream.xml'.\n"
				"Is your working directory the same as where \n"
				"the xmltest.cpp and dream.xml file are?\n\n"
	#if defined( _MSC_VER )
				"In windows Visual Studio you may need to set\n"
				"Properties->Debugging->Working Directory to '..'\n"
	#endif
			  );
		exit( 1 );
	}
	fclose( fp );

	#if defined(_MSC_VER)
	#pragma warning ( pop )
	#endif

	/* ------ Example 1: Load and parse an XML file. ---- */	
	{
		XMLDocument doc;
		doc.LoadFile( "dream.xml" );
	}
	
	/* ------ Example 2: Lookup information. ---- */	
	{
		XMLDocument doc;
		doc.LoadFile( "dream.xml" );

		// Structure of the XML file:
		// - Element "PLAY"			the root Element
		// - - Element "TITLE"		child of the root PLAY Element
		// - - - Text				child of the TITLE Element
		
		// Navigate to the title, using the convenience function, with a dangerous lack of error checking.
		const char* title = doc.FirstChildElement( "PLAY" )->FirstChildElement( "TITLE" )->GetText();
		printf( "Name of play (1): %s\n", title );
		
		// Text is just another Node to TinyXML-2. The more general way to get to the XMLText:
		XMLText* textNode = doc.FirstChildElement( "PLAY" )->FirstChildElement( "TITLE" )->FirstChild()->ToText();
		title = textNode->Value();
		printf( "Name of play (2): %s\n", title );
	}

	{
		static const char* test[] = {	"<element />",
									    "<element></element>",
										"<element><subelement/></element>",
									    "<element><subelement></subelement></element>",
									    "<element><subelement><subsub/></subelement></element>",
									    "<!--comment beside elements--><element><subelement></subelement></element>",
									    "<!--comment beside elements, this time with spaces-->  \n <element>  <subelement> \n </subelement> </element>",
									    "<element attrib1='foo' attrib2=\"bar\" ></element>",
									    "<element attrib1='foo' attrib2=\"bar\" ><subelement attrib3='yeehaa' /></element>",
										"<element>Text inside element.</element>",
										"<element><b></b></element>",
										"<element>Text inside and <b>bolded</b> in the element.</element>",
										"<outer><element>Text inside and <b>bolded</b> in the element.</element></outer>",
										"<element>This &amp; That.</element>",
										"<element attrib='This&lt;That' />",
										0
		};
		for( int i=0; test[i]; ++i ) {
			XMLDocument doc;
			doc.Parse( test[i] );
			doc.Print();
			printf( "----------------------------------------------\n" );
		}
	}
#if 1
	{
		static const char* test = "<!--hello world\n"
			                      "          line 2\r"
			                      "          line 3\r\n"
			                      "          line 4\n\r"
			                      "          line 5\r-->";

		XMLDocument doc;
		doc.Parse( test );
		doc.Print();
	}

	{
		static const char* test = "<element>Text before.</element>";
		XMLDocument doc;
		doc.Parse( test );
		XMLElement* root = doc.FirstChildElement();
		XMLElement* newElement = doc.NewElement( "Subelement" );
		root->InsertEndChild( newElement );
//.........这里部分代码省略.........

        bool parse(const char *buffer) {

            // TODO: Restructure parse code so all checks occur in beginning
            // before any values are changed

            // TODO: catch lexical_cast exception

            doc.Parse( buffer );
            XMLHandle docHandle( &doc );

            XMLText *nodeval = docHandle.FirstChildElement( "ExternalData" )
                        .FirstChildElement( "TString" )
                        .FirstChild()   // this is a text, not an element
                        .ToText();

            if( nodeval ) {
                if ( nodeval->Value() ) {
                    estr = nodeval->Value();
                }
                else {  // something wrong with xml
                    malformedXMLError("TString Value");
                    return false;
                }
            }
            else {  // something wrong with xml
                malformedXMLError("TString");
                return false;
            }

            nodeval = docHandle.FirstChildElement( "ExternalData" )
                        .FirstChildElement( "Position" )
                        .FirstChildElement("XPos")   // this is a text, not an element
                        .FirstChild()
                        .ToText();

            if( nodeval ) {
                if ( nodeval->Value() ) {
                    xPos = boost::lexical_cast<double>(nodeval->Value());
                }
                else {  // something wrong with xml
                    malformedXMLError("XPos Value");
                    return false;
                }
            }
            else {  // something wrong with xml
                malformedXMLError("XPos");
                return false;
            }

            nodeval = docHandle.FirstChildElement( "ExternalData" )
                        .FirstChildElement( "Position" )
                        .FirstChildElement("YPos")   // this is a text, not an element
                        .FirstChild()
                        .ToText();

            if( nodeval ) {
                if ( nodeval->Value() ) {
                    yPos = boost::lexical_cast<double>(nodeval->Value());
                }
                else {  // something wrong with xml
                    malformedXMLError("YPos Value");
                    return false;
                }
            }
            else {  // something wrong with xml
                malformedXMLError("YPos");
                return false;
            }

            nodeval = docHandle.FirstChildElement( "ExternalData" )
                        .FirstChildElement( "Position" )
                        .FirstChildElement("ZPos")   // this is a text, not an element
                        .FirstChild()
                        .ToText();

            if( nodeval ) {
                if ( nodeval->Value() ) {
                    zPos = boost::lexical_cast<double>(nodeval->Value());
                }
                else {  // something wrong with xml
                    malformedXMLError("ZPos Value");
                    return false;
                }
            }
            else {  // something wrong with xml
                malformedXMLError("ZPos");
                return false;
            }

            nodeval = docHandle.FirstChildElement( "ExternalData" )
                        .FirstChildElement( "Temperature" )
                        .FirstChildElement("Cpu")   // this is a text, not an element
                        .FirstChild()
                        .ToText();

            if( nodeval ) {
                if ( nodeval->Value() ) {
                    cpu = boost::lexical_cast<double>(nodeval->Value());
                }
                else {  // something wrong with xml
//.........这里部分代码省略.........

bool COLLADAImporter::LoadGeometry(XMLElement* geometryNode,boost::unordered_map<std::string, std::vector<float> >& floatarrays)
{
	boost::unordered_map<std::string,Source> sources;

	XMLElement *mesh = XMLHelper::GetChildElement(geometryNode,"mesh");
	if(mesh == NULL)
		mesh = XMLHelper::GetChildElement(geometryNode,"convex_mesh");
	if(mesh == NULL)
		return false;

	// load all source elements under <mesh>
	std::vector<XMLElement*> xmlsources = XMLHelper::GetChildElements(mesh,"source");
	for(std::vector<XMLElement*>::iterator it = xmlsources.begin();it != xmlsources.end(); it++) {
		Source s;
		if(s.parseXML(*it,floatarrays))
			sources[s.getID()] = s;
		else
			return false;
	}

	XMLElement* xmlvertices = XMLHelper::GetChildElement(mesh,"vertices");
	if(xmlvertices == NULL)
		return false;
	if(xmlvertices->Attribute("id") == NULL)
		return false;

	// get <vertrices> id
	std::string verticesid = xmlvertices->Attribute("id");
	// get <vertices>, <input> with semantic="POSITION"
	XMLElement *positionInput = XMLHelper::GetChildElement(xmlvertices,"input","semantic","POSITION");
	std::string positionid;
	if(!XMLHelper::GetElementAttribute(positionInput,"source",positionid))
		return false;
	
	positionid = positionid.substr(1);	// remove leading "#"

	
	Mesh mmesh;
	std::string geometryid;
	if(XMLHelper::GetElementAttribute(geometryNode,"id",geometryid))
		mmesh.setID(geometryid);

	std::string geometryName;
	if(XMLHelper::GetElementAttribute(geometryNode,"name",geometryName))
		mmesh.setName(geometryName);

	Source& vertices = sources[positionid];
	int ucount = vertices.getUnitCount();
	if(ucount < 3)
		return false;
	int vcount = vertices.getArrayValues().size() / ucount;
	for(int i=0;i<vcount;i++) {
		int idx = ucount*i;
		vec3 v(vertices.getArrayValues()[idx],vertices.getArrayValues()[idx+1],vertices.getArrayValues()[idx+2]);
		mmesh.getVertices().push_back(v);
	}

	// get <triangles> nodes
	std::vector<XMLElement*> xmltriangles = XMLHelper::GetChildElements(mesh,"triangles");
	for(std::vector<XMLElement*>::iterator it = xmltriangles.begin();it!=xmltriangles.end();it++){
		XMLElement * triangles = *it;					
		if(triangles->Attribute("count") != NULL) {
			// get triangle count
			int tricount=0;
			if(!StringHelper::from_string<int>(tricount,std::string(triangles->Attribute("count"))))
				continue;

			std::string materialsymbol;
			if(!XMLHelper::GetElementAttribute(triangles,"material",materialsymbol))
				materialsymbol = "";

			std::string temp;
			int vertices_offset;
			// get vertices <input>
			XMLElement* verticesInput = XMLHelper::GetChildElement(triangles,"input","semantic","VERTEX");						
			if(!XMLHelper::GetElementAttribute(verticesInput,"source",temp))
				return false;
			temp = temp.substr(1);
			if(temp != verticesid)		// verify source is the same as vertices id loaded above in current mesh
				return false;
			if(!XMLHelper::GetElementAttribute(verticesInput,"offset",temp))		// get vertices offset in <p> element
				return false;
			if(!StringHelper::from_string(vertices_offset,temp))
				return false;

			std::string normalid;
			int normal_offset;						
			bool hasNormals;

			// get normals <input>
			XMLElement* normalInput = XMLHelper::GetChildElement(triangles,"input","semantic","NORMAL");
			if(!XMLHelper::GetElementAttribute(normalInput,"source",normalid))
				hasNormals = false;
			else {
				normalid = normalid.substr(1);
				hasNormals = true;
			}
											
			if(hasNormals && !XMLHelper::GetElementAttribute(normalInput,"offset",temp))	// get offset for normals in <p> element
				return false;
//.........这里部分代码省略.........

bool COLLADAImporter::LoadMaterial(XMLElement* colladaRootNode,const std::string& id)
{
	if(m_Materials.find(id) != m_Materials.end())			// material already loaded
		return true;

	XMLElement *materials = XMLHelper::GetChildElement(colladaRootNode,"library_materials");
	if(materials == NULL)
		return false;
	XMLElement *material = XMLHelper::GetChildElement(materials,"material","id",id);
	if(material == NULL)
		return false;
	XMLElement *effect = XMLHelper::GetChildElement(material,"instance_effect");
	if(effect == NULL)
		return false;
	std::string effectid;
	if(!XMLHelper::GetElementAttribute(effect,"url",effectid))
		return false;
	effectid = effectid.substr(1);		// remove leading "#"

	XMLElement *effects = XMLHelper::GetChildElement(colladaRootNode,"library_effects");
	if(effects == NULL)
		return false;
	effect = XMLHelper::GetChildElement(effects,"id",effectid);
	if(effect == NULL)
		return false;
	XMLElement *profile = XMLHelper::GetChildElement(effect,"profile_COMMON");
	if(profile == NULL)
		return false;
	XMLElement *technique = XMLHelper::GetChildElement(profile,"technique");
	if(technique == NULL)
		return false;

	XMLElement *bp = XMLHelper::GetChildElement(technique,"blinn");
	if(bp == NULL) {
		bp = XMLHelper::GetChildElement(technique,"phong");
		if(bp == NULL) {
			bp = XMLHelper::GetChildElement(technique,"lambert");
			if(bp == NULL)
				return false;
		}
			
	}

	Material mat;
	// ambient
	XMLElement *ambient = XMLHelper::GetChildElement(bp,"ambient");
	if(ambient != NULL) {	
		XMLElement *color = XMLHelper::GetChildElement(ambient,"color");
		if(color != NULL) {
			XMLText *value = color->FirstChild()->ToText();
			if(value != NULL) {		
				std::vector<float> c = StringHelper::ConvertStringToTArray<float>(value->Value());
				if(c.size() >= 3 )			
					mat.m_Ambient = vec3(c[0],c[1],c[2]);
			}
		}
	}

	//diffuse
	XMLElement *diffuse = XMLHelper::GetChildElement(bp,"diffuse");
	if(diffuse != NULL) {		
		XMLElement* color = XMLHelper::GetChildElement(diffuse,"color");
		if(color != NULL) {		
			XMLText* value = color->FirstChild()->ToText();
			if(value != NULL) {				
				std::vector<float> c = StringHelper::ConvertStringToTArray<float>(value->Value());
				if(c.size() >= 3 )					
					mat.m_Diffuse = vec3(c[0],c[1],c[2]);
			}
		}
	}

	//specular
	XMLElement *specular = XMLHelper::GetChildElement(bp,"specular");
	if(specular != NULL) {		
		XMLElement* color = XMLHelper::GetChildElement(specular,"color");
		if(color != NULL) {		
			XMLText* value = color->FirstChild()->ToText();
			if(value != NULL) {
				std::vector<float> c = StringHelper::ConvertStringToTArray<float>(value->Value());
				if(c.size() >= 3 )		
					mat.m_Specular = vec3(c[0],c[1],c[2]);
			}
		}
	}

	//emission
	XMLElement *emission = XMLHelper::GetChildElement(bp,"emission");
	if(emission != NULL) {
		XMLElement* color = XMLHelper::GetChildElement(emission,"color");
		if(color != NULL) {			
			XMLText* value = color->FirstChild()->ToText();
			if(value != NULL) {			
				std::vector<float> c = StringHelper::ConvertStringToTArray<float>(value->Value());
				if(c.size() >= 3 )
					mat.m_Emmission = vec3(c[0],c[1],c[2]);
			}
		}
	}
	m_Materials[id] = mat;
//.........这里部分代码省略.........

//.........这里部分代码省略.........
		pFile->Release();
        pXmlTexture = pXmlTexture->NextSiblingElement("texture");
    }
	OVR_DEBUG_LOG_TEXT(("Done.\n"));

    // Load the models
	pXmlDocument->FirstChildElement("scene")->FirstChildElement("models")->
		          QueryIntAttribute("count", &modelCount);
	
		OVR_DEBUG_LOG(("Loading models... %i models to load...", modelCount));
    XMLElement* pXmlModel = pXmlDocument->FirstChildElement("scene")->
		                                  FirstChildElement("models")->FirstChildElement("model");
    for(int i = 0; i < modelCount; ++i)
    {
		if (i % 15 == 0)
		{
			OVR_DEBUG_LOG_TEXT(("%i models remaining...", modelCount - i));
		}
        const char* name = pXmlModel->Attribute("name");
        Models.PushBack(*new Model(Prim_Triangles, name));
        bool isCollisionModel = false;
        pXmlModel->QueryBoolAttribute("isCollisionModel", &isCollisionModel);
        Models[i]->IsCollisionModel = isCollisionModel;
		if (isCollisionModel)
		{
			Models[i]->Visible = false;
		}

        bool tree_c = (strcmp(name, "tree_C") == 0) || (strcmp(name, "Object03") == 0);

        //read the vertices
        OVR::Array<Vector3f> *vertices = new OVR::Array<Vector3f>();
        ParseVectorString(pXmlModel->FirstChildElement("vertices")->FirstChild()->
			              ToText()->Value(), vertices);

		for (unsigned int vertexIndex = 0; vertexIndex < vertices->GetSize(); ++vertexIndex)
		{
			vertices->At(vertexIndex).x *= -1.0f;

            if (tree_c)
            {   // Move the terrace tree closer to the house
                vertices->At(vertexIndex).z += 0.5;
            }
		}

        //read the normals
        OVR::Array<Vector3f> *normals = new OVR::Array<Vector3f>();
        ParseVectorString(pXmlModel->FirstChildElement("normals")->FirstChild()->
			              ToText()->Value(), normals);

		for (unsigned int normalIndex = 0; normalIndex < normals->GetSize(); ++normalIndex)
		{
			normals->At(normalIndex).z *= -1.0f;
		}

        //read the textures
        OVR::Array<Vector3f> *diffuseUVs = new OVR::Array<Vector3f>();
        OVR::Array<Vector3f> *lightmapUVs = new OVR::Array<Vector3f>();
        int         diffuseTextureIndex = -1;
        int         lightmapTextureIndex = -1;
        XMLElement* pXmlCurMaterial = pXmlModel->FirstChildElement("material");

        while(pXmlCurMaterial != NULL)
        {
            if(pXmlCurMaterial->Attribute("name", "diffuse"))
            {

void LevelParser::parseTileLayer(XMLElement* pTileElement, Level *pLevel)
{
	// New TileLayer instance 
	TileLayer* pTileLayer = new TileLayer(m_tileSize, m_width, m_height, TheGame::Instance().getTilesets());

	// local temporary variable
	bool collidable = false;

	// A multidimensional array of int values to hold our final decoded and uncompressed tile data
	std::vector<std::vector<int>> data;

	// xml data node
	XMLElement* pDataNode = nullptr;
	// to store base64 decoded information
	std::string decodedIDs;	

	// We search for the node we need
	for (XMLElement* e = pTileElement->FirstChildElement(); e != NULL; e = e->NextSiblingElement())
	{
		// check if layer has properties
		if (e->Value() == std::string("properties"))
		{
			for (XMLElement* property = e->FirstChildElement(); property != NULL; property = property->NextSiblingElement())
			{
				if (property->Value() == std::string("property"))
				{
					// Check if it is a collision layer
					if (property->Attribute("name") == std::string("collidable"))
					{
						collidable = true;
					}
				}
			}
		}

		if (e->Value() == std::string("data"))
		{
			pDataNode = e;
		}
	}

	// Tile information not encoded nor compressed
	if (pDataNode->Attribute("encoding") == nullptr)
	{
		std::vector<int> layerRow(m_width);
		for (int rows = 0; rows < m_height; rows++)
		{
			data.push_back(layerRow);
		}

		XMLElement* tile = pDataNode->FirstChildElement();
		int id;
		for (int rows = 0; rows < m_height; rows++)
		{
			for (int cols = 0; cols < m_width ; cols++)
			{
				tile->QueryAttribute("gid", &data[rows][cols]);
				tile = tile->NextSiblingElement();
			}
		}
	}
	else
	{
		// We get the text (our encoded/compressed data) from the data node and use the base64 decoder to decode it
		for (XMLNode* e = pDataNode->FirstChild(); e != NULL; e = e->NextSibling())
		{
			XMLText* text = e->ToText();
			std::string t = text->Value();
			decodedIDs = base64_decode(t);
		}

		// We use the zlib library to decompress our data once again
		uLongf sizeofids = m_width * m_height * sizeof(int);
		std::vector<unsigned> gids(sizeofids);
		uncompress((Bytef*)&gids[0], &sizeofids, (const Bytef*)decodedIDs.c_str(), decodedIDs.size());

		// gids now contains all of our tile IDs, so we fill our data array with the correct values

		std::vector<int> layerRow(m_width);

		for (int j = 0; j < m_height; j++)
		{
			data.push_back(layerRow);
		}

		for (int rows = 0; rows < m_height; rows++)
		{
			for (int cols = 0; cols < m_width; cols++)
			{
				data[rows][cols] = gids[rows * m_width + cols];
			}
		}
	}

	pTileLayer->setTileIDs(data);
	pTileLayer->setMapWidth(m_width);

	// push into collision array and mark the layer as collidable if necessary
	if (collidable)
	{
//.........这里部分代码省略.........