Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

OgreXMLMeshSerializer.cpp @ 930

Revision 930, 62.3 KB checked in by igarcia, 18 years ago (diff)

Rev	Line
[930]	1	/*
	2	-----------------------------------------------------------------------------
	3	This source file is part of OGRE
	4	(Object-oriented Graphics Rendering Engine)
	5	For the latest info, see http://www.ogre3d.org/
	6
	7	Copyright (c) 2000-2005 The OGRE Team
	8	Also see acknowledgements in Readme.html
	9
	10	This program is free software; you can redistribute it and/or modify it under
	11	the terms of the GNU Lesser General Public License as published by the Free Software
	12	Foundation; either version 2 of the License, or (at your option) any later
	13	version.
	14
	15	This program is distributed in the hope that it will be useful, but WITHOUT
	16	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
	17	FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
	18
	19	You should have received a copy of the GNU Lesser General Public License along with
	20	this program; if not, write to the Free Software Foundation, Inc., 59 Temple
	21	Place - Suite 330, Boston, MA 02111-1307, USA, or go to
	22	http://www.gnu.org/copyleft/lesser.txt.
	23	-----------------------------------------------------------------------------
	24	*/
	25
	26
	27	#include "OgreXMLMeshSerializer.h"
	28	#include "OgreSubMesh.h"
	29	#include "OgreLogManager.h"
	30	#include "OgreSkeleton.h"
	31	#include "OgreStringConverter.h"
	32	#include "OgreHardwareBufferManager.h"
	33	#include "OgreException.h"
	34	#include "OgreAnimation.h"
	35	#include "OgreAnimationTrack.h"
	36	#include "OgreKeyFrame.h"
	37
	38	namespace Ogre {
	39
	40	//---------------------------------------------------------------------
	41	XMLMeshSerializer::XMLMeshSerializer()
	42	{
	43	}
	44	//---------------------------------------------------------------------
	45	XMLMeshSerializer::~XMLMeshSerializer()
	46	{
	47	}
	48	//---------------------------------------------------------------------
	49	void XMLMeshSerializer::importMesh(const String& filename,
	50	VertexElementType colourElementType, Mesh* pMesh)
	51	{
	52	LogManager::getSingleton().logMessage("XMLMeshSerializer reading mesh data from " + filename + "...");
	53	mpMesh = pMesh;
	54	mColourElementType = colourElementType;
	55	mXMLDoc = new TiXmlDocument(filename);
	56	mXMLDoc->LoadFile();
	57
	58	TiXmlElement* elem;
	59
	60	TiXmlElement* rootElem = mXMLDoc->RootElement();
	61
	62	// shared geometry
	63	elem = rootElem->FirstChildElement("sharedgeometry");
	64	if (elem)
	65	{
	66	if(StringConverter::parseInt(elem->Attribute("vertexcount")) > 0)
	67	{
	68	mpMesh->sharedVertexData = new VertexData();
	69	readGeometry(elem, mpMesh->sharedVertexData);
	70	}
	71	}
	72
	73	// submeshes
	74	elem = rootElem->FirstChildElement("submeshes");
	75	if (elem)
	76	readSubMeshes(elem);
	77
	78	// skeleton link
	79	elem = rootElem->FirstChildElement("skeletonlink");
	80	if (elem)
	81	readSkeletonLink(elem);
	82
	83	// bone assignments
	84	elem = rootElem->FirstChildElement("boneassignments");
	85	if (elem)
	86	readBoneAssignments(elem);
	87
	88	//Lod
	89	elem = rootElem->FirstChildElement("levelofdetail");
	90	if (elem)
	91	readLodInfo(elem);
	92
	93	// submesh names
	94	elem = rootElem->FirstChildElement("submeshnames");
	95	if (elem)
	96	readSubMeshNames(elem, mpMesh);
	97
	98	// poses
	99	elem = rootElem->FirstChildElement("poses");
	100	if (elem)
	101	readPoses(elem, mpMesh);
	102
	103	// animations
	104	elem = rootElem->FirstChildElement("animations");
	105	if (elem)
	106	readAnimations(elem, mpMesh);
	107
	108	delete mXMLDoc;
	109
	110	LogManager::getSingleton().logMessage("XMLMeshSerializer import successful.");
	111
	112	}
	113	//---------------------------------------------------------------------
	114	void XMLMeshSerializer::exportMesh(const Mesh* pMesh, const String& filename)
	115	{
	116	LogManager::getSingleton().logMessage("XMLMeshSerializer writing mesh data to " + filename + "...");
	117
	118	mpMesh = const_cast<Mesh*>(pMesh);
	119
	120	mXMLDoc = new TiXmlDocument();
	121	mXMLDoc->InsertEndChild(TiXmlElement("mesh"));
	122	TiXmlElement* rootNode = mXMLDoc->RootElement();
	123
	124	LogManager::getSingleton().logMessage("Populating DOM...");
	125
	126
	127
	128	// Write to DOM
	129	writeMesh(pMesh);
	130	LogManager::getSingleton().logMessage("DOM populated, writing XML file..");
	131
	132	// Write out to a file
	133	mXMLDoc->SaveFile(filename);
	134
	135
	136	delete mXMLDoc;
	137
	138	LogManager::getSingleton().logMessage("XMLMeshSerializer export successful.");
	139
	140	}
	141	//---------------------------------------------------------------------
	142	void XMLMeshSerializer::writeMesh(const Mesh* pMesh)
	143	{
	144	TiXmlElement* rootNode = mXMLDoc->RootElement();
	145	// Write geometry
	146	if (pMesh->sharedVertexData)
	147	{
	148	TiXmlElement* geomNode =
	149	rootNode->InsertEndChild(TiXmlElement("sharedgeometry"))->ToElement();
	150	writeGeometry(geomNode, pMesh->sharedVertexData);
	151	}
	152
	153	// Write Submeshes
	154	TiXmlElement* subMeshesNode =
	155	rootNode->InsertEndChild(TiXmlElement("submeshes"))->ToElement();
	156	for (int i = 0; i < pMesh->getNumSubMeshes(); ++i)
	157	{
	158	LogManager::getSingleton().logMessage("Writing submesh...");
	159	writeSubMesh(subMeshesNode, pMesh->getSubMesh(i));
	160	LogManager::getSingleton().logMessage("Submesh exported.");
	161	}
	162
	163	// Write skeleton info if required
	164	if (pMesh->hasSkeleton())
	165	{
	166	LogManager::getSingleton().logMessage("Exporting skeleton link...");
	167	// Write skeleton link
	168	writeSkeletonLink(rootNode, pMesh->getSkeletonName());
	169	LogManager::getSingleton().logMessage("Skeleton link exported.");
	170
	171	// Write bone assignments
	172	Mesh::BoneAssignmentIterator bi = const_cast<Mesh*>(pMesh)->getBoneAssignmentIterator();
	173	if (bi.hasMoreElements())
	174	{
	175	LogManager::getSingleton().logMessage("Exporting shared geometry bone assignments...");
	176	TiXmlElement* boneAssignNode =
	177	rootNode->InsertEndChild(TiXmlElement("boneassignments"))->ToElement();
	178
	179	while (bi.hasMoreElements())
	180	{
	181	const VertexBoneAssignment& assign = bi.getNext();
	182	writeBoneAssignment(boneAssignNode, &assign);
	183	}
	184
	185	LogManager::getSingleton().logMessage("Shared geometry bone assignments exported.");
	186	}
	187	}
	188	if (pMesh->getNumLodLevels() > 1)
	189	{
	190	LogManager::getSingleton().logMessage("Exporting LOD information...");
	191	writeLodInfo(rootNode, pMesh);
	192	LogManager::getSingleton().logMessage("LOD information exported.");
	193	}
	194	// Write submesh names
	195	writeSubMeshNames(rootNode, pMesh);
	196	// Write poses
	197	writePoses(rootNode, pMesh);
	198	// Write animations
	199	writeAnimations(rootNode, pMesh);
	200
	201
	202
	203
	204
	205	}
	206	//---------------------------------------------------------------------
	207	void XMLMeshSerializer::writeSubMesh(TiXmlElement* mSubMeshesNode, const SubMesh* s)
	208	{
	209	TiXmlElement* subMeshNode =
	210	mSubMeshesNode->InsertEndChild(TiXmlElement("submesh"))->ToElement();
	211
	212	size_t numFaces;
	213
	214	// Material name
	215	subMeshNode->SetAttribute("material", s->getMaterialName());
	216	// bool useSharedVertices
	217	subMeshNode->SetAttribute("usesharedvertices",
	218	StringConverter::toString(s->useSharedVertices) );
	219	// bool use32BitIndexes
	220	bool use32BitIndexes = (s->indexData->indexBuffer->getType() == HardwareIndexBuffer::IT_32BIT);
	221	subMeshNode->SetAttribute("use32bitindexes",
	222	StringConverter::toString( use32BitIndexes ));
	223
	224	// Operation type
	225	switch(s->operationType)
	226	{
	227	case RenderOperation::OT_LINE_LIST:
	228	case RenderOperation::OT_LINE_STRIP:
	229	case RenderOperation::OT_POINT_LIST:
	230	OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Unsupported operation type, only "
	231	"triangle types are allowed.", "XMLMeshSerializer::writeSubMesh");
	232	break;
	233	case RenderOperation::OT_TRIANGLE_FAN:
	234	subMeshNode->SetAttribute("operationtype", "triangle_fan");
	235	break;
	236	case RenderOperation::OT_TRIANGLE_LIST:
	237	subMeshNode->SetAttribute("operationtype", "triangle_list");
	238	break;
	239	case RenderOperation::OT_TRIANGLE_STRIP:
	240	subMeshNode->SetAttribute("operationtype", "triangle_strip");
	241	break;
	242	}
	243
	244	// Faces
	245	TiXmlElement* facesNode =
	246	subMeshNode->InsertEndChild(TiXmlElement("faces"))->ToElement();
	247	if (s->operationType == RenderOperation::OT_TRIANGLE_LIST)
	248	{
	249	// tri list
	250	numFaces = s->indexData->indexCount / 3;
	251	}
	252	else
	253	{
	254	// triangle fan or triangle strip
	255	numFaces = s->indexData->indexCount - 2;
	256	}
	257	facesNode->SetAttribute("count",
	258	StringConverter::toString(numFaces));
	259	// Write each face in turn
	260	ushort i;
	261	unsigned int* pInt;
	262	unsigned short* pShort;
	263	HardwareIndexBufferSharedPtr ibuf = s->indexData->indexBuffer;
	264	if (use32BitIndexes)
	265	{
	266	pInt = static_cast<unsigned int*>(
	267	ibuf->lock(HardwareBuffer::HBL_READ_ONLY));
	268	}
	269	else
	270	{
	271	pShort = static_cast<unsigned short*>(
	272	ibuf->lock(HardwareBuffer::HBL_READ_ONLY));
	273	}
	274	for (i = 0; i < numFaces; ++i)
	275	{
	276	TiXmlElement* faceNode =
	277	facesNode->InsertEndChild(TiXmlElement("face"))->ToElement();
	278	if (use32BitIndexes)
	279	{
	280	faceNode->SetAttribute("v1", StringConverter::toString(*pInt++));
	281	/// Only need all 3 vertex indices if trilist or first face
	282	if (s->operationType == RenderOperation::OT_TRIANGLE_LIST \|\| i == 0)
	283	{
	284	faceNode->SetAttribute("v2", StringConverter::toString(*pInt++));
	285	faceNode->SetAttribute("v3", StringConverter::toString(*pInt++));
	286	}
	287	}
	288	else
	289	{
	290	faceNode->SetAttribute("v1", StringConverter::toString(*pShort++));
	291	/// Only need all 3 vertex indices if trilist or first face
	292	if (s->operationType == RenderOperation::OT_TRIANGLE_LIST \|\| i == 0)
	293	{
	294	faceNode->SetAttribute("v2", StringConverter::toString(*pShort++));
	295	faceNode->SetAttribute("v3", StringConverter::toString(*pShort++));
	296	}
	297	}
	298	}
	299
	300	// M_GEOMETRY chunk (Optional: present only if useSharedVertices = false)
	301	if (!s->useSharedVertices)
	302	{
	303	TiXmlElement* geomNode =
	304	subMeshNode->InsertEndChild(TiXmlElement("geometry"))->ToElement();
	305	writeGeometry(geomNode, s->vertexData);
	306	}
	307
	308	// texture aliases
	309	writeTextureAliases(subMeshNode, s);
	310
	311	// Bone assignments
	312	if (mpMesh->hasSkeleton())
	313	{
	314	SubMesh::BoneAssignmentIterator bi = const_cast<SubMesh*>(s)->getBoneAssignmentIterator();
	315	LogManager::getSingleton().logMessage("Exporting dedicated geometry bone assignments...");
	316
	317	TiXmlElement* boneAssignNode =
	318	subMeshNode->InsertEndChild(TiXmlElement("boneassignments"))->ToElement();
	319	while (bi.hasMoreElements())
	320	{
	321	const VertexBoneAssignment& assign = bi.getNext();
	322	writeBoneAssignment(boneAssignNode, &assign);
	323	}
	324	}
	325	LogManager::getSingleton().logMessage("Dedicated geometry bone assignments exported.");
	326
	327	}
	328	//---------------------------------------------------------------------
	329	void XMLMeshSerializer::writeGeometry(TiXmlElement* mParentNode, const VertexData* vertexData)
	330	{
	331	// Write a vertex buffer per element
	332
	333	TiXmlElement vbNode, vertexNode, *dataNode;
	334
	335	// Set num verts on parent
	336	mParentNode->SetAttribute("vertexcount", StringConverter::toString(vertexData->vertexCount));
	337
	338	VertexDeclaration* decl = vertexData->vertexDeclaration;
	339	VertexBufferBinding* bind = vertexData->vertexBufferBinding;
	340
	341	VertexBufferBinding::VertexBufferBindingMap::const_iterator b, bend;
	342	bend = bind->getBindings().end();
	343	// Iterate over buffers
	344	for(b = bind->getBindings().begin(); b != bend; ++b)
	345	{
	346	vbNode = mParentNode->InsertEndChild(TiXmlElement("vertexbuffer"))->ToElement();
	347	const HardwareVertexBufferSharedPtr vbuf = b->second;
	348	unsigned short bufferIdx = b->first;
	349	// Get all the elements that relate to this buffer
	350	VertexDeclaration::VertexElementList elems = decl->findElementsBySource(bufferIdx);
	351	VertexDeclaration::VertexElementList::iterator i, iend;
	352	iend = elems.end();
	353
	354	// Set up the data access for this buffer (lock read-only)
	355	unsigned char* pVert;
	356	float* pFloat;
	357	ARGB* pColour;
	358
	359	pVert = static_cast<unsigned char*>(
	360	vbuf->lock(HardwareBuffer::HBL_READ_ONLY));
	361
	362	// Skim over the elements to set up the general data
	363	unsigned short numTextureCoords = 0;
	364	for (i = elems.begin(); i != iend; ++i)
	365	{
	366	VertexElement& elem = *i;
	367	switch(elem.getSemantic())
	368	{
	369	case VES_POSITION:
	370	vbNode->SetAttribute("positions","true");
	371	break;
	372	case VES_NORMAL:
	373	vbNode->SetAttribute("normals","true");
	374	break;
	375	case VES_DIFFUSE:
	376	vbNode->SetAttribute("colours_diffuse","true");
	377	break;
	378	case VES_SPECULAR:
	379	vbNode->SetAttribute("colours_specular","true");
	380	break;
	381	case VES_TEXTURE_COORDINATES:
	382	vbNode->SetAttribute(
	383	"texture_coord_dimensions_" + StringConverter::toString(numTextureCoords),
	384	StringConverter::toString(VertexElement::getTypeCount(elem.getType())));
	385	++numTextureCoords;
	386	break;
	387	default:
	388	break;
	389	}
	390	}
	391	if (numTextureCoords > 0)
	392	{
	393	vbNode->SetAttribute("texture_coords",
	394	StringConverter::toString(numTextureCoords));
	395	}
	396
	397	// For each vertex
	398	for (size_t v = 0; v < vertexData->vertexCount; ++v)
	399	{
	400	vertexNode =
	401	vbNode->InsertEndChild(TiXmlElement("vertex"))->ToElement();
	402	// Iterate over the elements
	403	for (i = elems.begin(); i != iend; ++i)
	404	{
	405	VertexElement& elem = *i;
	406	switch(elem.getSemantic())
	407	{
	408	case VES_POSITION:
	409	elem.baseVertexPointerToElement(pVert, &pFloat);
	410	dataNode =
	411	vertexNode->InsertEndChild(TiXmlElement("position"))->ToElement();
	412	dataNode->SetAttribute("x", StringConverter::toString(pFloat[0]));
	413	dataNode->SetAttribute("y", StringConverter::toString(pFloat[1]));
	414	dataNode->SetAttribute("z", StringConverter::toString(pFloat[2]));
	415	break;
	416	case VES_NORMAL:
	417	elem.baseVertexPointerToElement(pVert, &pFloat);
	418	dataNode =
	419	vertexNode->InsertEndChild(TiXmlElement("normal"))->ToElement();
	420	dataNode->SetAttribute("x", StringConverter::toString(pFloat[0]));
	421	dataNode->SetAttribute("y", StringConverter::toString(pFloat[1]));
	422	dataNode->SetAttribute("z", StringConverter::toString(pFloat[2]));
	423	break;
	424	case VES_DIFFUSE:
	425	elem.baseVertexPointerToElement(pVert, &pColour);
	426	dataNode =
	427	vertexNode->InsertEndChild(TiXmlElement("colour_diffuse"))->ToElement();
	428	{
	429	ARGB rc = *pColour++;
	430	ColourValue cv;
	431	cv.b = (rc & 0xFF) / 255.0f; rc >>= 8;
	432	cv.g = (rc & 0xFF) / 255.0f; rc >>= 8;
	433	cv.r = (rc & 0xFF) / 255.0f; rc >>= 8;
	434	cv.a = (rc & 0xFF) / 255.0f;
	435	dataNode->SetAttribute("value", StringConverter::toString(cv));
	436	}
	437	break;
	438	case VES_SPECULAR:
	439	elem.baseVertexPointerToElement(pVert, &pColour);
	440	dataNode =
	441	vertexNode->InsertEndChild(TiXmlElement("colour_specular"))->ToElement();
	442	{
	443	ARGB rc = *pColour++;
	444	ColourValue cv;
	445	cv.b = (rc & 0xFF) / 255.0f; rc >>= 8;
	446	cv.g = (rc & 0xFF) / 255.0f; rc >>= 8;
	447	cv.r = (rc & 0xFF) / 255.0f; rc >>= 8;
	448	cv.a = (rc & 0xFF) / 255.0f;
	449	dataNode->SetAttribute("value", StringConverter::toString(cv));
	450	}
	451	break;
	452	case VES_TEXTURE_COORDINATES:
	453	elem.baseVertexPointerToElement(pVert, &pFloat);
	454	dataNode =
	455	vertexNode->InsertEndChild(TiXmlElement("texcoord"))->ToElement();
	456
	457	switch(elem.getType())
	458	{
	459	case VET_FLOAT1:
	460	dataNode->SetAttribute("u", StringConverter::toString(*pFloat++));
	461	break;
	462	case VET_FLOAT2:
	463	dataNode->SetAttribute("u", StringConverter::toString(*pFloat++));
	464	dataNode->SetAttribute("v", StringConverter::toString(*pFloat++));
	465	break;
	466	case VET_FLOAT3:
	467	dataNode->SetAttribute("u", StringConverter::toString(*pFloat++));
	468	dataNode->SetAttribute("v", StringConverter::toString(*pFloat++));
	469	dataNode->SetAttribute("w", StringConverter::toString(*pFloat++));
	470	break;
	471	default:
	472	break;
	473	}
	474	break;
	475	default:
	476	break;
	477
	478	}
	479	}
	480	pVert += vbuf->getVertexSize();
	481	}
	482	vbuf->unlock();
	483	}
	484
	485	getchar();
	486
	487	}
	488	//---------------------------------------------------------------------
	489	void XMLMeshSerializer::writeSkeletonLink(TiXmlElement* mMeshNode, const String& skelName)
	490	{
	491
	492	TiXmlElement* skelNode =
	493	mMeshNode->InsertEndChild(TiXmlElement("skeletonlink"))->ToElement();
	494	skelNode->SetAttribute("name", skelName);
	495	}
	496	//---------------------------------------------------------------------
	497	void XMLMeshSerializer::writeBoneAssignment(TiXmlElement* mBoneAssignNode, const VertexBoneAssignment* assign)
	498	{
	499	TiXmlElement* assignNode =
	500	mBoneAssignNode->InsertEndChild(
	501	TiXmlElement("vertexboneassignment"))->ToElement();
	502
	503	assignNode->SetAttribute("vertexindex",
	504	StringConverter::toString(assign->vertexIndex));
	505	assignNode->SetAttribute("boneindex",
	506	StringConverter::toString(assign->boneIndex));
	507	assignNode->SetAttribute("weight",
	508	StringConverter::toString(assign->weight));
	509
	510
	511	}
	512	//---------------------------------------------------------------------
	513	void XMLMeshSerializer::writeTextureAliases(TiXmlElement* mSubmeshesNode, const SubMesh* subMesh)
	514	{
	515	if (!subMesh->hasTextureAliases())
	516	return; // do nothing
	517
	518	TiXmlElement* textureAliasesNode =
	519	mSubmeshesNode->InsertEndChild(TiXmlElement("textures"))->ToElement();
	520
	521	// use ogre map iterator
	522	SubMesh::AliasTextureIterator aliasIterator = subMesh->getAliasTextureIterator();
	523
	524	while (aliasIterator.hasMoreElements())
	525	{
	526	TiXmlElement* aliasTextureNode =
	527	textureAliasesNode->InsertEndChild(TiXmlElement("texture"))->ToElement();
	528	// iterator key is alias and value is texture name
	529	aliasTextureNode->SetAttribute("alias", aliasIterator.peekNextKey());
	530	aliasTextureNode->SetAttribute("name", aliasIterator.peekNextValue());
	531	aliasIterator.moveNext();
	532	}
	533
	534	}
	535	//---------------------------------------------------------------------
	536	void XMLMeshSerializer::readSubMeshes(TiXmlElement* mSubmeshesNode)
	537	{
	538	LogManager::getSingleton().logMessage("Reading submeshes...");
	539
	540	for (TiXmlElement* smElem = mSubmeshesNode->FirstChildElement();
	541	smElem != 0; smElem = smElem->NextSiblingElement())
	542	{
	543	// All children should be submeshes
	544	SubMesh* sm = mpMesh->createSubMesh();
	545
	546	const char* mat = smElem->Attribute("material");
	547	if (mat)
	548	sm->setMaterialName(mat);
	549
	550	// Read operation type
	551	const char* optype = smElem->Attribute("operationtype");
	552	if (optype)
	553	{
	554	if (!strcmp(optype, "triangle_list"))
	555	{
	556	sm->operationType = RenderOperation::OT_TRIANGLE_LIST;
	557	}
	558	else if (!strcmp(optype, "triangle_fan"))
	559	{
	560	sm->operationType = RenderOperation::OT_TRIANGLE_FAN;
	561	}
	562	else if (!strcmp(optype, "triangle_strip"))
	563	{
	564	sm->operationType = RenderOperation::OT_TRIANGLE_STRIP;
	565	}
	566
	567	}
	568
	569	const char* tmp = smElem->Attribute("usesharedvertices");
	570	if (tmp)
	571	sm->useSharedVertices = StringConverter::parseBool(tmp);
	572	tmp = smElem->Attribute("use32bitindexes");
	573	bool use32BitIndexes = false;
	574	if (tmp)
	575	use32BitIndexes = StringConverter::parseBool(tmp);
	576
	577	// Faces
	578	TiXmlElement* faces = smElem->FirstChildElement("faces");
	579	if (sm->operationType == RenderOperation::OT_TRIANGLE_LIST)
	580	{
	581	// tri list
	582	sm->indexData->indexCount =
	583	StringConverter::parseInt(faces->Attribute("count")) * 3;
	584	}
	585	else
	586	{
	587	// tri strip or fan
	588	sm->indexData->indexCount =
	589	StringConverter::parseInt(faces->Attribute("count")) + 2;
	590	}
	591
	592	// Allocate space
	593	HardwareIndexBufferSharedPtr ibuf = HardwareBufferManager::getSingleton().
	594	createIndexBuffer(
	595	use32BitIndexes? HardwareIndexBuffer::IT_32BIT : HardwareIndexBuffer::IT_16BIT,
	596	sm->indexData->indexCount,
	597	HardwareBuffer::HBU_DYNAMIC,
	598	false);
	599	sm->indexData->indexBuffer = ibuf;
	600	unsigned int *pInt;
	601	unsigned short *pShort;
	602	if (use32BitIndexes)
	603	{
	604	pInt = static_cast<unsigned int*>(
	605	ibuf->lock(HardwareBuffer::HBL_DISCARD));
	606	}
	607	else
	608	{
	609	pShort = static_cast<unsigned short*>(
	610	ibuf->lock(HardwareBuffer::HBL_DISCARD));
	611	}
	612	TiXmlElement* faceElem;
	613	bool firstTri = true;
	614	for (faceElem = faces->FirstChildElement();
	615	faceElem != 0; faceElem = faceElem->NextSiblingElement())
	616	{
	617	if (use32BitIndexes)
	618	{
	619	*pInt++ = StringConverter::parseInt(faceElem->Attribute("v1"));
	620	// only need all 3 vertices if it's a trilist or first tri
	621	if (sm->operationType == RenderOperation::OT_TRIANGLE_LIST \|\| firstTri)
	622	{
	623	*pInt++ = StringConverter::parseInt(faceElem->Attribute("v2"));
	624	*pInt++ = StringConverter::parseInt(faceElem->Attribute("v3"));
	625	}
	626	}
	627	else
	628	{
	629	*pShort++ = StringConverter::parseInt(faceElem->Attribute("v1"));
	630	// only need all 3 vertices if it's a trilist or first tri
	631	if (sm->operationType == RenderOperation::OT_TRIANGLE_LIST \|\| firstTri)
	632	{
	633	*pShort++ = StringConverter::parseInt(faceElem->Attribute("v2"));
	634	*pShort++ = StringConverter::parseInt(faceElem->Attribute("v3"));
	635	}
	636	}
	637	firstTri = false;
	638	}
	639	ibuf->unlock();
	640
	641	// Geometry
	642	if (!sm->useSharedVertices)
	643	{
	644	TiXmlElement* geomNode = smElem->FirstChildElement("geometry");
	645	if (geomNode)
	646	{
	647	sm->vertexData = new VertexData();
	648	readGeometry(geomNode, sm->vertexData);
	649	}
	650	}
	651
	652	// texture aliases
	653	TiXmlElement* textureAliasesNode = smElem->FirstChildElement("textures");
	654	if(textureAliasesNode)
	655	readTextureAliases(textureAliasesNode, sm);
	656
	657	// Bone assignments
	658	TiXmlElement* boneAssigns = smElem->FirstChildElement("boneassignments");
	659	if(boneAssigns)
	660	readBoneAssignments(boneAssigns, sm);
	661
	662	}
	663	LogManager::getSingleton().logMessage("Submeshes done.");
	664	}
	665	//---------------------------------------------------------------------
	666	void XMLMeshSerializer::readGeometry(TiXmlElement* mGeometryNode, VertexData* vertexData)
	667	{
	668	LogManager::getSingleton().logMessage("Reading geometry...");
	669	unsigned char *pVert;
	670	float *pFloat;
	671	ARGB *pCol;
	672
	673	vertexData->vertexCount = StringConverter::parseInt(mGeometryNode->Attribute("vertexcount"));
	674	// Skip empty
	675	if (vertexData->vertexCount <= 0) return;
	676
	677
	678	VertexDeclaration* decl = vertexData->vertexDeclaration;
	679	VertexBufferBinding* bind = vertexData->vertexBufferBinding;
	680	unsigned short bufCount = 0;
	681	unsigned short totalTexCoords = 0; // across all buffers
	682
	683	// Information for calculating bounds
	684	Vector3 min, max, pos;
	685	Real maxSquaredRadius = -1;
	686	bool first = true;
	687
	688	// Iterate over all children (vertexbuffer entries)
	689	for (TiXmlElement* vbElem = mGeometryNode->FirstChildElement();
	690	vbElem != 0; vbElem = vbElem->NextSiblingElement())
	691	{
	692	size_t offset = 0;
	693	// Skip non-vertexbuffer elems
	694	if (stricmp(vbElem->Value(), "vertexbuffer")) continue;
	695
	696	const char* attrib = vbElem->Attribute("positions");
	697	if (attrib && StringConverter::parseBool(attrib))
	698	{
	699	// Add element
	700	decl->addElement(bufCount, offset, VET_FLOAT3, VES_POSITION);
	701	offset += VertexElement::getTypeSize(VET_FLOAT3);
	702	}
	703	attrib = vbElem->Attribute("normals");
	704	if (attrib && StringConverter::parseBool(attrib))
	705	{
	706	// Add element
	707	decl->addElement(bufCount, offset, VET_FLOAT3, VES_NORMAL);
	708	offset += VertexElement::getTypeSize(VET_FLOAT3);
	709	}
	710	attrib = vbElem->Attribute("colours_diffuse");
	711	if (attrib && StringConverter::parseBool(attrib))
	712	{
	713	// Add element
	714	decl->addElement(bufCount, offset, mColourElementType, VES_DIFFUSE);
	715	offset += VertexElement::getTypeSize(mColourElementType);
	716	}
	717	attrib = vbElem->Attribute("colours_specular");
	718	if (attrib && StringConverter::parseBool(attrib))
	719	{
	720	// Add element
	721	decl->addElement(bufCount, offset, mColourElementType, VES_SPECULAR);
	722	offset += VertexElement::getTypeSize(mColourElementType);
	723	}
	724	attrib = vbElem->Attribute("texture_coords");
	725	if (attrib && StringConverter::parseInt(attrib))
	726	{
	727	unsigned short numTexCoords = StringConverter::parseInt(vbElem->Attribute("texture_coords"));
	728	for (unsigned short tx = 0; tx < numTexCoords; ++tx)
	729	{
	730	// NB set is local to this buffer, but will be translated into a
	731	// global set number across all vertex buffers
	732	attrib = vbElem->Attribute("texture_coord_dimensions_" + StringConverter::toString(tx));
	733	unsigned short dims;
	734	if (attrib)
	735	{
	736	dims = StringConverter::parseInt(attrib);
	737	}
	738	else
	739	{
	740	// Default
	741	dims = 2;
	742	}
	743	// Add element
	744	VertexElementType vtype = VertexElement::multiplyTypeCount(VET_FLOAT1, dims);
	745	decl->addElement(bufCount, offset, vtype,
	746	VES_TEXTURE_COORDINATES, totalTexCoords++);
	747	offset += VertexElement::getTypeSize(vtype);
	748	}
	749	}
	750	// Now create the vertex buffer
	751	HardwareVertexBufferSharedPtr vbuf = HardwareBufferManager::getSingleton().
	752	createVertexBuffer(offset, vertexData->vertexCount,
	753	HardwareBuffer::HBU_STATIC_WRITE_ONLY, false);
	754	// Bind it
	755	bind->setBinding(bufCount, vbuf);
	756	// Lock it
	757	pVert = static_cast<unsigned char*>(
	758	vbuf->lock(HardwareBuffer::HBL_DISCARD));
	759
	760	// Get the element list for this buffer alone
	761	VertexDeclaration::VertexElementList elems = decl->findElementsBySource(bufCount);
	762	// Now the buffer is set up, parse all the vertices
	763	for (TiXmlElement* vertexElem = vbElem->FirstChildElement();
	764	vertexElem != 0; vertexElem = vertexElem->NextSiblingElement())
	765	{
	766	// Now parse the elements, ensure they are all matched
	767	VertexDeclaration::VertexElementList::const_iterator ielem, ielemend;
	768	TiXmlElement* xmlElem;
	769	TiXmlElement* texCoordElem = 0;
	770	ielemend = elems.end();
	771	for (ielem = elems.begin(); ielem != ielemend; ++ielem)
	772	{
	773	const VertexElement& elem = *ielem;
	774	// Find child for this element
	775	switch(elem.getSemantic())
	776	{
	777	case VES_POSITION:
	778	xmlElem = vertexElem->FirstChildElement("position");
	779	if (!xmlElem)
	780	{
	781	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Missing <position> element.",
	782	"XMLSerializer::readGeometry");
	783	}
	784	elem.baseVertexPointerToElement(pVert, &pFloat);
	785
	786	*pFloat++ = StringConverter::parseReal(
	787	xmlElem->Attribute("x"));
	788	*pFloat++ = StringConverter::parseReal(
	789	xmlElem->Attribute("y"));
	790	*pFloat++ = StringConverter::parseReal(
	791	xmlElem->Attribute("z"));
	792
	793	pos.x = StringConverter::parseReal(
	794	xmlElem->Attribute("x"));
	795	pos.y = StringConverter::parseReal(
	796	xmlElem->Attribute("y"));
	797	pos.z = StringConverter::parseReal(
	798	xmlElem->Attribute("z"));
	799
	800	if (first)
	801	{
	802	min = max = pos;
	803	maxSquaredRadius = pos.squaredLength();
	804	first = false;
	805	}
	806	else
	807	{
	808	min.makeFloor(pos);
	809	max.makeCeil(pos);
	810	maxSquaredRadius = std::max(pos.squaredLength(), maxSquaredRadius);
	811	}
	812	break;
	813	case VES_NORMAL:
	814	xmlElem = vertexElem->FirstChildElement("normal");
	815	if (!xmlElem)
	816	{
	817	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Missing <normal> element.",
	818	"XMLSerializer::readGeometry");
	819	}
	820	elem.baseVertexPointerToElement(pVert, &pFloat);
	821
	822	*pFloat++ = StringConverter::parseReal(
	823	xmlElem->Attribute("x"));
	824	*pFloat++ = StringConverter::parseReal(
	825	xmlElem->Attribute("y"));
	826	*pFloat++ = StringConverter::parseReal(
	827	xmlElem->Attribute("z"));
	828	break;
	829	case VES_DIFFUSE:
	830	xmlElem = vertexElem->FirstChildElement("colour_diffuse");
	831	if (!xmlElem)
	832	{
	833	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Missing <colour_diffuse> element.",
	834	"XMLSerializer::readGeometry");
	835	}
	836	elem.baseVertexPointerToElement(pVert, &pCol);
	837	{
	838	ColourValue cv;
	839	cv = StringConverter::parseColourValue(
	840	xmlElem->Attribute("value"));
	841	*pCol++ = VertexElement::convertColourValue(cv, mColourElementType);
	842	}
	843	break;
	844	case VES_SPECULAR:
	845	xmlElem = vertexElem->FirstChildElement("colour_specular");
	846	if (!xmlElem)
	847	{
	848	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Missing <colour_specular> element.",
	849	"XMLSerializer::readGeometry");
	850	}
	851	elem.baseVertexPointerToElement(pVert, &pCol);
	852	{
	853	ColourValue cv;
	854	cv = StringConverter::parseColourValue(
	855	xmlElem->Attribute("value"));
	856	*pCol++ = VertexElement::convertColourValue(cv, mColourElementType);
	857	}
	858	break;
	859	case VES_TEXTURE_COORDINATES:
	860	if (!texCoordElem)
	861	{
	862	// Get first texcoord
	863	xmlElem = vertexElem->FirstChildElement("texcoord");
	864	}
	865	else
	866	{
	867	// Get next texcoord
	868	xmlElem = texCoordElem->NextSiblingElement("texcoord");
	869	}
	870	if (!xmlElem)
	871	{
	872	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Missing <texcoord> element.",
	873	"XMLSerializer::readGeometry");
	874	}
	875	// Record the latest texture coord entry
	876	texCoordElem = xmlElem;
	877	elem.baseVertexPointerToElement(pVert, &pFloat);
	878
	879	*pFloat++ = StringConverter::parseReal(
	880	xmlElem->Attribute("u"));
	881	if (VertexElement::getTypeCount(elem.getType()) > 1)
	882	{
	883	*pFloat++ = StringConverter::parseReal(
	884	xmlElem->Attribute("v"));
	885	}
	886	if (VertexElement::getTypeCount(elem.getType()) > 2)
	887	{
	888	*pFloat++ = StringConverter::parseReal(
	889	xmlElem->Attribute("w"));
	890	}
	891
	892	break;
	893	default:
	894	break;
	895	}
	896	} // semantic
	897	pVert += vbuf->getVertexSize();
	898	} // vertex
	899	bufCount++;
	900	vbuf->unlock();
	901	} // vertexbuffer
	902
	903	// Set bounds
	904	const AxisAlignedBox& currBox = mpMesh->getBounds();
	905	Real currRadius = mpMesh->getBoundingSphereRadius();
	906	if (currBox.isNull())
	907	{
	908	//do not pad the bounding box
	909	mpMesh->_setBounds(AxisAlignedBox(min, max), false);
	910	mpMesh->_setBoundingSphereRadius(Math::Sqrt(maxSquaredRadius));
	911	}
	912	else
	913	{
	914	AxisAlignedBox newBox(min, max);
	915	newBox.merge(currBox);
	916	//do not pad the bounding box
	917	mpMesh->_setBounds(newBox, false);
	918	mpMesh->_setBoundingSphereRadius(std::max(Math::Sqrt(maxSquaredRadius), currRadius));
	919	}
	920
	921
	922	LogManager::getSingleton().logMessage("Geometry done...");
	923	}
	924	//---------------------------------------------------------------------
	925	void XMLMeshSerializer::readSkeletonLink(TiXmlElement* mSkelNode)
	926	{
	927	mpMesh->setSkeletonName(mSkelNode->Attribute("name"));
	928	}
	929	//---------------------------------------------------------------------
	930	void XMLMeshSerializer::readBoneAssignments(TiXmlElement* mBoneAssignmentsNode)
	931	{
	932	LogManager::getSingleton().logMessage("Reading bone assignments...");
	933
	934	// Iterate over all children (vertexboneassignment entries)
	935	for (TiXmlElement* elem = mBoneAssignmentsNode->FirstChildElement();
	936	elem != 0; elem = elem->NextSiblingElement())
	937	{
	938	VertexBoneAssignment vba;
	939	vba.vertexIndex = StringConverter::parseInt(
	940	elem->Attribute("vertexindex"));
	941	vba.boneIndex = StringConverter::parseInt(
	942	elem->Attribute("boneindex"));
	943	vba.weight= StringConverter::parseReal(
	944	elem->Attribute("weight"));
	945
	946	mpMesh->addBoneAssignment(vba);
	947	}
	948
	949	LogManager::getSingleton().logMessage("Bone assignments done.");
	950	}
	951	//---------------------------------------------------------------------
	952	void XMLMeshSerializer::readTextureAliases(TiXmlElement* mTextureAliasesNode, SubMesh* subMesh)
	953	{
	954	LogManager::getSingleton().logMessage("Reading sub mesh texture aliases...");
	955
	956	// Iterate over all children (texture entries)
	957	for (TiXmlElement* elem = mTextureAliasesNode->FirstChildElement();
	958	elem != 0; elem = elem->NextSiblingElement())
	959	{
	960	// pass alias and texture name to submesh
	961	// read attribute "alias"
	962	String alias = elem->Attribute("alias");
	963	// read attribute "name"
	964	String name = elem->Attribute("name");
	965
	966	subMesh->addTextureAlias(alias, name);
	967	}
	968
	969	LogManager::getSingleton().logMessage("Texture aliases done.");
	970	}
	971	//---------------------------------------------------------------------
	972	void XMLMeshSerializer::readSubMeshNames(TiXmlElement* mMeshNamesNode, Mesh *sm)
	973	{
	974	LogManager::getSingleton().logMessage("Reading mesh names...");
	975
	976	// Iterate over all children (vertexboneassignment entries)
	977	for (TiXmlElement* elem = mMeshNamesNode->FirstChildElement();
	978	elem != 0; elem = elem->NextSiblingElement())
	979	{
	980	String meshName = elem->Attribute("name");
	981	int index = StringConverter::parseInt(elem->Attribute("index"));
	982
	983	sm->nameSubMesh(meshName, index);
	984	}
	985
	986	LogManager::getSingleton().logMessage("Mesh names done.");
	987	}
	988	//---------------------------------------------------------------------
	989	void XMLMeshSerializer::readBoneAssignments(TiXmlElement* mBoneAssignmentsNode, SubMesh* sm)
	990	{
	991	LogManager::getSingleton().logMessage("Reading bone assignments...");
	992	// Iterate over all children (vertexboneassignment entries)
	993	for (TiXmlElement* elem = mBoneAssignmentsNode->FirstChildElement();
	994	elem != 0; elem = elem->NextSiblingElement())
	995	{
	996	VertexBoneAssignment vba;
	997	vba.vertexIndex = StringConverter::parseInt(
	998	elem->Attribute("vertexindex"));
	999	vba.boneIndex = StringConverter::parseInt(
	1000	elem->Attribute("boneindex"));
	1001	vba.weight= StringConverter::parseReal(
	1002	elem->Attribute("weight"));
	1003
	1004	sm->addBoneAssignment(vba);
	1005	}
	1006	LogManager::getSingleton().logMessage("Bone assignments done.");
	1007	}
	1008	//---------------------------------------------------------------------
	1009	void XMLMeshSerializer::writeLodInfo(TiXmlElement* mMeshNode, const Mesh* pMesh)
	1010	{
	1011	TiXmlElement* lodNode =
	1012	mMeshNode->InsertEndChild(TiXmlElement("levelofdetail"))->ToElement();
	1013
	1014	unsigned short numLvls = pMesh->getNumLodLevels();
	1015	bool manual = pMesh->isLodManual();
	1016	lodNode->SetAttribute("numlevels", StringConverter::toString(numLvls));
	1017	lodNode->SetAttribute("manual", StringConverter::toString(manual));
	1018
	1019	// Iterate from level 1, not 0 (full detail)
	1020	for (unsigned short i = 1; i < numLvls; ++i)
	1021	{
	1022	const MeshLodUsage& usage = pMesh->getLodLevel(i);
	1023	if (manual)
	1024	{
	1025	writeLodUsageManual(lodNode, i, usage);
	1026	}
	1027	else
	1028	{
	1029	writeLodUsageGenerated(lodNode, i, usage, pMesh);
	1030	}
	1031	}
	1032
	1033	}
	1034	//---------------------------------------------------------------------
	1035	void XMLMeshSerializer::writeSubMeshNames(TiXmlElement* mMeshNode, const Mesh* m)
	1036	{
	1037	const Mesh::SubMeshNameMap& nameMap = m->getSubMeshNameMap();
	1038	if (nameMap.empty())
	1039	return; // do nothing
	1040
	1041	TiXmlElement* namesNode =
	1042	mMeshNode->InsertEndChild(TiXmlElement("submeshnames"))->ToElement();
	1043	Mesh::SubMeshNameMap::const_iterator i, iend;
	1044	iend = nameMap.end();
	1045	for (i = nameMap.begin(); i != iend; ++i)
	1046	{
	1047	TiXmlElement* subNameNode =
	1048	namesNode->InsertEndChild(TiXmlElement("submeshname"))->ToElement();
	1049
	1050	subNameNode->SetAttribute("name", i->first);
	1051	subNameNode->SetAttribute("index",
	1052	StringConverter::toString(i->second));
	1053	}
	1054
	1055	}
	1056	//---------------------------------------------------------------------
	1057	void XMLMeshSerializer::writeLodUsageManual(TiXmlElement* usageNode,
	1058	unsigned short levelNum, const MeshLodUsage& usage)
	1059	{
	1060	TiXmlElement* manualNode =
	1061	usageNode->InsertEndChild(TiXmlElement("lodmanual"))->ToElement();
	1062
	1063	manualNode->SetAttribute("fromdepthsquared",
	1064	StringConverter::toString(usage.fromDepthSquared));
	1065	manualNode->SetAttribute("meshname", usage.manualName);
	1066
	1067	}
	1068	//---------------------------------------------------------------------
	1069	void XMLMeshSerializer::writeLodUsageGenerated(TiXmlElement* usageNode,
	1070	unsigned short levelNum, const MeshLodUsage& usage,
	1071	const Mesh* pMesh)
	1072	{
	1073	TiXmlElement* generatedNode =
	1074	usageNode->InsertEndChild(TiXmlElement("lodgenerated"))->ToElement();
	1075	generatedNode->SetAttribute("fromdepthsquared",
	1076	StringConverter::toString(usage.fromDepthSquared));
	1077
	1078	// Iterate over submeshes at this level
	1079	unsigned short numsubs = pMesh->getNumSubMeshes();
	1080
	1081	for (unsigned short subi = 0; subi < numsubs; ++subi)
	1082	{
	1083	TiXmlElement* subNode =
	1084	generatedNode->InsertEndChild(TiXmlElement("lodfacelist"))->ToElement();
	1085	SubMesh* sub = pMesh->getSubMesh(subi);
	1086	subNode->SetAttribute("submeshindex", StringConverter::toString(subi));
	1087	// NB level - 1 because SubMeshes don't store the first index in geometry
	1088	IndexData* facedata = sub->mLodFaceList[levelNum - 1];
	1089	subNode->SetAttribute("numfaces", StringConverter::toString(facedata->indexCount / 3));
	1090
	1091	// Write each face in turn
	1092	bool use32BitIndexes = (facedata->indexBuffer->getType() == HardwareIndexBuffer::IT_32BIT);
	1093
	1094	// Write each face in turn
	1095	unsigned int* pInt;
	1096	unsigned short* pShort;
	1097	HardwareIndexBufferSharedPtr ibuf = facedata->indexBuffer;
	1098	if (use32BitIndexes)
	1099	{
	1100	pInt = static_cast<unsigned int*>(
	1101	ibuf->lock(HardwareBuffer::HBL_READ_ONLY));
	1102	}
	1103	else
	1104	{
	1105	pShort = static_cast<unsigned short*>(
	1106	ibuf->lock(HardwareBuffer::HBL_READ_ONLY));
	1107	}
	1108
	1109	for (size_t f = 0; f < facedata->indexCount; f += 3)
	1110	{
	1111	TiXmlElement* faceNode =
	1112	subNode->InsertEndChild(TiXmlElement("face"))->ToElement();
	1113	if (use32BitIndexes)
	1114	{
	1115	faceNode->SetAttribute("v1", StringConverter::toString(*pInt++));
	1116	faceNode->SetAttribute("v2", StringConverter::toString(*pInt++));
	1117	faceNode->SetAttribute("v3", StringConverter::toString(*pInt++));
	1118	}
	1119	else
	1120	{
	1121	faceNode->SetAttribute("v1", StringConverter::toString(*pShort++));
	1122	faceNode->SetAttribute("v2", StringConverter::toString(*pShort++));
	1123	faceNode->SetAttribute("v3", StringConverter::toString(*pShort++));
	1124	}
	1125
	1126	}
	1127
	1128
	1129
	1130	}
	1131
	1132	}
	1133	//---------------------------------------------------------------------
	1134	void XMLMeshSerializer::readLodInfo(TiXmlElement* lodNode)
	1135	{
	1136
	1137	LogManager::getSingleton().logMessage("Parsing LOD information...");
	1138
	1139	const char* val = lodNode->Attribute("numlevels");
	1140	unsigned short numLevels = static_cast<unsigned short>(
	1141	StringConverter::parseUnsignedInt(val));
	1142
	1143	val = lodNode->Attribute("manual");
	1144	bool manual = StringConverter::parseBool(val);
	1145
	1146	// Set up the basic structures
	1147	mpMesh->_setLodInfo(numLevels, manual);
	1148
	1149	// Parse the detail, start from 1 (the first sub-level of detail)
	1150	unsigned short i = 1;
	1151	TiXmlElement* usageElem;
	1152	if (manual)
	1153	{
	1154	usageElem = lodNode->FirstChildElement("lodmanual");
	1155	}
	1156	else
	1157	{
	1158	usageElem = lodNode->FirstChildElement("lodgenerated");
	1159	}
	1160	while (usageElem)
	1161	{
	1162	if (manual)
	1163	{
	1164	readLodUsageManual(usageElem, i);
	1165	usageElem = usageElem->NextSiblingElement();
	1166	}
	1167	else
	1168	{
	1169	readLodUsageGenerated(usageElem, i);
	1170	usageElem = usageElem->NextSiblingElement();
	1171	}
	1172	++i;
	1173	}
	1174
	1175	LogManager::getSingleton().logMessage("LOD information done.");
	1176
	1177	}
	1178	//---------------------------------------------------------------------
	1179	void XMLMeshSerializer::readLodUsageManual(TiXmlElement* manualNode, unsigned short index)
	1180	{
	1181	MeshLodUsage usage;
	1182	const char* val = manualNode->Attribute("fromdepthsquared");
	1183	usage.fromDepthSquared = StringConverter::parseReal(val);
	1184	usage.manualName = manualNode->Attribute("meshname");
	1185	usage.edgeData = NULL;
	1186
	1187	mpMesh->_setLodUsage(index, usage);
	1188	}
	1189	//---------------------------------------------------------------------
	1190	void XMLMeshSerializer::readLodUsageGenerated(TiXmlElement* genNode, unsigned short index)
	1191	{
	1192	MeshLodUsage usage;
	1193	const char* val = genNode->Attribute("fromdepthsquared");
	1194	usage.fromDepthSquared = StringConverter::parseReal(val);
	1195	usage.manualMesh.setNull();
	1196	usage.manualName = "";
	1197	usage.edgeData = NULL;
	1198
	1199	mpMesh->_setLodUsage(index, usage);
	1200
	1201	// Read submesh face lists
	1202	TiXmlElement* faceListElem = genNode->FirstChildElement("lodfacelist");
	1203	while (faceListElem)
	1204	{
	1205	val = faceListElem->Attribute("submeshindex");
	1206	unsigned short subidx = StringConverter::parseUnsignedInt(val);
	1207	val = faceListElem->Attribute("numfaces");
	1208	unsigned short numFaces = StringConverter::parseUnsignedInt(val);
	1209	// use of 32bit indexes depends on submesh
	1210	HardwareIndexBuffer::IndexType itype =
	1211	mpMesh->getSubMesh(subidx)->indexData->indexBuffer->getType();
	1212	bool use32bitindexes = (itype == HardwareIndexBuffer::IT_32BIT);
	1213
	1214	// Assign memory: this will be deleted by the submesh
	1215	HardwareIndexBufferSharedPtr ibuf = HardwareBufferManager::getSingleton().
	1216	createIndexBuffer(
	1217	itype, numFaces * 3, HardwareBuffer::HBU_STATIC_WRITE_ONLY);
	1218
	1219	unsigned short *pShort;
	1220	unsigned int *pInt;
	1221	if (use32bitindexes)
	1222	{
	1223	pInt = static_cast<unsigned int*>(
	1224	ibuf->lock(HardwareBuffer::HBL_DISCARD));
	1225	}
	1226	else
	1227	{
	1228	pShort = static_cast<unsigned short*>(
	1229	ibuf->lock(HardwareBuffer::HBL_DISCARD));
	1230	}
	1231	TiXmlElement* faceElem = faceListElem->FirstChildElement("face");
	1232	for (unsigned int face = 0; face < numFaces; ++face, faceElem = faceElem->NextSiblingElement())
	1233	{
	1234	if (use32bitindexes)
	1235	{
	1236	val = faceElem->Attribute("v1");
	1237	*pInt++ = StringConverter::parseUnsignedInt(val);
	1238	val = faceElem->Attribute("v2");
	1239	*pInt++ = StringConverter::parseUnsignedInt(val);
	1240	val = faceElem->Attribute("v3");
	1241	*pInt++ = StringConverter::parseUnsignedInt(val);
	1242	}
	1243	else
	1244	{
	1245	val = faceElem->Attribute("v1");
	1246	*pShort++ = StringConverter::parseUnsignedInt(val);
	1247	val = faceElem->Attribute("v2");
	1248	*pShort++ = StringConverter::parseUnsignedInt(val);
	1249	val = faceElem->Attribute("v3");
	1250	*pShort++ = StringConverter::parseUnsignedInt(val);
	1251	}
	1252
	1253	}
	1254
	1255	ibuf->unlock();
	1256	IndexData* facedata = new IndexData(); // will be deleted by SubMesh
	1257	facedata->indexCount = numFaces * 3;
	1258	facedata->indexStart = 0;
	1259	facedata->indexBuffer = ibuf;
	1260	mpMesh->_setSubMeshLodFaceList(subidx, index, facedata);
	1261
	1262	faceListElem = faceListElem->NextSiblingElement();
	1263	}
	1264
	1265	}
	1266	//-----------------------------------------------------------------------------
	1267	void XMLMeshSerializer::readPoses(TiXmlElement* posesNode, Mesh *m)
	1268	{
	1269	TiXmlElement* poseNode = posesNode->FirstChildElement("pose");
	1270
	1271	while (poseNode)
	1272	{
	1273	const char* target = poseNode->Attribute("target");
	1274	if (!target)
	1275	{
	1276	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	1277	"Required attribute 'target' missing on pose",
	1278	"XMLMeshSerializer::readPoses");
	1279	}
	1280	unsigned short targetID;
	1281	if(target == "mesh")
	1282	{
	1283	targetID = 0;
	1284	}
	1285	else
	1286	{
	1287	// submesh, get index
	1288	const char* val = poseNode->Attribute("index");
	1289	if (!val)
	1290	{
	1291	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	1292	"Required attribute 'index' missing on pose",
	1293	"XMLMeshSerializer::readPoses");
	1294	}
	1295	unsigned short submeshIndex = static_cast<unsigned short>(
	1296	StringConverter::parseUnsignedInt(val));
	1297
	1298	targetID = submeshIndex + 1;
	1299	}
	1300
	1301	String name;
	1302	const char* val = poseNode->Attribute("name");
	1303	if (val)
	1304	name = val;
	1305	Pose* pose = m->createPose(targetID, name);
	1306
	1307	TiXmlElement* poseOffsetNode = poseNode->FirstChildElement("poseoffset");
	1308	while (poseOffsetNode)
	1309	{
	1310	uint index = StringConverter::parseUnsignedInt(
	1311	poseOffsetNode->Attribute("index"));
	1312	Vector3 offset;
	1313	offset.x = StringConverter::parseReal(poseOffsetNode->Attribute("x"));
	1314	offset.y = StringConverter::parseReal(poseOffsetNode->Attribute("y"));
	1315	offset.z = StringConverter::parseReal(poseOffsetNode->Attribute("z"));
	1316
	1317	pose->addVertex(index, offset);
	1318
	1319	poseOffsetNode = poseOffsetNode->NextSiblingElement();
	1320	}
	1321
	1322	poseNode = poseNode->NextSiblingElement();
	1323
	1324	}
	1325
	1326
	1327	}
	1328	//-----------------------------------------------------------------------------
	1329	void XMLMeshSerializer::readAnimations(TiXmlElement* mAnimationsNode, Mesh *pMesh)
	1330	{
	1331	TiXmlElement* animElem = mAnimationsNode->FirstChildElement("animation");
	1332	while (animElem)
	1333	{
	1334	String name = animElem->Attribute("name");
	1335	const char* charLen = animElem->Attribute("length");
	1336	Real len = StringConverter::parseReal(charLen);
	1337
	1338	Animation* anim = pMesh->createAnimation(name, len);
	1339
	1340	TiXmlElement* tracksNode = animElem->FirstChildElement("tracks");
	1341	if (tracksNode)
	1342	{
	1343	readTracks(tracksNode, pMesh, anim);
	1344	}
	1345
	1346	animElem = animElem->NextSiblingElement();
	1347
	1348	}
	1349
	1350
	1351	}
	1352	//-----------------------------------------------------------------------------
	1353	void XMLMeshSerializer::readTracks(TiXmlElement* tracksNode, Mesh m, Animation anim)
	1354	{
	1355	TiXmlElement* trackNode = tracksNode->FirstChildElement("track");
	1356	while (trackNode)
	1357	{
	1358	String target = trackNode->Attribute("target");
	1359	unsigned short targetID;
	1360	VertexData* vertexData = 0;
	1361	if(target == "mesh")
	1362	{
	1363	targetID = 0;
	1364	vertexData = m->sharedVertexData;
	1365	}
	1366	else
	1367	{
	1368	// submesh, get index
	1369	const char* val = trackNode->Attribute("index");
	1370	if (!val)
	1371	{
	1372	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	1373	"Required attribute 'index' missing on submesh track",
	1374	"XMLMeshSerializer::readTracks");
	1375	}
	1376	unsigned short submeshIndex = static_cast<unsigned short>(
	1377	StringConverter::parseUnsignedInt(val));
	1378
	1379	targetID = submeshIndex + 1;
	1380	vertexData = m->getSubMesh(submeshIndex)->vertexData;
	1381
	1382	}
	1383
	1384	if (!vertexData)
	1385	{
	1386	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	1387	"Track cannot be created for " + target + " since VertexData "
	1388	"does not exist at the specified index",
	1389	"XMLMeshSerializer::readTracks");
	1390	}
	1391
	1392	// Get type
	1393	VertexAnimationType animType = VAT_NONE;
	1394	String strAnimType = trackNode->Attribute("type");
	1395	if (strAnimType == "morph")
	1396	{
	1397	animType = VAT_MORPH;
	1398	}
	1399	else if (strAnimType == "pose")
	1400	{
	1401	animType = VAT_POSE;
	1402	}
	1403	else
	1404	{
	1405	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	1406	"Unrecognised animation track type '" + strAnimType + "'",
	1407	"XMLMeshSerializer::readTracks");
	1408	}
	1409
	1410	// Create track
	1411	VertexAnimationTrack* track =
	1412	anim->createVertexTrack(targetID, vertexData, animType);
	1413
	1414	TiXmlElement* keyframesNode = trackNode->FirstChildElement("keyframes");
	1415	if (keyframesNode)
	1416	{
	1417	if (track->getAnimationType() == VAT_MORPH)
	1418	{
	1419	readMorphKeyFrames(keyframesNode, track, vertexData->vertexCount);
	1420	}
	1421	else // VAT_POSE
	1422	{
	1423	readPoseKeyFrames(keyframesNode, track);
	1424	}
	1425	}
	1426
	1427	trackNode = trackNode->NextSiblingElement();
	1428	}
	1429	}
	1430	//-----------------------------------------------------------------------------
	1431	void XMLMeshSerializer::readMorphKeyFrames(TiXmlElement* keyframesNode,
	1432	VertexAnimationTrack* track, size_t vertexCount)
	1433	{
	1434	TiXmlElement* keyNode = keyframesNode->FirstChildElement("keyframe");
	1435	while (keyNode)
	1436	{
	1437	const char* val = keyNode->Attribute("time");
	1438	if (!val)
	1439	{
	1440	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	1441	"Required attribute 'time' missing on keyframe",
	1442	"XMLMeshSerializer::readKeyFrames");
	1443	}
	1444	Real time = StringConverter::parseReal(val);
	1445
	1446	VertexMorphKeyFrame* kf = track->createVertexMorphKeyFrame(time);
	1447
	1448	// create a vertex buffer
	1449	HardwareVertexBufferSharedPtr vbuf =
	1450	HardwareBufferManager::getSingleton().createVertexBuffer(
	1451	VertexElement::getTypeSize(VET_FLOAT3), vertexCount,
	1452	HardwareBuffer::HBU_STATIC, true);
	1453
	1454	float* pFloat = static_cast<float*>(
	1455	vbuf->lock(HardwareBuffer::HBL_DISCARD));
	1456
	1457
	1458	TiXmlElement* posNode = keyNode->FirstChildElement("position");
	1459	for (size_t v = 0; v < vertexCount; ++v)
	1460	{
	1461	if (!posNode)
	1462	{
	1463	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	1464	"Not enough 'position' elements under keyframe",
	1465	"XMLMeshSerializer::readKeyFrames");
	1466
	1467	}
	1468
	1469	*pFloat++ = StringConverter::parseReal(
	1470	posNode->Attribute("x"));
	1471	*pFloat++ = StringConverter::parseReal(
	1472	posNode->Attribute("y"));
	1473	*pFloat++ = StringConverter::parseReal(
	1474	posNode->Attribute("z"));
	1475
	1476
	1477	posNode = posNode->NextSiblingElement("position");
	1478	}
	1479
	1480	vbuf->unlock();
	1481
	1482	kf->setVertexBuffer(vbuf);
	1483
	1484
	1485	keyNode = keyNode->NextSiblingElement();
	1486	}
	1487
	1488
	1489	}
	1490	//-----------------------------------------------------------------------------
	1491	void XMLMeshSerializer::readPoseKeyFrames(TiXmlElement* keyframesNode, VertexAnimationTrack* track)
	1492	{
	1493	TiXmlElement* keyNode = keyframesNode->FirstChildElement("keyframe");
	1494	while (keyNode)
	1495	{
	1496	const char* val = keyNode->Attribute("time");
	1497	if (!val)
	1498	{
	1499	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	1500	"Required attribute 'time' missing on keyframe",
	1501	"XMLMeshSerializer::readKeyFrames");
	1502	}
	1503	Real time = StringConverter::parseReal(val);
	1504
	1505	VertexPoseKeyFrame* kf = track->createVertexPoseKeyFrame(time);
	1506
	1507	// Read all pose references
	1508	TiXmlElement* poseRefNode = keyNode->FirstChildElement("poseref");
	1509	while (poseRefNode)
	1510	{
	1511	const char* val = poseRefNode->Attribute("poseindex");
	1512	if (!val)
	1513	{
	1514	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	1515	"Required attribute 'poseindex' missing on poseref",
	1516	"XMLMeshSerializer::readPoseKeyFrames");
	1517	}
	1518	unsigned short poseIndex = StringConverter::parseUnsignedInt(val);
	1519	Real influence = 1.0f;
	1520	val = poseRefNode->Attribute("influence");
	1521	if (val)
	1522	{
	1523	influence = StringConverter::parseReal(val);
	1524	}
	1525
	1526	kf->addPoseReference(poseIndex, influence);
	1527
	1528	poseRefNode = poseRefNode->NextSiblingElement();
	1529	}
	1530
	1531	keyNode = keyNode->NextSiblingElement();
	1532	}
	1533
	1534	}
	1535	//-----------------------------------------------------------------------------
	1536	void XMLMeshSerializer::writePoses(TiXmlElement* meshNode, const Mesh* m)
	1537	{
	1538	if (m->getPoseCount() == 0)
	1539	return;
	1540
	1541	TiXmlElement* posesNode =
	1542	meshNode->InsertEndChild(TiXmlElement("poses"))->ToElement();
	1543
	1544	Mesh::ConstPoseIterator poseIt = m->getPoseIterator();
	1545	while (poseIt.hasMoreElements())
	1546	{
	1547	const Pose* pose = poseIt.getNext();
	1548	TiXmlElement* poseNode =
	1549	posesNode->InsertEndChild(TiXmlElement("pose"))->ToElement();
	1550	unsigned short target = pose->getTarget();
	1551	if (target == 0)
	1552	{
	1553	// Main mesh
	1554	poseNode->SetAttribute("target", "mesh");
	1555	}
	1556	else
	1557	{
	1558	// Submesh - rebase index
	1559	poseNode->SetAttribute("target", "submesh");
	1560	poseNode->SetAttribute("index",
	1561	StringConverter::toString(target - 1));
	1562	}
	1563	poseNode->SetAttribute("name", pose->getName());
	1564
	1565	Pose::ConstVertexOffsetIterator vit = pose->getVertexOffsetIterator();
	1566	while (vit.hasMoreElements())
	1567	{
	1568	TiXmlElement* poseOffsetElement = poseNode->InsertEndChild(
	1569	TiXmlElement("poseoffset"))->ToElement();
	1570
	1571	poseOffsetElement->SetAttribute("index",
	1572	StringConverter::toString(vit.peekNextKey()));
	1573
	1574	Vector3 offset = vit.getNext();
	1575	poseOffsetElement->SetAttribute("x", StringConverter::toString(offset.x));
	1576	poseOffsetElement->SetAttribute("y", StringConverter::toString(offset.y));
	1577	poseOffsetElement->SetAttribute("z", StringConverter::toString(offset.z));
	1578
	1579
	1580	}
	1581
	1582	}
	1583
	1584	}
	1585	//-----------------------------------------------------------------------------
	1586	void XMLMeshSerializer::writeAnimations(TiXmlElement* meshNode, const Mesh* m)
	1587	{
	1588	// Skip if no animation
	1589	if (!m->hasVertexAnimation())
	1590	return;
	1591
	1592	TiXmlElement* animationsNode =
	1593	meshNode->InsertEndChild(TiXmlElement("animations"))->ToElement();
	1594
	1595	for (unsigned short a = 0; a < m->getNumAnimations(); ++a)
	1596	{
	1597	Animation* anim = m->getAnimation(a);
	1598
	1599	TiXmlElement* animNode =
	1600	animationsNode->InsertEndChild(TiXmlElement("animation"))->ToElement();
	1601	animNode->SetAttribute("name", anim->getName());
	1602	animNode->SetAttribute("length",
	1603	StringConverter::toString(anim->getLength()));
	1604
	1605	TiXmlElement* tracksNode =
	1606	animNode->InsertEndChild(TiXmlElement("tracks"))->ToElement();
	1607	Animation::VertexTrackIterator iter = anim->getVertexTrackIterator();
	1608	while(iter.hasMoreElements())
	1609	{
	1610	const VertexAnimationTrack* track = iter.getNext();
	1611	TiXmlElement* trackNode =
	1612	tracksNode->InsertEndChild(TiXmlElement("track"))->ToElement();
	1613
	1614	unsigned short targetID = track->getHandle();
	1615	if (targetID == 0)
	1616	{
	1617	trackNode->SetAttribute("target", "mesh");
	1618	}
	1619	else
	1620	{
	1621	trackNode->SetAttribute("target", "submesh");
	1622	trackNode->SetAttribute("index",
	1623	StringConverter::toString(targetID-1));
	1624	}
	1625
	1626	if (track->getAnimationType() == VAT_MORPH)
	1627	{
	1628	trackNode->SetAttribute("type", "morph");
	1629	writeMorphKeyFrames(trackNode, track);
	1630	}
	1631	else
	1632	{
	1633	trackNode->SetAttribute("type", "pose");
	1634	writePoseKeyFrames(trackNode, track);
	1635	}
	1636
	1637
	1638	}
	1639	}
	1640
	1641
	1642	}
	1643	//-----------------------------------------------------------------------------
	1644	void XMLMeshSerializer::writeMorphKeyFrames(TiXmlElement* trackNode, const VertexAnimationTrack* track)
	1645	{
	1646	TiXmlElement* keyframesNode =
	1647	trackNode->InsertEndChild(TiXmlElement("keyframes"))->ToElement();
	1648
	1649	size_t vertexCount = track->getAssociatedVertexData()->vertexCount;
	1650
	1651	for (unsigned short k = 0; k < track->getNumKeyFrames(); ++k)
	1652	{
	1653	VertexMorphKeyFrame* kf = track->getVertexMorphKeyFrame(k);
	1654	TiXmlElement* keyNode =
	1655	keyframesNode->InsertEndChild(TiXmlElement("keyframe"))->ToElement();
	1656	keyNode->SetAttribute("time",
	1657	StringConverter::toString(kf->getTime()));
	1658
	1659	HardwareVertexBufferSharedPtr vbuf = kf->getVertexBuffer();
	1660	float* pFloat = static_cast<float*>(
	1661	vbuf->lock(HardwareBuffer::HBL_READ_ONLY));
	1662
	1663	for (size_t v = 0; v < vertexCount; ++v)
	1664	{
	1665	TiXmlElement* posNode =
	1666	keyNode->InsertEndChild(TiXmlElement("position"))->ToElement();
	1667	posNode->SetAttribute("x", StringConverter::toString(*pFloat++));
	1668	posNode->SetAttribute("y", StringConverter::toString(*pFloat++));
	1669	posNode->SetAttribute("z", StringConverter::toString(*pFloat++));
	1670	}
	1671
	1672	}
	1673	}
	1674	//-----------------------------------------------------------------------------
	1675	void XMLMeshSerializer::writePoseKeyFrames(TiXmlElement* trackNode, const VertexAnimationTrack* track)
	1676	{
	1677	TiXmlElement* keyframesNode =
	1678	trackNode->InsertEndChild(TiXmlElement("keyframes"))->ToElement();
	1679
	1680	for (unsigned short k = 0; k < track->getNumKeyFrames(); ++k)
	1681	{
	1682	VertexPoseKeyFrame* kf = track->getVertexPoseKeyFrame(k);
	1683	TiXmlElement* keyNode =
	1684	keyframesNode->InsertEndChild(TiXmlElement("keyframe"))->ToElement();
	1685	keyNode->SetAttribute("time",
	1686	StringConverter::toString(kf->getTime()));
	1687
	1688	VertexPoseKeyFrame::PoseRefIterator poseIt = kf->getPoseReferenceIterator();
	1689	while (poseIt.hasMoreElements())
	1690	{
	1691	const VertexPoseKeyFrame::PoseRef& poseRef = poseIt.getNext();
	1692	TiXmlElement* poseRefNode =
	1693	keyNode->InsertEndChild(TiXmlElement("poseref"))->ToElement();
	1694
	1695	poseRefNode->SetAttribute("poseindex",
	1696	StringConverter::toString(poseRef.poseIndex));
	1697	poseRefNode->SetAttribute("influence",
	1698	StringConverter::toString(poseRef.influence));
	1699
	1700	}
	1701
	1702	}
	1703
	1704
	1705	}
	1706
	1707
	1708
	1709
	1710	}
	1711

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: GTP/trunk/Lib/Illum/GPUObscurancesGT/src/OgreXMLMeshSerializer.cpp @ 930

Download in other formats: