Context Navigation

OgreMeshSerializerImpl.cpp @ 692

Revision 692, 87.0 KB checked in by mattausch, 19 years ago (diff)
adding ogre 1.2 and dependencies

Rev	Line
[692]	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	#include "OgreStableHeaders.h"
	26
	27	#include "OgreMeshSerializerImpl.h"
	28	#include "OgreMeshFileFormat.h"
	29	#include "OgreMesh.h"
	30	#include "OgreSubMesh.h"
	31	#include "OgreException.h"
	32	#include "OgreLogManager.h"
	33	#include "OgreSkeleton.h"
	34	#include "OgreHardwareBufferManager.h"
	35	#include "OgreMaterial.h"
	36	#include "OgreTechnique.h"
	37	#include "OgrePass.h"
	38	#include "OgreAnimation.h"
	39	#include "OgreAnimationTrack.h"
	40	#include "OgreKeyFrame.h"
	41	#include "OgreRoot.h"
	42
	43	#if OGRE_COMPILER == OGRE_COMPILER_MSVC
	44	// Disable conversion warnings, we do a lot of them, intentionally
	45	# pragma warning (disable : 4267)
	46	#endif
	47
	48
	49	namespace Ogre {
	50
	51	/// stream overhead = ID + size
	52	const long STREAM_OVERHEAD_SIZE = sizeof(uint16) + sizeof(uint32);
	53	//---------------------------------------------------------------------
	54	MeshSerializerImpl::MeshSerializerImpl()
	55	{
	56
	57	// Version number
	58	mVersion = "[MeshSerializer_v1.30]";
	59	}
	60	//---------------------------------------------------------------------
	61	MeshSerializerImpl::~MeshSerializerImpl()
	62	{
	63	}
	64	//---------------------------------------------------------------------
	65	void MeshSerializerImpl::exportMesh(const Mesh* pMesh,
	66	const String& filename, Endian endianMode)
	67	{
	68	LogManager::getSingleton().logMessage("MeshSerializer writing mesh data to " + filename + "...");
	69
	70	// Decide on endian mode
	71	determineEndianness(endianMode);
	72
	73	// Check that the mesh has it's bounds set
	74	if (pMesh->getBounds().isNull() \|\| pMesh->getBoundingSphereRadius() == 0.0f)
	75	{
	76	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "The Mesh you have supplied does not have its"
	77	" bounds completely defined. Define them first before exporting.",
	78	"MeshSerializerImpl::exportMesh");
	79	}
	80	mpfFile = fopen(filename.c_str(), "wb");
	81	if (!mpfFile)
	82	{
	83	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	84	"Unable to open file " + filename + " for writing",
	85	"MeshSerializerImpl::exportMesh");
	86	}
	87
	88	writeFileHeader();
	89	LogManager::getSingleton().logMessage("File header written.");
	90
	91
	92	LogManager::getSingleton().logMessage("Writing mesh data...");
	93	writeMesh(pMesh);
	94	LogManager::getSingleton().logMessage("Mesh data exported.");
	95
	96	fclose(mpfFile);
	97	LogManager::getSingleton().logMessage("MeshSerializer export successful.");
	98	}
	99	//---------------------------------------------------------------------
	100	void MeshSerializerImpl::importMesh(DataStreamPtr& stream, Mesh* pMesh)
	101	{
	102	// Determine endianness (must be the first thing we do!)
	103	determineEndianness(stream);
	104
	105	// Check header
	106	readFileHeader(stream);
	107
	108	unsigned short streamID;
	109	while(!stream->eof())
	110	{
	111	streamID = readChunk(stream);
	112	switch (streamID)
	113	{
	114	case M_MESH:
	115	readMesh(stream, pMesh);
	116	break;
	117	}
	118
	119	}
	120	}
	121	//---------------------------------------------------------------------
	122	void MeshSerializerImpl::writeMesh(const Mesh* pMesh)
	123	{
	124	// Header
	125	writeChunkHeader(M_MESH, calcMeshSize(pMesh));
	126
	127	// bool skeletallyAnimated
	128	bool skelAnim = pMesh->hasSkeleton();
	129	writeBools(&skelAnim, 1);
	130
	131	// Write shared geometry
	132	if (pMesh->sharedVertexData)
	133	writeGeometry(pMesh->sharedVertexData);
	134
	135	// Write Submeshes
	136	for (int i = 0; i < pMesh->getNumSubMeshes(); ++i)
	137	{
	138	LogManager::getSingleton().logMessage("Writing submesh...");
	139	writeSubMesh(pMesh->getSubMesh(i));
	140	LogManager::getSingleton().logMessage("Submesh exported.");
	141	}
	142
	143	// Write skeleton info if required
	144	if (pMesh->hasSkeleton())
	145	{
	146	LogManager::getSingleton().logMessage("Exporting skeleton link...");
	147	// Write skeleton link
	148	writeSkeletonLink(pMesh->getSkeletonName());
	149	LogManager::getSingleton().logMessage("Skeleton link exported.");
	150
	151	// Write bone assignments
	152	if (!pMesh->mBoneAssignments.empty())
	153	{
	154	LogManager::getSingleton().logMessage("Exporting shared geometry bone assignments...");
	155
	156	Mesh::VertexBoneAssignmentList::const_iterator vi;
	157	for (vi = pMesh->mBoneAssignments.begin();
	158	vi != pMesh->mBoneAssignments.end(); ++vi)
	159	{
	160	writeMeshBoneAssignment(vi->second);
	161	}
	162
	163	LogManager::getSingleton().logMessage("Shared geometry bone assignments exported.");
	164	}
	165	}
	166
	167	// Write LOD data if any
	168	if (pMesh->getNumLodLevels() > 1)
	169	{
	170	LogManager::getSingleton().logMessage("Exporting LOD information....");
	171	writeLodInfo(pMesh);
	172	LogManager::getSingleton().logMessage("LOD information exported.");
	173
	174	}
	175	// Write bounds information
	176	LogManager::getSingleton().logMessage("Exporting bounds information....");
	177	writeBoundsInfo(pMesh);
	178	LogManager::getSingleton().logMessage("Bounds information exported.");
	179
	180	// Write submesh name table
	181	LogManager::getSingleton().logMessage("Exporting submesh name table...");
	182	writeSubMeshNameTable(pMesh);
	183	LogManager::getSingleton().logMessage("Submesh name table exported.");
	184
	185	// Write edge lists
	186	if (pMesh->isEdgeListBuilt())
	187	{
	188	LogManager::getSingleton().logMessage("Exporting edge lists...");
	189	writeEdgeList(pMesh);
	190	LogManager::getSingleton().logMessage("Edge lists exported");
	191	}
	192
	193	// Write morph animation
	194	writePoses(pMesh);
	195	if (pMesh->hasVertexAnimation())
	196	{
	197	writeAnimations(pMesh);
	198	}
	199	}
	200	//---------------------------------------------------------------------
	201	// Added by DrEvil
	202	void MeshSerializerImpl::writeSubMeshNameTable(const Mesh* pMesh)
	203	{
	204	// Header
	205	writeChunkHeader(M_SUBMESH_NAME_TABLE, calcSubMeshNameTableSize(pMesh));
	206
	207	// Loop through and save out the index and names.
	208	Mesh::SubMeshNameMap::const_iterator it = pMesh->mSubMeshNameMap.begin();
	209
	210	while(it != pMesh->mSubMeshNameMap.end())
	211	{
	212	// Header
	213	writeChunkHeader(M_SUBMESH_NAME_TABLE_ELEMENT, STREAM_OVERHEAD_SIZE +
	214	sizeof(unsigned short) + (unsigned long)it->first.length() + 1);
	215
	216	// write the index
	217	writeShorts(&it->second, 1);
	218	// name
	219	writeString(it->first);
	220
	221	++it;
	222	}
	223	}
	224	//---------------------------------------------------------------------
	225	void MeshSerializerImpl::writeSubMesh(const SubMesh* s)
	226	{
	227	// Header
	228	writeChunkHeader(M_SUBMESH, calcSubMeshSize(s));
	229
	230	// char* materialName
	231	writeString(s->getMaterialName());
	232
	233	// bool useSharedVertices
	234	writeBools(&s->useSharedVertices, 1);
	235
	236	unsigned int indexCount = s->indexData->indexCount;
	237	writeInts(&indexCount, 1);
	238
	239	// bool indexes32Bit
	240	bool idx32bit = (s->indexData->indexBuffer->getType() == HardwareIndexBuffer::IT_32BIT);
	241	writeBools(&idx32bit, 1);
	242
	243	// unsigned short* faceVertexIndices ((indexCount)
	244	HardwareIndexBufferSharedPtr ibuf = s->indexData->indexBuffer;
	245	void* pIdx = ibuf->lock(HardwareBuffer::HBL_READ_ONLY);
	246	if (idx32bit)
	247	{
	248	unsigned int* pIdx32 = static_cast<unsigned int*>(pIdx);
	249	writeInts(pIdx32, s->indexData->indexCount);
	250	}
	251	else
	252	{
	253	unsigned short* pIdx16 = static_cast<unsigned short*>(pIdx);
	254	writeShorts(pIdx16, s->indexData->indexCount);
	255	}
	256	ibuf->unlock();
	257
	258	// M_GEOMETRY stream (Optional: present only if useSharedVertices = false)
	259	if (!s->useSharedVertices)
	260	{
	261	writeGeometry(s->vertexData);
	262	}
	263
	264	// end of sub mesh chunk
	265
	266	// write out texture alias chunks
	267	writeSubMeshTextureAliases(s);
	268
	269	// Operation type
	270	writeSubMeshOperation(s);
	271
	272	// Bone assignments
	273	if (!s->mBoneAssignments.empty())
	274	{
	275	LogManager::getSingleton().logMessage("Exporting dedicated geometry bone assignments...");
	276
	277	SubMesh::VertexBoneAssignmentList::const_iterator vi;
	278	for (vi = s->mBoneAssignments.begin();
	279	vi != s->mBoneAssignments.end(); ++vi)
	280	{
	281	writeSubMeshBoneAssignment(vi->second);
	282	}
	283
	284	LogManager::getSingleton().logMessage("Dedicated geometry bone assignments exported.");
	285	}
	286
	287
	288	}
	289
	290	//---------------------------------------------------------------------
	291	void MeshSerializerImpl::writeSubMeshTextureAliases(const SubMesh* s)
	292	{
	293	size_t chunkSize;
	294	AliasTextureNamePairList::const_iterator i;
	295
	296	LogManager::getSingleton().logMessage("Exporting submesh texture aliases...");
	297
	298	// iterate through texture aliases and write them out as a chunk
	299	for (i = s->mTextureAliases.begin(); i != s->mTextureAliases.end(); ++i)
	300	{
	301	// calculate chunk size based on string length + 1. Add 1 for the line feed.
	302	chunkSize = STREAM_OVERHEAD_SIZE + i->first.length() + i->second.length() + 2;
	303	writeChunkHeader(M_SUBMESH_TEXTURE_ALIAS, chunkSize);
	304	// write out alias name
	305	writeString(i->first);
	306	// write out texture name
	307	writeString(i->second);
	308	}
	309
	310	LogManager::getSingleton().logMessage("Submesh texture aliases exported.");
	311	}
	312
	313	//---------------------------------------------------------------------
	314	void MeshSerializerImpl::writeSubMeshOperation(const SubMesh* sm)
	315	{
	316	// Header
	317	writeChunkHeader(M_SUBMESH_OPERATION, calcSubMeshOperationSize(sm));
	318
	319	// unsigned short operationType
	320	unsigned short opType = static_cast<unsigned short>(sm->operationType);
	321	writeShorts(&opType, 1);
	322	}
	323	//---------------------------------------------------------------------
	324	void MeshSerializerImpl::writeGeometry(const VertexData* vertexData)
	325	{
	326	// calc size
	327	const VertexDeclaration::VertexElementList& elemList =
	328	vertexData->vertexDeclaration->getElements();
	329	const VertexBufferBinding::VertexBufferBindingMap& bindings =
	330	vertexData->vertexBufferBinding->getBindings();
	331	VertexBufferBinding::VertexBufferBindingMap::const_iterator vbi, vbiend;
	332
	333	size_t size = STREAM_OVERHEAD_SIZE + sizeof(unsigned int) + // base
	334	(STREAM_OVERHEAD_SIZE + elemList.size() * (STREAM_OVERHEAD_SIZE + sizeof(unsigned short) * 5)); // elements
	335	vbiend = bindings.end();
	336	for (vbi = bindings.begin(); vbi != vbiend; ++vbi)
	337	{
	338	const HardwareVertexBufferSharedPtr& vbuf = vbi->second;
	339	size += (STREAM_OVERHEAD_SIZE * 2) + (sizeof(unsigned short) * 2) + vbuf->getSizeInBytes();
	340	}
	341
	342	// Header
	343	writeChunkHeader(M_GEOMETRY, size);
	344
	345	unsigned int vertexCount = vertexData->vertexCount;
	346	writeInts(&vertexCount, 1);
	347
	348	// Vertex declaration
	349	size = STREAM_OVERHEAD_SIZE + elemList.size() * (STREAM_OVERHEAD_SIZE + sizeof(unsigned short) * 5);
	350	writeChunkHeader(M_GEOMETRY_VERTEX_DECLARATION, size);
	351
	352	VertexDeclaration::VertexElementList::const_iterator vei, veiend;
	353	veiend = elemList.end();
	354	unsigned short tmp;
	355	size = STREAM_OVERHEAD_SIZE + sizeof(unsigned short) * 5;
	356	for (vei = elemList.begin(); vei != veiend; ++vei)
	357	{
	358	const VertexElement& elem = *vei;
	359	writeChunkHeader(M_GEOMETRY_VERTEX_ELEMENT, size);
	360	// unsigned short source; // buffer bind source
	361	tmp = elem.getSource();
	362	writeShorts(&tmp, 1);
	363	// unsigned short type; // VertexElementType
	364	tmp = static_cast<unsigned short>(elem.getType());
	365	writeShorts(&tmp, 1);
	366	// unsigned short semantic; // VertexElementSemantic
	367	tmp = static_cast<unsigned short>(elem.getSemantic());
	368	writeShorts(&tmp, 1);
	369	// unsigned short offset; // start offset in buffer in bytes
	370	tmp = static_cast<unsigned short>(elem.getOffset());
	371	writeShorts(&tmp, 1);
	372	// unsigned short index; // index of the semantic (for colours and texture coords)
	373	tmp = elem.getIndex();
	374	writeShorts(&tmp, 1);
	375
	376	}
	377
	378	// Buffers and bindings
	379	vbiend = bindings.end();
	380	for (vbi = bindings.begin(); vbi != vbiend; ++vbi)
	381	{
	382	const HardwareVertexBufferSharedPtr& vbuf = vbi->second;
	383	size = (STREAM_OVERHEAD_SIZE * 2) + (sizeof(unsigned short) * 2) + vbuf->getSizeInBytes();
	384	writeChunkHeader(M_GEOMETRY_VERTEX_BUFFER, size);
	385	// unsigned short bindIndex; // Index to bind this buffer to
	386	tmp = vbi->first;
	387	writeShorts(&tmp, 1);
	388	// unsigned short vertexSize; // Per-vertex size, must agree with declaration at this index
	389	tmp = (unsigned short)vbuf->getVertexSize();
	390	writeShorts(&tmp, 1);
	391
	392	// Data
	393	size = STREAM_OVERHEAD_SIZE + vbuf->getSizeInBytes();
	394	writeChunkHeader(M_GEOMETRY_VERTEX_BUFFER_DATA, size);
	395	void* pBuf = vbuf->lock(HardwareBuffer::HBL_READ_ONLY);
	396
	397	if (mFlipEndian)
	398	{
	399	// endian conversion
	400	// Copy data
	401	unsigned char* tempData = new unsigned char[vbuf->getSizeInBytes()];
	402	memcpy(tempData, pBuf, vbuf->getSizeInBytes());
	403	flipToLittleEndian(
	404	tempData,
	405	vertexData->vertexCount,
	406	vbuf->getVertexSize(),
	407	vertexData->vertexDeclaration->findElementsBySource(vbi->first));
	408	writeData(tempData, vbuf->getVertexSize(), vertexData->vertexCount);
	409	delete [] tempData;
	410	}
	411	else
	412	{
	413	writeData(pBuf, vbuf->getVertexSize(), vertexData->vertexCount);
	414	}
	415	vbuf->unlock();
	416	}
	417
	418
	419	}
	420	//---------------------------------------------------------------------
	421	size_t MeshSerializerImpl::calcSubMeshNameTableSize(const Mesh* pMesh)
	422	{
	423	size_t size = STREAM_OVERHEAD_SIZE;
	424	// Figure out the size of the Name table.
	425	// Iterate through the subMeshList & add up the size of the indexes and names.
	426	Mesh::SubMeshNameMap::const_iterator it = pMesh->mSubMeshNameMap.begin();
	427	while(it != pMesh->mSubMeshNameMap.end())
	428	{
	429	// size of the index + header size for each element chunk
	430	size += STREAM_OVERHEAD_SIZE + sizeof(uint16);
	431	// name
	432	size += it->first.length() + 1;
	433
	434	++it;
	435	}
	436
	437	// size of the sub-mesh name table.
	438	return size;
	439	}
	440	//---------------------------------------------------------------------
	441	size_t MeshSerializerImpl::calcMeshSize(const Mesh* pMesh)
	442	{
	443	size_t size = STREAM_OVERHEAD_SIZE;
	444
	445	// Num shared vertices
	446	size += sizeof(uint32);
	447
	448	// Geometry
	449	if (pMesh->sharedVertexData && pMesh->sharedVertexData->vertexCount > 0)
	450	{
	451	size += calcGeometrySize(pMesh->sharedVertexData);
	452	}
	453
	454	// Submeshes
	455	for (unsigned short i = 0; i < pMesh->getNumSubMeshes(); ++i)
	456	{
	457	size += calcSubMeshSize(pMesh->getSubMesh(i));
	458	}
	459
	460	// Skeleton link
	461	if (pMesh->hasSkeleton())
	462	{
	463	size += calcSkeletonLinkSize(pMesh->getSkeletonName());
	464	}
	465
	466	// Submesh name table
	467	size += calcSubMeshNameTableSize(pMesh);
	468
	469	// Edge list
	470	if (pMesh->isEdgeListBuilt())
	471	{
	472	size += calcEdgeListSize(pMesh);
	473	}
	474
	475	// Animations
	476	for (unsigned short a = 0; a < pMesh->getNumAnimations(); ++a)
	477	{
	478	Animation* anim = pMesh->getAnimation(a);
	479	size += calcAnimationSize(anim);
	480	}
	481
	482	return size;
	483	}
	484	//---------------------------------------------------------------------
	485	size_t MeshSerializerImpl::calcSubMeshSize(const SubMesh* pSub)
	486	{
	487	size_t size = STREAM_OVERHEAD_SIZE;
	488
	489	// Material name
	490	size += pSub->getMaterialName().length() + 1;
	491
	492	// bool useSharedVertices
	493	size += sizeof(bool);
	494	// unsigned int indexCount
	495	size += sizeof(unsigned int);
	496	// bool indexes32bit
	497	size += sizeof(bool);
	498	// unsigned int* faceVertexIndices
	499	size += sizeof(unsigned int) * pSub->indexData->indexCount;
	500
	501	// Geometry
	502	if (!pSub->useSharedVertices)
	503	{
	504	size += calcGeometrySize(pSub->vertexData);
	505	}
	506
	507	size += calcSubMeshTextureAliasesSize(pSub);
	508	size += calcSubMeshOperationSize(pSub);
	509
	510	// Bone assignments
	511	if (!pSub->mBoneAssignments.empty())
	512	{
	513	SubMesh::VertexBoneAssignmentList::const_iterator vi;
	514	for (vi = pSub->mBoneAssignments.begin();
	515	vi != pSub->mBoneAssignments.end(); ++vi)
	516	{
	517	size += calcBoneAssignmentSize();
	518	}
	519	}
	520
	521	return size;
	522	}
	523	//---------------------------------------------------------------------
	524	size_t MeshSerializerImpl::calcSubMeshOperationSize(const SubMesh* pSub)
	525	{
	526	return STREAM_OVERHEAD_SIZE + sizeof(uint16);
	527	}
	528	//---------------------------------------------------------------------
	529	size_t MeshSerializerImpl::calcSubMeshTextureAliasesSize(const SubMesh* pSub)
	530	{
	531	size_t chunkSize = 0;
	532	AliasTextureNamePairList::const_iterator i;
	533
	534	// iterate through texture alias map and calc size of strings
	535	for (i = pSub->mTextureAliases.begin(); i != pSub->mTextureAliases.end(); ++i)
	536	{
	537	// calculate chunk size based on string length + 1. Add 1 for the line feed.
	538	chunkSize += STREAM_OVERHEAD_SIZE + i->first.length() + i->second.length() + 2;
	539	}
	540
	541	return chunkSize;
	542	}
	543	//---------------------------------------------------------------------
	544	size_t MeshSerializerImpl::calcGeometrySize(const VertexData* vertexData)
	545	{
	546	size_t size = STREAM_OVERHEAD_SIZE;
	547
	548	// Num vertices
	549	size += sizeof(unsigned int);
	550
	551	const VertexDeclaration::VertexElementList& elems =
	552	vertexData->vertexDeclaration->getElements();
	553
	554	VertexDeclaration::VertexElementList::const_iterator i, iend;
	555	iend = elems.end();
	556	for (i = elems.begin(); i != iend; ++i)
	557	{
	558	const VertexElement& elem = *i;
	559	// Vertex element
	560	size += VertexElement::getTypeSize(elem.getType()) * vertexData->vertexCount;
	561	}
	562	return size;
	563	}
	564	//---------------------------------------------------------------------
	565	void MeshSerializerImpl::readGeometry(DataStreamPtr& stream, Mesh* pMesh,
	566	VertexData* dest)
	567	{
	568
	569	dest->vertexStart = 0;
	570
	571	unsigned int vertexCount = 0;
	572	readInts(stream, &vertexCount, 1);
	573	dest->vertexCount = vertexCount;
	574
	575	// Find optional geometry streams
	576	if (!stream->eof())
	577	{
	578	unsigned short streamID = readChunk(stream);
	579	while(!stream->eof() &&
	580	(streamID == M_GEOMETRY_VERTEX_DECLARATION \|\|
	581	streamID == M_GEOMETRY_VERTEX_BUFFER ))
	582	{
	583	switch (streamID)
	584	{
	585	case M_GEOMETRY_VERTEX_DECLARATION:
	586	readGeometryVertexDeclaration(stream, pMesh, dest);
	587	break;
	588	case M_GEOMETRY_VERTEX_BUFFER:
	589	readGeometryVertexBuffer(stream, pMesh, dest);
	590	break;
	591	}
	592	// Get next stream
	593	if (!stream->eof())
	594	{
	595	streamID = readChunk(stream);
	596	}
	597	}
	598	if (!stream->eof())
	599	{
	600	// Backpedal back to start of non-submesh stream
	601	stream->skip(-STREAM_OVERHEAD_SIZE);
	602	}
	603	}
	604
	605	// Perform any necessary colour conversion for an active rendersystem
	606	if (Root::getSingletonPtr() && Root::getSingleton().getRenderSystem())
	607	{
	608	// We don't know the source type if it's VET_COLOUR, but assume ARGB
	609	// since that's the most common. Won't get used unless the mesh is
	610	// ambiguous anyway, which will have been warned about in the log
	611	dest->convertPackedColour(VET_COLOUR_ARGB,
	612	VertexElement::getBestColourVertexElementType());
	613	}
	614	}
	615	//---------------------------------------------------------------------
	616	void MeshSerializerImpl::readGeometryVertexDeclaration(DataStreamPtr& stream,
	617	Mesh* pMesh, VertexData* dest)
	618	{
	619	// Find optional geometry streams
	620	if (!stream->eof())
	621	{
	622	unsigned short streamID = readChunk(stream);
	623	while(!stream->eof() &&
	624	(streamID == M_GEOMETRY_VERTEX_ELEMENT ))
	625	{
	626	switch (streamID)
	627	{
	628	case M_GEOMETRY_VERTEX_ELEMENT:
	629	readGeometryVertexElement(stream, pMesh, dest);
	630	break;
	631	}
	632	// Get next stream
	633	if (!stream->eof())
	634	{
	635	streamID = readChunk(stream);
	636	}
	637	}
	638	if (!stream->eof())
	639	{
	640	// Backpedal back to start of non-submesh stream
	641	stream->skip(-STREAM_OVERHEAD_SIZE);
	642	}
	643	}
	644
	645	}
	646	//---------------------------------------------------------------------
	647	void MeshSerializerImpl::readGeometryVertexElement(DataStreamPtr& stream,
	648	Mesh* pMesh, VertexData* dest)
	649	{
	650	unsigned short source, offset, index, tmp;
	651	VertexElementType vType;
	652	VertexElementSemantic vSemantic;
	653	// unsigned short source; // buffer bind source
	654	readShorts(stream, &source, 1);
	655	// unsigned short type; // VertexElementType
	656	readShorts(stream, &tmp, 1);
	657	vType = static_cast<VertexElementType>(tmp);
	658	// unsigned short semantic; // VertexElementSemantic
	659	readShorts(stream, &tmp, 1);
	660	vSemantic = static_cast<VertexElementSemantic>(tmp);
	661	// unsigned short offset; // start offset in buffer in bytes
	662	readShorts(stream, &offset, 1);
	663	// unsigned short index; // index of the semantic
	664	readShorts(stream, &index, 1);
	665
	666	dest->vertexDeclaration->addElement(source, offset, vType, vSemantic, index);
	667
	668	if (vType == VET_COLOUR)
	669	{
	670	StringUtil::StrStreamType s;
	671	s << "Warning: VET_COLOUR element type is deprecated, you should use "
	672	<< "one of the more specific types to indicate the byte order. "
	673	<< "Use OgreMeshUpgrade on " << pMesh->getName() << " as soon as possible. ";
	674	LogManager::getSingleton().logMessage(s.str());
	675	}
	676
	677	}
	678	//---------------------------------------------------------------------
	679	void MeshSerializerImpl::readGeometryVertexBuffer(DataStreamPtr& stream,
	680	Mesh* pMesh, VertexData* dest)
	681	{
	682	unsigned short bindIndex, vertexSize;
	683	// unsigned short bindIndex; // Index to bind this buffer to
	684	readShorts(stream, &bindIndex, 1);
	685	// unsigned short vertexSize; // Per-vertex size, must agree with declaration at this index
	686	readShorts(stream, &vertexSize, 1);
	687
	688	// Check for vertex data header
	689	unsigned short headerID;
	690	headerID = readChunk(stream);
	691	if (headerID != M_GEOMETRY_VERTEX_BUFFER_DATA)
	692	{
	693	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Can't find vertex buffer data area",
	694	"MeshSerializerImpl::readGeometryVertexBuffer");
	695	}
	696	// Check that vertex size agrees
	697	if (dest->vertexDeclaration->getVertexSize(bindIndex) != vertexSize)
	698	{
	699	OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Buffer vertex size does not agree with vertex declaration",
	700	"MeshSerializerImpl::readGeometryVertexBuffer");
	701	}
	702
	703	// Create / populate vertex buffer
	704	HardwareVertexBufferSharedPtr vbuf;
	705	vbuf = HardwareBufferManager::getSingleton().createVertexBuffer(
	706	vertexSize,
	707	dest->vertexCount,
	708	pMesh->mVertexBufferUsage,
	709	pMesh->mVertexBufferShadowBuffer);
	710	void* pBuf = vbuf->lock(HardwareBuffer::HBL_DISCARD);
	711	stream->read(pBuf, dest->vertexCount * vertexSize);
	712
	713	// endian conversion for OSX
	714	flipFromLittleEndian(
	715	pBuf,
	716	dest->vertexCount,
	717	vertexSize,
	718	dest->vertexDeclaration->findElementsBySource(bindIndex));
	719	vbuf->unlock();
	720
	721	// Set binding
	722	dest->vertexBufferBinding->setBinding(bindIndex, vbuf);
	723
	724	}
	725	//---------------------------------------------------------------------
	726	void MeshSerializerImpl::readSubMeshNameTable(DataStreamPtr& stream, Mesh* pMesh)
	727	{
	728	// The map for
	729	std::map<unsigned short, String> subMeshNames;
	730	unsigned short streamID, subMeshIndex;
	731
	732	// Need something to store the index, and the objects name
	733	// This table is a method that imported meshes can retain their naming
	734	// so that the names established in the modelling software can be used
	735	// to get the sub-meshes by name. The exporter must support exporting
	736	// the optional stream M_SUBMESH_NAME_TABLE.
	737
	738	// Read in all the sub-streams. Each sub-stream should contain an index and Ogre::String for the name.
	739	if (!stream->eof())
	740	{
	741	streamID = readChunk(stream);
	742	while(!stream->eof() && (streamID == M_SUBMESH_NAME_TABLE_ELEMENT ))
	743	{
	744	// Read in the index of the submesh.
	745	readShorts(stream, &subMeshIndex, 1);
	746	// Read in the String and map it to its index.
	747	subMeshNames[subMeshIndex] = readString(stream);
	748
	749	// If we're not end of file get the next stream ID
	750	if (!stream->eof())
	751	streamID = readChunk(stream);
	752	}
	753	if (!stream->eof())
	754	{
	755	// Backpedal back to start of stream
	756	stream->skip(-STREAM_OVERHEAD_SIZE);
	757	}
	758	}
	759
	760	// Set all the submeshes names
	761	// ?
	762
	763	// Loop through and save out the index and names.
	764	std::map<unsigned short, String>::const_iterator it = subMeshNames.begin();
	765
	766	while(it != subMeshNames.end())
	767	{
	768	// Name this submesh to the stored name.
	769	pMesh->nameSubMesh(it->second, it->first);
	770	++it;
	771	}
	772
	773
	774
	775	}
	776	//---------------------------------------------------------------------
	777	void MeshSerializerImpl::readMesh(DataStreamPtr& stream, Mesh* pMesh)
	778	{
	779	unsigned short streamID;
	780
	781	// Never automatically build edge lists for this version
	782	// expect them in the file or not at all
	783	pMesh->mAutoBuildEdgeLists = false;
	784
	785	// bool skeletallyAnimated
	786	readBools(stream, &mIsSkeletallyAnimated, 1);
	787
	788	// Find all substreams
	789	if (!stream->eof())
	790	{
	791	streamID = readChunk(stream);
	792	while(!stream->eof() &&
	793	(streamID == M_GEOMETRY \|\|
	794	streamID == M_SUBMESH \|\|
	795	streamID == M_MESH_SKELETON_LINK \|\|
	796	streamID == M_MESH_BONE_ASSIGNMENT \|\|
	797	streamID == M_MESH_LOD \|\|
	798	streamID == M_MESH_BOUNDS \|\|
	799	streamID == M_SUBMESH_NAME_TABLE \|\|
	800	streamID == M_EDGE_LISTS \|\|
	801	streamID == M_POSES \|\|
	802	streamID == M_ANIMATIONS))
	803	{
	804	switch(streamID)
	805	{
	806	case M_GEOMETRY:
	807	pMesh->sharedVertexData = new VertexData();
	808	try {
	809	readGeometry(stream, pMesh, pMesh->sharedVertexData);
	810	}
	811	catch (Exception& e)
	812	{
	813	if (e.getNumber() == Exception::ERR_ITEM_NOT_FOUND)
	814	{
	815	// duff geometry data entry with 0 vertices
	816	delete pMesh->sharedVertexData;
	817	pMesh->sharedVertexData = 0;
	818	// Skip this stream (pointer will have been returned to just after header)
	819	stream->skip(mCurrentstreamLen - STREAM_OVERHEAD_SIZE);
	820	}
	821	else
	822	{
	823	throw;
	824	}
	825	}
	826	break;
	827	case M_SUBMESH:
	828	readSubMesh(stream, pMesh);
	829	break;
	830	case M_MESH_SKELETON_LINK:
	831	readSkeletonLink(stream, pMesh);
	832	break;
	833	case M_MESH_BONE_ASSIGNMENT:
	834	readMeshBoneAssignment(stream, pMesh);
	835	break;
	836	case M_MESH_LOD:
	837	readMeshLodInfo(stream, pMesh);
	838	break;
	839	case M_MESH_BOUNDS:
	840	readBoundsInfo(stream, pMesh);
	841	break;
	842	case M_SUBMESH_NAME_TABLE:
	843	readSubMeshNameTable(stream, pMesh);
	844	break;
	845	case M_EDGE_LISTS:
	846	readEdgeList(stream, pMesh);
	847	break;
	848	case M_POSES:
	849	readPoses(stream, pMesh);
	850	break;
	851	case M_ANIMATIONS:
	852	readAnimations(stream, pMesh);
	853	break;
	854
	855	}
	856
	857	if (!stream->eof())
	858	{
	859	streamID = readChunk(stream);
	860	}
	861
	862	}
	863	if (!stream->eof())
	864	{
	865	// Backpedal back to start of stream
	866	stream->skip(-STREAM_OVERHEAD_SIZE);
	867	}
	868	}
	869
	870	}
	871	//---------------------------------------------------------------------
	872	void MeshSerializerImpl::readSubMesh(DataStreamPtr& stream, Mesh* pMesh)
	873	{
	874	unsigned short streamID;
	875
	876	SubMesh* sm = pMesh->createSubMesh();
	877	// char* materialName
	878	String materialName = readString(stream);
	879	sm->setMaterialName(materialName);
	880	// bool useSharedVertices
	881	readBools(stream,&sm->useSharedVertices, 1);
	882
	883	sm->indexData->indexStart = 0;
	884	unsigned int indexCount = 0;
	885	readInts(stream, &indexCount, 1);
	886	sm->indexData->indexCount = indexCount;
	887
	888	HardwareIndexBufferSharedPtr ibuf;
	889	// bool indexes32Bit
	890	bool idx32bit;
	891	readBools(stream, &idx32bit, 1);
	892	if (idx32bit)
	893	{
	894	ibuf = HardwareBufferManager::getSingleton().
	895	createIndexBuffer(
	896	HardwareIndexBuffer::IT_32BIT,
	897	sm->indexData->indexCount,
	898	pMesh->mIndexBufferUsage,
	899	pMesh->mIndexBufferShadowBuffer);
	900	// unsigned int* faceVertexIndices
	901	unsigned int* pIdx = static_cast<unsigned int*>(
	902	ibuf->lock(HardwareBuffer::HBL_DISCARD)
	903	);
	904	readInts(stream, pIdx, sm->indexData->indexCount);
	905	ibuf->unlock();
	906
	907	}
	908	else // 16-bit
	909	{
	910	ibuf = HardwareBufferManager::getSingleton().
	911	createIndexBuffer(
	912	HardwareIndexBuffer::IT_16BIT,
	913	sm->indexData->indexCount,
	914	pMesh->mIndexBufferUsage,
	915	pMesh->mIndexBufferShadowBuffer);
	916	// unsigned short* faceVertexIndices
	917	unsigned short* pIdx = static_cast<unsigned short*>(
	918	ibuf->lock(HardwareBuffer::HBL_DISCARD)
	919	);
	920	readShorts(stream, pIdx, sm->indexData->indexCount);
	921	ibuf->unlock();
	922	}
	923	sm->indexData->indexBuffer = ibuf;
	924
	925	// M_GEOMETRY stream (Optional: present only if useSharedVertices = false)
	926	if (!sm->useSharedVertices)
	927	{
	928	streamID = readChunk(stream);
	929	if (streamID != M_GEOMETRY)
	930	{
	931	OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Missing geometry data in mesh file",
	932	"MeshSerializerImpl::readSubMesh");
	933	}
	934	sm->vertexData = new VertexData();
	935	readGeometry(stream, pMesh, sm->vertexData);
	936	}
	937
	938
	939	// Find all bone assignments, submesh operation, and texture aliases (if present)
	940	if (!stream->eof())
	941	{
	942	streamID = readChunk(stream);
	943	while(!stream->eof() &&
	944	(streamID == M_SUBMESH_BONE_ASSIGNMENT \|\|
	945	streamID == M_SUBMESH_OPERATION \|\|
	946	streamID == M_SUBMESH_TEXTURE_ALIAS))
	947	{
	948	switch(streamID)
	949	{
	950	case M_SUBMESH_OPERATION:
	951	readSubMeshOperation(stream, pMesh, sm);
	952	break;
	953	case M_SUBMESH_BONE_ASSIGNMENT:
	954	readSubMeshBoneAssignment(stream, pMesh, sm);
	955	break;
	956	case M_SUBMESH_TEXTURE_ALIAS:
	957	readSubMeshTextureAlias(stream, pMesh, sm);
	958	break;
	959	}
	960
	961	if (!stream->eof())
	962	{
	963	streamID = readChunk(stream);
	964	}
	965
	966	}
	967	if (!stream->eof())
	968	{
	969	// Backpedal back to start of stream
	970	stream->skip(-STREAM_OVERHEAD_SIZE);
	971	}
	972	}
	973
	974
	975	}
	976	//---------------------------------------------------------------------
	977	void MeshSerializerImpl::readSubMeshOperation(DataStreamPtr& stream,
	978	Mesh* pMesh, SubMesh* sm)
	979	{
	980	// unsigned short operationType
	981	unsigned short opType;
	982	readShorts(stream, &opType, 1);
	983	sm->operationType = static_cast<RenderOperation::OperationType>(opType);
	984	}
	985	//---------------------------------------------------------------------
	986	void MeshSerializerImpl::readSubMeshTextureAlias(DataStreamPtr& stream, Mesh* pMesh, SubMesh* sub)
	987	{
	988	String aliasName = readString(stream);
	989	String textureName = readString(stream);
	990	sub->addTextureAlias(aliasName, textureName);
	991	}
	992	//---------------------------------------------------------------------
	993	void MeshSerializerImpl::writeSkeletonLink(const String& skelName)
	994	{
	995	writeChunkHeader(M_MESH_SKELETON_LINK, calcSkeletonLinkSize(skelName));
	996
	997	writeString(skelName);
	998
	999	}
	1000	//---------------------------------------------------------------------
	1001	void MeshSerializerImpl::readSkeletonLink(DataStreamPtr& stream, Mesh* pMesh)
	1002	{
	1003	String skelName = readString(stream);
	1004	pMesh->setSkeletonName(skelName);
	1005	}
	1006	//---------------------------------------------------------------------
	1007	void MeshSerializerImpl::readTextureLayer(DataStreamPtr& stream, Mesh* pMesh,
	1008	MaterialPtr& pMat)
	1009	{
	1010	// Material definition section phased out of 1.1
	1011	}
	1012	//---------------------------------------------------------------------
	1013	size_t MeshSerializerImpl::calcSkeletonLinkSize(const String& skelName)
	1014	{
	1015	size_t size = STREAM_OVERHEAD_SIZE;
	1016
	1017	size += skelName.length() + 1;
	1018
	1019	return size;
	1020
	1021	}
	1022	//---------------------------------------------------------------------
	1023	void MeshSerializerImpl::writeMeshBoneAssignment(const VertexBoneAssignment& assign)
	1024	{
	1025	writeChunkHeader(M_MESH_BONE_ASSIGNMENT, calcBoneAssignmentSize());
	1026
	1027	// unsigned int vertexIndex;
	1028	writeInts(&(assign.vertexIndex), 1);
	1029	// unsigned short boneIndex;
	1030	writeShorts(&(assign.boneIndex), 1);
	1031	// float weight;
	1032	writeFloats(&(assign.weight), 1);
	1033	}
	1034	//---------------------------------------------------------------------
	1035	void MeshSerializerImpl::writeSubMeshBoneAssignment(const VertexBoneAssignment& assign)
	1036	{
	1037	writeChunkHeader(M_SUBMESH_BONE_ASSIGNMENT, calcBoneAssignmentSize());
	1038
	1039	// unsigned int vertexIndex;
	1040	writeInts(&(assign.vertexIndex), 1);
	1041	// unsigned short boneIndex;
	1042	writeShorts(&(assign.boneIndex), 1);
	1043	// float weight;
	1044	writeFloats(&(assign.weight), 1);
	1045	}
	1046	//---------------------------------------------------------------------
	1047	void MeshSerializerImpl::readMeshBoneAssignment(DataStreamPtr& stream, Mesh* pMesh)
	1048	{
	1049	VertexBoneAssignment assign;
	1050
	1051	// unsigned int vertexIndex;
	1052	readInts(stream, &(assign.vertexIndex),1);
	1053	// unsigned short boneIndex;
	1054	readShorts(stream, &(assign.boneIndex),1);
	1055	// float weight;
	1056	readFloats(stream, &(assign.weight), 1);
	1057
	1058	pMesh->addBoneAssignment(assign);
	1059
	1060	}
	1061	//---------------------------------------------------------------------
	1062	void MeshSerializerImpl::readSubMeshBoneAssignment(DataStreamPtr& stream,
	1063	Mesh* pMesh, SubMesh* sub)
	1064	{
	1065	VertexBoneAssignment assign;
	1066
	1067	// unsigned int vertexIndex;
	1068	readInts(stream, &(assign.vertexIndex),1);
	1069	// unsigned short boneIndex;
	1070	readShorts(stream, &(assign.boneIndex),1);
	1071	// float weight;
	1072	readFloats(stream, &(assign.weight), 1);
	1073
	1074	sub->addBoneAssignment(assign);
	1075
	1076	}
	1077	//---------------------------------------------------------------------
	1078	size_t MeshSerializerImpl::calcBoneAssignmentSize(void)
	1079	{
	1080	size_t size = STREAM_OVERHEAD_SIZE;
	1081
	1082	// Vert index
	1083	size += sizeof(unsigned int);
	1084	// Bone index
	1085	size += sizeof(unsigned short);
	1086	// weight
	1087	size += sizeof(float);
	1088
	1089	return size;
	1090	}
	1091	//---------------------------------------------------------------------
	1092	void MeshSerializerImpl::writeLodInfo(const Mesh* pMesh)
	1093	{
	1094	unsigned short numLods = pMesh->getNumLodLevels();
	1095	bool manual = pMesh->isLodManual();
	1096	writeLodSummary(numLods, manual);
	1097
	1098	// Loop from LOD 1 (not 0, this is full detail)
	1099	for (unsigned short i = 1; i < numLods; ++i)
	1100	{
	1101	const MeshLodUsage& usage = pMesh->getLodLevel(i);
	1102	if (manual)
	1103	{
	1104	writeLodUsageManual(usage);
	1105	}
	1106	else
	1107	{
	1108	writeLodUsageGenerated(pMesh, usage, i);
	1109	}
	1110
	1111	}
	1112
	1113
	1114	}
	1115	//---------------------------------------------------------------------
	1116	void MeshSerializerImpl::writeLodSummary(unsigned short numLevels, bool manual)
	1117	{
	1118	// Header
	1119	size_t size = STREAM_OVERHEAD_SIZE;
	1120	// unsigned short numLevels;
	1121	size += sizeof(unsigned short);
	1122	// bool manual; (true for manual alternate meshes, false for generated)
	1123	size += sizeof(bool);
	1124	writeChunkHeader(M_MESH_LOD, size);
	1125
	1126	// Details
	1127	// unsigned short numLevels;
	1128	writeShorts(&numLevels, 1);
	1129	// bool manual; (true for manual alternate meshes, false for generated)
	1130	writeBools(&manual, 1);
	1131
	1132
	1133	}
	1134	//---------------------------------------------------------------------
	1135	void MeshSerializerImpl::writeLodUsageManual(const MeshLodUsage& usage)
	1136	{
	1137	// Header
	1138	size_t size = STREAM_OVERHEAD_SIZE;
	1139	size_t manualSize = STREAM_OVERHEAD_SIZE;
	1140	// float fromDepthSquared;
	1141	size += sizeof(float);
	1142	// Manual part size
	1143
	1144	// String manualMeshName;
	1145	manualSize += usage.manualName.length() + 1;
	1146
	1147	size += manualSize;
	1148
	1149	writeChunkHeader(M_MESH_LOD_USAGE, size);
	1150	writeFloats(&(usage.fromDepthSquared), 1);
	1151
	1152	writeChunkHeader(M_MESH_LOD_MANUAL, manualSize);
	1153	writeString(usage.manualName);
	1154
	1155
	1156	}
	1157	//---------------------------------------------------------------------
	1158	void MeshSerializerImpl::writeLodUsageGenerated(const Mesh* pMesh, const MeshLodUsage& usage,
	1159	unsigned short lodNum)
	1160	{
	1161	// Usage Header
	1162	size_t size = STREAM_OVERHEAD_SIZE;
	1163	unsigned short subidx;
	1164
	1165	// float fromDepthSquared;
	1166	size += sizeof(float);
	1167
	1168	// Calc generated SubMesh sections size
	1169	for(subidx = 0; subidx < pMesh->getNumSubMeshes(); ++subidx)
	1170	{
	1171	// header
	1172	size += STREAM_OVERHEAD_SIZE;
	1173	// unsigned int numFaces;
	1174	size += sizeof(unsigned int);
	1175	SubMesh* sm = pMesh->getSubMesh(subidx);
	1176	const IndexData* indexData = sm->mLodFaceList[lodNum - 1];
	1177
	1178	// bool indexes32Bit
	1179	size += sizeof(bool);
	1180	// unsigned short/int faceIndexes;
	1181	if (indexData->indexBuffer->getType() == HardwareIndexBuffer::IT_32BIT)
	1182	{
	1183	size += static_cast<unsigned long>(
	1184	sizeof(unsigned int) * indexData->indexCount);
	1185	}
	1186	else
	1187	{
	1188	size += static_cast<unsigned long>(
	1189	sizeof(unsigned short) * indexData->indexCount);
	1190	}
	1191
	1192	}
	1193
	1194	writeChunkHeader(M_MESH_LOD_USAGE, size);
	1195	writeFloats(&(usage.fromDepthSquared), 1);
	1196
	1197	// Now write sections
	1198	// Calc generated SubMesh sections size
	1199	for(subidx = 0; subidx < pMesh->getNumSubMeshes(); ++subidx)
	1200	{
	1201	size = STREAM_OVERHEAD_SIZE;
	1202	// unsigned int numFaces;
	1203	size += sizeof(unsigned int);
	1204	SubMesh* sm = pMesh->getSubMesh(subidx);
	1205	const IndexData* indexData = sm->mLodFaceList[lodNum - 1];
	1206	// bool indexes32Bit
	1207	size += sizeof(bool);
	1208	// unsigned short/int faceIndexes;
	1209	if (indexData->indexBuffer->getType() == HardwareIndexBuffer::IT_32BIT)
	1210	{
	1211	size += static_cast<unsigned long>(
	1212	sizeof(unsigned int) * indexData->indexCount);
	1213	}
	1214	else
	1215	{
	1216	size += static_cast<unsigned long>(
	1217	sizeof(unsigned short) * indexData->indexCount);
	1218	}
	1219
	1220	writeChunkHeader(M_MESH_LOD_GENERATED, size);
	1221	unsigned int idxCount = static_cast<unsigned int>(indexData->indexCount);
	1222	writeInts(&idxCount, 1);
	1223	// Lock index buffer to write
	1224	HardwareIndexBufferSharedPtr ibuf = indexData->indexBuffer;
	1225	// bool indexes32bit
	1226	bool idx32 = (ibuf->getType() == HardwareIndexBuffer::IT_32BIT);
	1227	writeBools(&idx32, 1);
	1228	if (idx32)
	1229	{
	1230	unsigned int* pIdx = static_cast<unsigned int*>(
	1231	ibuf->lock(HardwareBuffer::HBL_READ_ONLY));
	1232	writeInts(pIdx, indexData->indexCount);
	1233	ibuf->unlock();
	1234	}
	1235	else
	1236	{
	1237	unsigned short* pIdx = static_cast<unsigned short*>(
	1238	ibuf->lock(HardwareBuffer::HBL_READ_ONLY));
	1239	writeShorts(pIdx, indexData->indexCount);
	1240	ibuf->unlock();
	1241	}
	1242	}
	1243
	1244
	1245	}
	1246	//---------------------------------------------------------------------
	1247	void MeshSerializerImpl::writeBoundsInfo(const Mesh* pMesh)
	1248	{
	1249	// Usage Header
	1250	unsigned long size = STREAM_OVERHEAD_SIZE;
	1251
	1252	size += sizeof(float) * 7;
	1253	writeChunkHeader(M_MESH_BOUNDS, size);
	1254
	1255	// float minx, miny, minz
	1256	const Vector3& min = pMesh->mAABB.getMinimum();
	1257	const Vector3& max = pMesh->mAABB.getMaximum();
	1258	writeFloats(&min.x, 1);
	1259	writeFloats(&min.y, 1);
	1260	writeFloats(&min.z, 1);
	1261	// float maxx, maxy, maxz
	1262	writeFloats(&max.x, 1);
	1263	writeFloats(&max.y, 1);
	1264	writeFloats(&max.z, 1);
	1265	// float radius
	1266	writeFloats(&pMesh->mBoundRadius, 1);
	1267
	1268	}
	1269	//---------------------------------------------------------------------
	1270	void MeshSerializerImpl::readBoundsInfo(DataStreamPtr& stream, Mesh* pMesh)
	1271	{
	1272	Vector3 min, max;
	1273	// float minx, miny, minz
	1274	readFloats(stream, &min.x, 1);
	1275	readFloats(stream, &min.y, 1);
	1276	readFloats(stream, &min.z, 1);
	1277	// float maxx, maxy, maxz
	1278	readFloats(stream, &max.x, 1);
	1279	readFloats(stream, &max.y, 1);
	1280	readFloats(stream, &max.z, 1);
	1281	AxisAlignedBox box(min, max);
	1282	pMesh->_setBounds(box, true);
	1283	// float radius
	1284	float radius;
	1285	readFloats(stream, &radius, 1);
	1286	pMesh->_setBoundingSphereRadius(radius);
	1287
	1288
	1289
	1290	}
	1291	//---------------------------------------------------------------------
	1292	void MeshSerializerImpl::readMeshLodInfo(DataStreamPtr& stream, Mesh* pMesh)
	1293	{
	1294	unsigned short streamID, i;
	1295
	1296	// unsigned short numLevels;
	1297	readShorts(stream, &(pMesh->mNumLods), 1);
	1298	// bool manual; (true for manual alternate meshes, false for generated)
	1299	readBools(stream, &(pMesh->mIsLodManual), 1);
	1300
	1301	// Preallocate submesh lod face data if not manual
	1302	if (!pMesh->mIsLodManual)
	1303	{
	1304	unsigned short numsubs = pMesh->getNumSubMeshes();
	1305	for (i = 0; i < numsubs; ++i)
	1306	{
	1307	SubMesh* sm = pMesh->getSubMesh(i);
	1308	sm->mLodFaceList.resize(pMesh->mNumLods-1);
	1309	}
	1310	}
	1311
	1312	// Loop from 1 rather than 0 (full detail index is not in file)
	1313	for (i = 1; i < pMesh->mNumLods; ++i)
	1314	{
	1315	streamID = readChunk(stream);
	1316	if (streamID != M_MESH_LOD_USAGE)
	1317	{
	1318	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	1319	"Missing M_MESH_LOD_USAGE stream in " + pMesh->getName(),
	1320	"MeshSerializerImpl::readMeshLodInfo");
	1321	}
	1322	// Read depth
	1323	MeshLodUsage usage;
	1324	readFloats(stream, &(usage.fromDepthSquared), 1);
	1325
	1326	if (pMesh->isLodManual())
	1327	{
	1328	readMeshLodUsageManual(stream, pMesh, i, usage);
	1329	}
	1330	else //(!pMesh->isLodManual)
	1331	{
	1332	readMeshLodUsageGenerated(stream, pMesh, i, usage);
	1333	}
	1334	usage.edgeData = NULL;
	1335
	1336	// Save usage
	1337	pMesh->mMeshLodUsageList.push_back(usage);
	1338	}
	1339
	1340
	1341	}
	1342	//---------------------------------------------------------------------
	1343	void MeshSerializerImpl::readMeshLodUsageManual(DataStreamPtr& stream,
	1344	Mesh* pMesh, unsigned short lodNum, MeshLodUsage& usage)
	1345	{
	1346	unsigned long streamID;
	1347	// Read detail stream
	1348	streamID = readChunk(stream);
	1349	if (streamID != M_MESH_LOD_MANUAL)
	1350	{
	1351	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	1352	"Missing M_MESH_LOD_MANUAL stream in " + pMesh->getName(),
	1353	"MeshSerializerImpl::readMeshLodUsageManual");
	1354	}
	1355
	1356	usage.manualName = readString(stream);
	1357	usage.manualMesh.setNull(); // will trigger load later
	1358	}
	1359	//---------------------------------------------------------------------
	1360	void MeshSerializerImpl::readMeshLodUsageGenerated(DataStreamPtr& stream,
	1361	Mesh* pMesh, unsigned short lodNum, MeshLodUsage& usage)
	1362	{
	1363	usage.manualName = "";
	1364	usage.manualMesh.setNull();
	1365
	1366	// Get one set of detail per SubMesh
	1367	unsigned short numSubs, i;
	1368	unsigned long streamID;
	1369	numSubs = pMesh->getNumSubMeshes();
	1370	for (i = 0; i < numSubs; ++i)
	1371	{
	1372	streamID = readChunk(stream);
	1373	if (streamID != M_MESH_LOD_GENERATED)
	1374	{
	1375	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	1376	"Missing M_MESH_LOD_GENERATED stream in " + pMesh->getName(),
	1377	"MeshSerializerImpl::readMeshLodUsageGenerated");
	1378	}
	1379
	1380	SubMesh* sm = pMesh->getSubMesh(i);
	1381	// lodNum - 1 because SubMesh doesn't store full detail LOD
	1382	sm->mLodFaceList[lodNum - 1] = new IndexData();
	1383	IndexData* indexData = sm->mLodFaceList[lodNum - 1];
	1384	// unsigned int numIndexes
	1385	unsigned int numIndexes;
	1386	readInts(stream, &numIndexes, 1);
	1387	indexData->indexCount = static_cast<size_t>(numIndexes);
	1388	// bool indexes32Bit
	1389	bool idx32Bit;
	1390	readBools(stream, &idx32Bit, 1);
	1391	// unsigned short/int faceIndexes; ((v1, v2, v3) * numFaces)
	1392	if (idx32Bit)
	1393	{
	1394	indexData->indexBuffer = HardwareBufferManager::getSingleton().
	1395	createIndexBuffer(HardwareIndexBuffer::IT_32BIT, indexData->indexCount,
	1396	pMesh->mIndexBufferUsage, pMesh->mIndexBufferShadowBuffer);
	1397	unsigned int* pIdx = static_cast<unsigned int*>(
	1398	indexData->indexBuffer->lock(
	1399	0,
	1400	indexData->indexBuffer->getSizeInBytes(),
	1401	HardwareBuffer::HBL_DISCARD) );
	1402
	1403	readInts(stream, pIdx, indexData->indexCount);
	1404	indexData->indexBuffer->unlock();
	1405
	1406	}
	1407	else
	1408	{
	1409	indexData->indexBuffer = HardwareBufferManager::getSingleton().
	1410	createIndexBuffer(HardwareIndexBuffer::IT_16BIT, indexData->indexCount,
	1411	pMesh->mIndexBufferUsage, pMesh->mIndexBufferShadowBuffer);
	1412	unsigned short* pIdx = static_cast<unsigned short*>(
	1413	indexData->indexBuffer->lock(
	1414	0,
	1415	indexData->indexBuffer->getSizeInBytes(),
	1416	HardwareBuffer::HBL_DISCARD) );
	1417	readShorts(stream, pIdx, indexData->indexCount);
	1418	indexData->indexBuffer->unlock();
	1419
	1420	}
	1421
	1422	}
	1423	}
	1424	//---------------------------------------------------------------------
	1425	void MeshSerializerImpl::flipFromLittleEndian(void* pData, size_t vertexCount,
	1426	size_t vertexSize, const VertexDeclaration::VertexElementList& elems)
	1427	{
	1428	if (mFlipEndian)
	1429	{
	1430	flipEndian(pData, vertexCount, vertexSize, elems);
	1431	}
	1432	}
	1433	//---------------------------------------------------------------------
	1434	void MeshSerializerImpl::flipToLittleEndian(void* pData, size_t vertexCount,
	1435	size_t vertexSize, const VertexDeclaration::VertexElementList& elems)
	1436	{
	1437	if (mFlipEndian)
	1438	{
	1439	flipEndian(pData, vertexCount, vertexSize, elems);
	1440	}
	1441	}
	1442	//---------------------------------------------------------------------
	1443	void MeshSerializerImpl::flipEndian(void* pData, size_t vertexCount,
	1444	size_t vertexSize, const VertexDeclaration::VertexElementList& elems)
	1445	{
	1446	void *pBase = pData;
	1447	for (size_t v = 0; v < vertexCount; ++v)
	1448	{
	1449	VertexDeclaration::VertexElementList::const_iterator ei, eiend;
	1450	eiend = elems.end();
	1451	for (ei = elems.begin(); ei != eiend; ++ei)
	1452	{
	1453	void *pElem;
	1454	// re-base pointer to the element
	1455	(*ei).baseVertexPointerToElement(pBase, &pElem);
	1456	// Flip the endian based on the type
	1457	size_t typeSize = 0;
	1458	switch (VertexElement::getBaseType((*ei).getType()))
	1459	{
	1460	case VET_FLOAT1:
	1461	typeSize = sizeof(float);
	1462	break;
	1463	case VET_SHORT1:
	1464	typeSize = sizeof(short);
	1465	break;
	1466	case VET_COLOUR:
	1467	case VET_COLOUR_ABGR:
	1468	case VET_COLOUR_ARGB:
	1469	typeSize = sizeof(RGBA);
	1470	break;
	1471	case VET_UBYTE4:
	1472	typeSize = 0; // NO FLIPPING
	1473	break;
	1474	};
	1475	Serializer::flipEndian(pElem, typeSize,
	1476	VertexElement::getTypeCount((*ei).getType()));
	1477
	1478	}
	1479
	1480	pBase = static_cast<void*>(
	1481	static_cast<unsigned char*>(pBase) + vertexSize);
	1482
	1483	}
	1484	}
	1485	//---------------------------------------------------------------------
	1486	size_t MeshSerializerImpl::calcEdgeListSize(const Mesh* pMesh)
	1487	{
	1488	size_t size = STREAM_OVERHEAD_SIZE;
	1489
	1490	for (ushort i = 0; i < pMesh->getNumLodLevels(); ++i)
	1491	{
	1492
	1493	const EdgeData* edgeData = pMesh->getEdgeList(i);
	1494	bool isManual = pMesh->isLodManual() && (i > 0);
	1495
	1496	size += calcEdgeListLodSize(edgeData, isManual);
	1497
	1498	}
	1499
	1500	return size;
	1501	}
	1502	//---------------------------------------------------------------------
	1503	size_t MeshSerializerImpl::calcEdgeListLodSize(const EdgeData* edgeData, bool isManual)
	1504	{
	1505	size_t size = STREAM_OVERHEAD_SIZE;
	1506
	1507	// unsigned short lodIndex
	1508	size += sizeof(uint16);
	1509
	1510	// bool isManual // If manual, no edge data here, loaded from manual mesh
	1511	size += sizeof(bool);
	1512	if (!isManual)
	1513	{
	1514	// unsigned long numTriangles
	1515	size += sizeof(uint32);
	1516	// unsigned long numEdgeGroups
	1517	size += sizeof(uint32);
	1518	// Triangle* triangleList
	1519	size_t triSize = 0;
	1520	// unsigned long indexSet
	1521	// unsigned long vertexSet
	1522	// unsigned long vertIndex[3]
	1523	// unsigned long sharedVertIndex[3]
	1524	// float normal[4]
	1525	triSize += sizeof(uint32) * 8
	1526	+ sizeof(float) * 4;
	1527
	1528	size += triSize * edgeData->triangles.size();
	1529	// Write the groups
	1530	for (EdgeData::EdgeGroupList::const_iterator gi = edgeData->edgeGroups.begin();
	1531	gi != edgeData->edgeGroups.end(); ++gi)
	1532	{
	1533	const EdgeData::EdgeGroup& edgeGroup = *gi;
	1534	size += calcEdgeGroupSize(edgeGroup);
	1535	}
	1536
	1537	}
	1538
	1539	return size;
	1540	}
	1541	//---------------------------------------------------------------------
	1542	size_t MeshSerializerImpl::calcEdgeGroupSize(const EdgeData::EdgeGroup& group)
	1543	{
	1544	size_t size = STREAM_OVERHEAD_SIZE;
	1545
	1546	// unsigned long vertexSet
	1547	size += sizeof(uint32);
	1548	// unsigned long numEdges
	1549	size += sizeof(uint32);
	1550	// Edge* edgeList
	1551	size_t edgeSize = 0;
	1552	// unsigned long triIndex[2]
	1553	// unsigned long vertIndex[2]
	1554	// unsigned long sharedVertIndex[2]
	1555	// bool degenerate
	1556	edgeSize += sizeof(uint32) * 6 + sizeof(bool);
	1557	size += edgeSize * group.edges.size();
	1558
	1559	return size;
	1560	}
	1561	//---------------------------------------------------------------------
	1562	void MeshSerializerImpl::writeEdgeList(const Mesh* pMesh)
	1563	{
	1564	writeChunkHeader(M_EDGE_LISTS, calcEdgeListSize(pMesh));
	1565
	1566	for (ushort i = 0; i < pMesh->getNumLodLevels(); ++i)
	1567	{
	1568	const EdgeData* edgeData = pMesh->getEdgeList(i);
	1569	bool isManual = pMesh->isLodManual() && (i > 0);
	1570	writeChunkHeader(M_EDGE_LIST_LOD, calcEdgeListLodSize(edgeData, isManual));
	1571
	1572	// unsigned short lodIndex
	1573	writeShorts(&i, 1);
	1574
	1575	// bool isManual // If manual, no edge data here, loaded from manual mesh
	1576	writeBools(&isManual, 1);
	1577	if (!isManual)
	1578	{
	1579	// unsigned long numTriangles
	1580	uint32 count = static_cast<uint32>(edgeData->triangles.size());
	1581	writeInts(&count, 1);
	1582	// unsigned long numEdgeGroups
	1583	count = static_cast<uint32>(edgeData->edgeGroups.size());
	1584	writeInts(&count, 1);
	1585	// Triangle* triangleList
	1586	// Iterate rather than writing en-masse to allow endian conversion
	1587	for (EdgeData::TriangleList::const_iterator t = edgeData->triangles.begin();
	1588	t != edgeData->triangles.end(); ++t)
	1589	{
	1590	const EdgeData::Triangle& tri = *t;
	1591	// unsigned long indexSet;
	1592	uint32 tmp[3];
	1593	tmp[0] = tri.indexSet;
	1594	writeInts(tmp, 1);
	1595	// unsigned long vertexSet;
	1596	tmp[0] = tri.vertexSet;
	1597	writeInts(tmp, 1);
	1598	// unsigned long vertIndex[3];
	1599	tmp[0] = tri.vertIndex[0];
	1600	tmp[1] = tri.vertIndex[1];
	1601	tmp[2] = tri.vertIndex[2];
	1602	writeInts(tmp, 3);
	1603	// unsigned long sharedVertIndex[3];
	1604	tmp[0] = tri.sharedVertIndex[0];
	1605	tmp[1] = tri.sharedVertIndex[1];
	1606	tmp[2] = tri.sharedVertIndex[2];
	1607	writeInts(tmp, 3);
	1608	// float normal[4];
	1609	writeFloats(&(tri.normal.x), 4);
	1610
	1611	}
	1612	// Write the groups
	1613	for (EdgeData::EdgeGroupList::const_iterator gi = edgeData->edgeGroups.begin();
	1614	gi != edgeData->edgeGroups.end(); ++gi)
	1615	{
	1616	const EdgeData::EdgeGroup& edgeGroup = *gi;
	1617	writeChunkHeader(M_EDGE_GROUP, calcEdgeGroupSize(edgeGroup));
	1618	// unsigned long vertexSet
	1619	uint32 vertexSet = static_cast<uint32>(edgeGroup.vertexSet);
	1620	writeInts(&vertexSet, 1);
	1621	// unsigned long numEdges
	1622	count = static_cast<uint32>(edgeGroup.edges.size());
	1623	writeInts(&count, 1);
	1624	// Edge* edgeList
	1625	// Iterate rather than writing en-masse to allow endian conversion
	1626	for (EdgeData::EdgeList::const_iterator ei = edgeGroup.edges.begin();
	1627	ei != edgeGroup.edges.end(); ++ei)
	1628	{
	1629	const EdgeData::Edge& edge = *ei;
	1630	uint32 tmp[2];
	1631	// unsigned long triIndex[2]
	1632	tmp[0] = edge.triIndex[0];
	1633	tmp[1] = edge.triIndex[1];
	1634	writeInts(tmp, 2);
	1635	// unsigned long vertIndex[2]
	1636	tmp[0] = edge.vertIndex[0];
	1637	tmp[1] = edge.vertIndex[1];
	1638	writeInts(tmp, 2);
	1639	// unsigned long sharedVertIndex[2]
	1640	tmp[0] = edge.sharedVertIndex[0];
	1641	tmp[1] = edge.sharedVertIndex[1];
	1642	writeInts(tmp, 2);
	1643	// bool degenerate
	1644	writeBools(&(edge.degenerate), 1);
	1645	}
	1646
	1647	}
	1648
	1649	}
	1650
	1651	}
	1652	}
	1653	//---------------------------------------------------------------------
	1654	void MeshSerializerImpl::readEdgeList(DataStreamPtr& stream, Mesh* pMesh)
	1655	{
	1656	unsigned short streamID;
	1657
	1658	if (!stream->eof())
	1659	{
	1660	streamID = readChunk(stream);
	1661	while(!stream->eof() &&
	1662	streamID == M_EDGE_LIST_LOD)
	1663	{
	1664	// Process single LOD
	1665
	1666	// unsigned short lodIndex
	1667	unsigned short lodIndex;
	1668	readShorts(stream, &lodIndex, 1);
	1669
	1670	// bool isManual // If manual, no edge data here, loaded from manual mesh
	1671	bool isManual;
	1672	readBools(stream, &isManual, 1);
	1673	// Only load in non-manual levels; others will be connected up by Mesh on demand
	1674	if (!isManual)
	1675	{
	1676	MeshLodUsage& usage = const_cast<MeshLodUsage&>(pMesh->getLodLevel(lodIndex));
	1677
	1678	usage.edgeData = new EdgeData();
	1679	// unsigned long numTriangles
	1680	uint32 numTriangles;
	1681	readInts(stream, &numTriangles, 1);
	1682	// Allocate correct amount of memory
	1683	usage.edgeData->triangles.resize(numTriangles);
	1684	// unsigned long numEdgeGroups
	1685	uint32 numEdgeGroups;
	1686	readInts(stream, &numEdgeGroups, 1);
	1687	// Allocate correct amount of memory
	1688	usage.edgeData->edgeGroups.resize(numEdgeGroups);
	1689	// Triangle* triangleList
	1690	uint32 tmp[3];
	1691	for (size_t t = 0; t < numTriangles; ++t)
	1692	{
	1693	EdgeData::Triangle& tri = usage.edgeData->triangles[t];
	1694	// unsigned long indexSet
	1695	readInts(stream, tmp, 1);
	1696	tri.indexSet = tmp[0];
	1697	// unsigned long vertexSet
	1698	readInts(stream, tmp, 1);
	1699	tri.vertexSet = tmp[0];
	1700	// unsigned long vertIndex[3]
	1701	readInts(stream, tmp, 3);
	1702	tri.vertIndex[0] = tmp[0];
	1703	tri.vertIndex[1] = tmp[1];
	1704	tri.vertIndex[2] = tmp[2];
	1705	// unsigned long sharedVertIndex[3]
	1706	readInts(stream, tmp, 3);
	1707	tri.sharedVertIndex[0] = tmp[0];
	1708	tri.sharedVertIndex[1] = tmp[1];
	1709	tri.sharedVertIndex[2] = tmp[2];
	1710	// float normal[4]
	1711	readFloats(stream, &(tri.normal.x), 4);
	1712
	1713	}
	1714
	1715	for (uint32 eg = 0; eg < numEdgeGroups; ++eg)
	1716	{
	1717	streamID = readChunk(stream);
	1718	if (streamID != M_EDGE_GROUP)
	1719	{
	1720	OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
	1721	"Missing M_EDGE_GROUP stream",
	1722	"MeshSerializerImpl::readEdgeList");
	1723	}
	1724	EdgeData::EdgeGroup& edgeGroup = usage.edgeData->edgeGroups[eg];
	1725
	1726	// unsigned long vertexSet
	1727	readInts(stream, tmp, 1);
	1728	edgeGroup.vertexSet = tmp[0];
	1729	// unsigned long numEdges
	1730	uint32 numEdges;
	1731	readInts(stream, &numEdges, 1);
	1732	edgeGroup.edges.resize(numEdges);
	1733	// Edge* edgeList
	1734	for (uint32 e = 0; e < numEdges; ++e)
	1735	{
	1736	EdgeData::Edge& edge = edgeGroup.edges[e];
	1737	// unsigned long triIndex[2]
	1738	readInts(stream, tmp, 2);
	1739	edge.triIndex[0] = tmp[0];
	1740	edge.triIndex[1] = tmp[1];
	1741	// unsigned long vertIndex[2]
	1742	readInts(stream, tmp, 2);
	1743	edge.vertIndex[0] = tmp[0];
	1744	edge.vertIndex[1] = tmp[1];
	1745	// unsigned long sharedVertIndex[2]
	1746	readInts(stream, tmp, 2);
	1747	edge.sharedVertIndex[0] = tmp[0];
	1748	edge.sharedVertIndex[1] = tmp[1];
	1749	// bool degenerate
	1750	readBools(stream, &(edge.degenerate), 1);
	1751	}
	1752	// Populate edgeGroup.vertexData pointers
	1753	// If there is shared vertex data, vertexSet 0 is that,
	1754	// otherwise 0 is first dedicated
	1755	if (pMesh->sharedVertexData)
	1756	{
	1757	if (edgeGroup.vertexSet == 0)
	1758	{
	1759	edgeGroup.vertexData = pMesh->sharedVertexData;
	1760	}
	1761	else
	1762	{
	1763	edgeGroup.vertexData = pMesh->getSubMesh(
	1764	edgeGroup.vertexSet-1)->vertexData;
	1765	}
	1766	}
	1767	else
	1768	{
	1769	edgeGroup.vertexData = pMesh->getSubMesh(
	1770	edgeGroup.vertexSet)->vertexData;
	1771	}
	1772	}
	1773
	1774	}
	1775
	1776	if (!stream->eof())
	1777	{
	1778	streamID = readChunk(stream);
	1779	}
	1780
	1781	}
	1782	if (!stream->eof())
	1783	{
	1784	// Backpedal back to start of stream
	1785	stream->skip(-STREAM_OVERHEAD_SIZE);
	1786	}
	1787	}
	1788
	1789
	1790
	1791	pMesh->mEdgeListsBuilt = true;
	1792	}
	1793	//---------------------------------------------------------------------
	1794	size_t MeshSerializerImpl::calcAnimationsSize(const Mesh* pMesh)
	1795	{
	1796	size_t size = STREAM_OVERHEAD_SIZE;
	1797
	1798	for (unsigned short a = 0; a < pMesh->getNumAnimations(); ++a)
	1799	{
	1800	Animation* anim = pMesh->getAnimation(a);
	1801	size += calcAnimationSize(anim);
	1802	}
	1803	return size;
	1804
	1805	}
	1806	//---------------------------------------------------------------------
	1807	size_t MeshSerializerImpl::calcAnimationSize(const Animation* anim)
	1808	{
	1809	size_t size = STREAM_OVERHEAD_SIZE;
	1810	// char* name
	1811	size += anim->getName().length() + 1;
	1812
	1813	// float length
	1814	size += sizeof(float);
	1815
	1816	Animation::VertexTrackIterator trackIt = anim->getVertexTrackIterator();
	1817	while (trackIt.hasMoreElements())
	1818	{
	1819	VertexAnimationTrack* vt = trackIt.getNext();
	1820	size += calcAnimationTrackSize(vt);
	1821	}
	1822
	1823	return size;
	1824	}
	1825	//---------------------------------------------------------------------
	1826	size_t MeshSerializerImpl::calcAnimationTrackSize(const VertexAnimationTrack* track)
	1827	{
	1828	size_t size = STREAM_OVERHEAD_SIZE;
	1829	// uint16 type
	1830	size += sizeof(uint16);
	1831	// unsigned short target // 0 for shared geometry,
	1832	size += sizeof(unsigned short);
	1833
	1834	if (track->getAnimationType() == VAT_MORPH)
	1835	{
	1836	for (unsigned short i = 0; i < track->getNumKeyFrames(); ++i)
	1837	{
	1838	VertexMorphKeyFrame* kf = track->getVertexMorphKeyFrame(i);
	1839	size += calcMorphKeyframeSize(kf, track->getAssociatedVertexData()->vertexCount);
	1840	}
	1841	}
	1842	else
	1843	{
	1844	for (unsigned short i = 0; i < track->getNumKeyFrames(); ++i)
	1845	{
	1846	VertexPoseKeyFrame* kf = track->getVertexPoseKeyFrame(i);
	1847	size += calcPoseKeyframeSize(kf);
	1848	}
	1849	}
	1850	return size;
	1851	}
	1852	//---------------------------------------------------------------------
	1853	size_t MeshSerializerImpl::calcMorphKeyframeSize(const VertexMorphKeyFrame* kf,
	1854	size_t vertexCount)
	1855	{
	1856	size_t size = STREAM_OVERHEAD_SIZE;
	1857	// float time
	1858	size += sizeof(float);
	1859	// bool isOriginalGeometry // point at original geometry?
	1860	size += sizeof(bool);
	1861	// float x,y,z
	1862	size += sizeof(float) * 3 * vertexCount;
	1863
	1864	return size;
	1865	}
	1866	//---------------------------------------------------------------------
	1867	size_t MeshSerializerImpl::calcPoseKeyframeSize(const VertexPoseKeyFrame* kf)
	1868	{
	1869	size_t size = STREAM_OVERHEAD_SIZE;
	1870
	1871	// float time
	1872	size += sizeof(float);
	1873
	1874	size += calcPoseKeyframePoseRefSize() * kf->getPoseReferences().size();
	1875
	1876	return size;
	1877
	1878	}
	1879	//---------------------------------------------------------------------
	1880	size_t MeshSerializerImpl::calcPoseKeyframePoseRefSize(void)
	1881	{
	1882	size_t size = STREAM_OVERHEAD_SIZE;
	1883	// unsigned short poseIndex
	1884	size += sizeof(uint16);
	1885	// float influence
	1886	size += sizeof(float);
	1887
	1888	return size;
	1889
	1890	}
	1891	//---------------------------------------------------------------------
	1892	size_t MeshSerializerImpl::calcPosesSize(const Mesh* pMesh)
	1893	{
	1894	size_t size = STREAM_OVERHEAD_SIZE;
	1895
	1896	Mesh::ConstPoseIterator poseIt = pMesh->getPoseIterator();
	1897	while (poseIt.hasMoreElements())
	1898	{
	1899	size += calcPoseSize(poseIt.getNext());
	1900	}
	1901	return size;
	1902	}
	1903	//---------------------------------------------------------------------
	1904	size_t MeshSerializerImpl::calcPoseSize(const Pose* pose)
	1905	{
	1906	size_t size = STREAM_OVERHEAD_SIZE;
	1907
	1908	// char* name (may be blank)
	1909	size += pose->getName().length() + 1;
	1910	// unsigned short target
	1911	size += sizeof(uint16);
	1912
	1913	// vertex offsets
	1914	size += pose->getVertexOffsets().size() * calcPoseVertexSize();
	1915
	1916	return size;
	1917
	1918	}
	1919	//---------------------------------------------------------------------
	1920	size_t MeshSerializerImpl::calcPoseVertexSize(void)
	1921	{
	1922	size_t size = STREAM_OVERHEAD_SIZE;
	1923	// unsigned long vertexIndex
	1924	size += sizeof(uint32);
	1925	// float xoffset, yoffset, zoffset
	1926	size += sizeof(float) * 3;
	1927
	1928	return size;
	1929	}
	1930	//---------------------------------------------------------------------
	1931	void MeshSerializerImpl::writePoses(const Mesh* pMesh)
	1932	{
	1933	Mesh::ConstPoseIterator poseIterator = pMesh->getPoseIterator();
	1934	if (poseIterator.hasMoreElements())
	1935	{
	1936	writeChunkHeader(M_POSES, calcPosesSize(pMesh));
	1937	while (poseIterator.hasMoreElements())
	1938	{
	1939	writePose(poseIterator.getNext());
	1940	}
	1941	}
	1942
	1943	}
	1944	//---------------------------------------------------------------------
	1945	void MeshSerializerImpl::writePose(const Pose* pose)
	1946	{
	1947	writeChunkHeader(M_POSE, calcPoseSize(pose));
	1948
	1949	// char* name (may be blank)
	1950	writeString(pose->getName());
	1951
	1952	// unsigned short target
	1953	ushort val = pose->getTarget();
	1954	writeShorts(&val, 1);
	1955
	1956	size_t vertexSize = calcPoseVertexSize();
	1957	Pose::ConstVertexOffsetIterator vit = pose->getVertexOffsetIterator();
	1958	while (vit.hasMoreElements())
	1959	{
	1960	uint32 vertexIndex = (uint32)vit.peekNextKey();
	1961	Vector3 offset = vit.getNext();
	1962	writeChunkHeader(M_POSE_VERTEX, vertexSize);
	1963	// unsigned long vertexIndex
	1964	writeInts(&vertexIndex, 1);
	1965	// float xoffset, yoffset, zoffset
	1966	writeFloats(offset.val, 3);
	1967	}
	1968
	1969
	1970	}
	1971	//---------------------------------------------------------------------
	1972	void MeshSerializerImpl::writeAnimations(const Mesh* pMesh)
	1973	{
	1974	writeChunkHeader(M_ANIMATIONS, calcAnimationsSize(pMesh));
	1975
	1976	for (unsigned short a = 0; a < pMesh->getNumAnimations(); ++a)
	1977	{
	1978	Animation* anim = pMesh->getAnimation(a);
	1979	LogManager::getSingleton().logMessage("Exporting animation " + anim->getName());
	1980	writeAnimation(anim);
	1981	LogManager::getSingleton().logMessage("Animation exported.");
	1982	}
	1983	}
	1984	//---------------------------------------------------------------------
	1985	void MeshSerializerImpl::writeAnimation(const Animation* anim)
	1986	{
	1987	writeChunkHeader(M_ANIMATION, calcAnimationSize(anim));
	1988	// char* name
	1989	writeString(anim->getName());
	1990	// float length
	1991	float len = anim->getLength();
	1992	writeFloats(&len, 1);
	1993	Animation::VertexTrackIterator trackIt = anim->getVertexTrackIterator();
	1994	while (trackIt.hasMoreElements())
	1995	{
	1996	VertexAnimationTrack* vt = trackIt.getNext();
	1997	writeAnimationTrack(vt);
	1998	}
	1999
	2000
	2001	}
	2002	//---------------------------------------------------------------------
	2003	void MeshSerializerImpl::writeAnimationTrack(const VertexAnimationTrack* track)
	2004	{
	2005	writeChunkHeader(M_ANIMATION_TRACK, calcAnimationTrackSize(track));
	2006	// unsigned short type // 1 == morph, 2 == pose
	2007	uint16 animType = (uint16)track->getAnimationType();
	2008	writeShorts(&animType, 1);
	2009	// unsigned short target
	2010	uint16 target = track->getHandle();
	2011	writeShorts(&target, 1);
	2012
	2013	if (track->getAnimationType() == VAT_MORPH)
	2014	{
	2015	for (unsigned short i = 0; i < track->getNumKeyFrames(); ++i)
	2016	{
	2017	VertexMorphKeyFrame* kf = track->getVertexMorphKeyFrame(i);
	2018	writeMorphKeyframe(kf, track->getAssociatedVertexData()->vertexCount);
	2019	}
	2020	}
	2021	else // VAT_POSE
	2022	{
	2023	for (unsigned short i = 0; i < track->getNumKeyFrames(); ++i)
	2024	{
	2025	VertexPoseKeyFrame* kf = track->getVertexPoseKeyFrame(i);
	2026	writePoseKeyframe(kf);
	2027	}
	2028	}
	2029
	2030	}
	2031	//---------------------------------------------------------------------
	2032	void MeshSerializerImpl::writeMorphKeyframe(const VertexMorphKeyFrame* kf, size_t vertexCount)
	2033	{
	2034	writeChunkHeader(M_ANIMATION_MORPH_KEYFRAME, calcMorphKeyframeSize(kf, vertexCount));
	2035	// float time
	2036	float timePos = kf->getTime();
	2037	writeFloats(&timePos, 1);
	2038	// float x,y,z // repeat by number of vertices in original geometry
	2039	float* pSrc = static_cast<float*>(
	2040	kf->getVertexBuffer()->lock(HardwareBuffer::HBL_READ_ONLY));
	2041	writeFloats(pSrc, vertexCount * 3);
	2042	kf->getVertexBuffer()->unlock();
	2043	}
	2044	//---------------------------------------------------------------------
	2045	void MeshSerializerImpl::writePoseKeyframe(const VertexPoseKeyFrame* kf)
	2046	{
	2047	writeChunkHeader(M_ANIMATION_POSE_KEYFRAME, calcPoseKeyframeSize(kf));
	2048	// float time
	2049	float timePos = kf->getTime();
	2050	writeFloats(&timePos, 1);
	2051
	2052	// pose references
	2053	VertexPoseKeyFrame::ConstPoseRefIterator poseRefIt =
	2054	kf->getPoseReferenceIterator();
	2055	while (poseRefIt.hasMoreElements())
	2056	{
	2057	writePoseKeyframePoseRef(poseRefIt.getNext());
	2058	}
	2059
	2060
	2061
	2062	}
	2063	//---------------------------------------------------------------------
	2064	void MeshSerializerImpl::writePoseKeyframePoseRef(
	2065	const VertexPoseKeyFrame::PoseRef& poseRef)
	2066	{
	2067	writeChunkHeader(M_ANIMATION_POSE_REF, calcPoseKeyframePoseRefSize());
	2068	// unsigned short poseIndex
	2069	writeShorts(&(poseRef.poseIndex), 1);
	2070	// float influence
	2071	writeFloats(&(poseRef.influence), 1);
	2072	}
	2073	//---------------------------------------------------------------------
	2074	void MeshSerializerImpl::readPoses(DataStreamPtr& stream, Mesh* pMesh)
	2075	{
	2076	unsigned short streamID;
	2077
	2078	// Find all substreams
	2079	if (!stream->eof())
	2080	{
	2081	streamID = readChunk(stream);
	2082	while(!stream->eof() &&
	2083	(streamID == M_POSE))
	2084	{
	2085	switch(streamID)
	2086	{
	2087	case M_POSE:
	2088	readPose(stream, pMesh);
	2089	break;
	2090
	2091	}
	2092
	2093	if (!stream->eof())
	2094	{
	2095	streamID = readChunk(stream);
	2096	}
	2097
	2098	}
	2099	if (!stream->eof())
	2100	{
	2101	// Backpedal back to start of stream
	2102	stream->skip(-STREAM_OVERHEAD_SIZE);
	2103	}
	2104	}
	2105	}
	2106	//---------------------------------------------------------------------
	2107	void MeshSerializerImpl::readPose(DataStreamPtr& stream, Mesh* pMesh)
	2108	{
	2109	// char* name (may be blank)
	2110	String name = readString(stream);
	2111	// unsigned short target
	2112	unsigned short target;
	2113	readShorts(stream, &target, 1);
	2114
	2115	Pose* pose = pMesh->createPose(target, name);
	2116
	2117	// Find all substreams
	2118	unsigned short streamID;
	2119	if (!stream->eof())
	2120	{
	2121	streamID = readChunk(stream);
	2122	while(!stream->eof() &&
	2123	(streamID == M_POSE_VERTEX))
	2124	{
	2125	switch(streamID)
	2126	{
	2127	case M_POSE_VERTEX:
	2128	// create vertex offset
	2129	uint32 vertIndex;
	2130	Vector3 offset;
	2131	// unsigned long vertexIndex
	2132	readInts(stream, &vertIndex, 1);
	2133	// float xoffset, yoffset, zoffset
	2134	readFloats(stream, offset.val, 3);
	2135
	2136	pose->addVertex(vertIndex, offset);
	2137	break;
	2138
	2139	}
	2140
	2141	if (!stream->eof())
	2142	{
	2143	streamID = readChunk(stream);
	2144	}
	2145
	2146	}
	2147	if (!stream->eof())
	2148	{
	2149	// Backpedal back to start of stream
	2150	stream->skip(-STREAM_OVERHEAD_SIZE);
	2151	}
	2152	}
	2153
	2154	}
	2155	//---------------------------------------------------------------------
	2156	void MeshSerializerImpl::readAnimations(DataStreamPtr& stream, Mesh* pMesh)
	2157	{
	2158	unsigned short streamID;
	2159
	2160	// Find all substreams
	2161	if (!stream->eof())
	2162	{
	2163	streamID = readChunk(stream);
	2164	while(!stream->eof() &&
	2165	(streamID == M_ANIMATION))
	2166	{
	2167	switch(streamID)
	2168	{
	2169	case M_ANIMATION:
	2170	readAnimation(stream, pMesh);
	2171	break;
	2172
	2173	}
	2174
	2175	if (!stream->eof())
	2176	{
	2177	streamID = readChunk(stream);
	2178	}
	2179
	2180	}
	2181	if (!stream->eof())
	2182	{
	2183	// Backpedal back to start of stream
	2184	stream->skip(-STREAM_OVERHEAD_SIZE);
	2185	}
	2186	}
	2187
	2188
	2189	}
	2190	//---------------------------------------------------------------------
	2191	void MeshSerializerImpl::readAnimation(DataStreamPtr& stream, Mesh* pMesh)
	2192	{
	2193
	2194	// char* name
	2195	String name = readString(stream);
	2196	// float length
	2197	float len;
	2198	readFloats(stream, &len, 1);
	2199
	2200	Animation* anim = pMesh->createAnimation(name, len);
	2201
	2202	// tracks
	2203	unsigned short streamID;
	2204
	2205	if (!stream->eof())
	2206	{
	2207	streamID = readChunk(stream);
	2208	while(!stream->eof() &&
	2209	streamID == M_ANIMATION_TRACK)
	2210	{
	2211	switch(streamID)
	2212	{
	2213	case M_ANIMATION_TRACK:
	2214	readAnimationTrack(stream, anim, pMesh);
	2215	break;
	2216	};
	2217	if (!stream->eof())
	2218	{
	2219	streamID = readChunk(stream);
	2220	}
	2221
	2222	}
	2223	if (!stream->eof())
	2224	{
	2225	// Backpedal back to start of stream
	2226	stream->skip(-STREAM_OVERHEAD_SIZE);
	2227	}
	2228	}
	2229	}
	2230	//---------------------------------------------------------------------
	2231	void MeshSerializerImpl::readAnimationTrack(DataStreamPtr& stream,
	2232	Animation* anim, Mesh* pMesh)
	2233	{
	2234	// ushort type
	2235	uint16 inAnimType;
	2236	readShorts(stream, &inAnimType, 1);
	2237	VertexAnimationType animType = (VertexAnimationType)inAnimType;
	2238
	2239	// unsigned short target
	2240	uint16 target;
	2241	readShorts(stream, &target, 1);
	2242
	2243	VertexAnimationTrack* track = anim->createVertexTrack(target,
	2244	pMesh->getVertexDataByTrackHandle(target), animType);
	2245
	2246	// keyframes
	2247	unsigned short streamID;
	2248
	2249	if (!stream->eof())
	2250	{
	2251	streamID = readChunk(stream);
	2252	while(!stream->eof() &&
	2253	(streamID == M_ANIMATION_MORPH_KEYFRAME \|\|
	2254	streamID == M_ANIMATION_POSE_KEYFRAME))
	2255	{
	2256	switch(streamID)
	2257	{
	2258	case M_ANIMATION_MORPH_KEYFRAME:
	2259	readMorphKeyFrame(stream, track);
	2260	break;
	2261	case M_ANIMATION_POSE_KEYFRAME:
	2262	readPoseKeyFrame(stream, track);
	2263	break;
	2264	};
	2265	if (!stream->eof())
	2266	{
	2267	streamID = readChunk(stream);
	2268	}
	2269
	2270	}
	2271	if (!stream->eof())
	2272	{
	2273	// Backpedal back to start of stream
	2274	stream->skip(-STREAM_OVERHEAD_SIZE);
	2275	}
	2276	}
	2277
	2278	}
	2279	//---------------------------------------------------------------------
	2280	void MeshSerializerImpl::readMorphKeyFrame(DataStreamPtr& stream, VertexAnimationTrack* track)
	2281	{
	2282	// float time
	2283	float timePos;
	2284	readFloats(stream, &timePos, 1);
	2285
	2286	VertexMorphKeyFrame* kf = track->createVertexMorphKeyFrame(timePos);
	2287
	2288	// Create buffer, allow read and use shadow buffer
	2289	size_t vertexCount = track->getAssociatedVertexData()->vertexCount;
	2290	HardwareVertexBufferSharedPtr vbuf =
	2291	HardwareBufferManager::getSingleton().createVertexBuffer(
	2292	VertexElement::getTypeSize(VET_FLOAT3), vertexCount,
	2293	HardwareBuffer::HBU_STATIC, true);
	2294	// float x,y,z // repeat by number of vertices in original geometry
	2295	float* pDst = static_cast<float*>(
	2296	vbuf->lock(HardwareBuffer::HBL_DISCARD));
	2297	readFloats(stream, pDst, vertexCount * 3);
	2298	vbuf->unlock();
	2299	kf->setVertexBuffer(vbuf);
	2300
	2301	}
	2302	//---------------------------------------------------------------------
	2303	void MeshSerializerImpl::readPoseKeyFrame(DataStreamPtr& stream, VertexAnimationTrack* track)
	2304	{
	2305	// float time
	2306	float timePos;
	2307	readFloats(stream, &timePos, 1);
	2308
	2309	// Create keyframe
	2310	VertexPoseKeyFrame* kf = track->createVertexPoseKeyFrame(timePos);
	2311
	2312	unsigned short streamID;
	2313
	2314	if (!stream->eof())
	2315	{
	2316	streamID = readChunk(stream);
	2317	while(!stream->eof() &&
	2318	streamID == M_ANIMATION_POSE_REF)
	2319	{
	2320	switch(streamID)
	2321	{
	2322	case M_ANIMATION_POSE_REF:
	2323	uint16 poseIndex;
	2324	float influence;
	2325	// unsigned short poseIndex
	2326	readShorts(stream, &poseIndex, 1);
	2327	// float influence
	2328	readFloats(stream, &influence, 1);
	2329
	2330	kf->addPoseReference(poseIndex, influence);
	2331
	2332	break;
	2333	};
	2334	if (!stream->eof())
	2335	{
	2336	streamID = readChunk(stream);
	2337	}
	2338
	2339	}
	2340	if (!stream->eof())
	2341	{
	2342	// Backpedal back to start of stream
	2343	stream->skip(-STREAM_OVERHEAD_SIZE);
	2344	}
	2345	}
	2346
	2347	}
	2348	//---------------------------------------------------------------------
	2349	//---------------------------------------------------------------------
	2350	//---------------------------------------------------------------------
	2351	MeshSerializerImpl_v1_2::MeshSerializerImpl_v1_2()
	2352	{
	2353	// Version number
	2354	mVersion = "[MeshSerializer_v1.20]";
	2355	}
	2356	//---------------------------------------------------------------------
	2357	MeshSerializerImpl_v1_2::~MeshSerializerImpl_v1_2()
	2358	{
	2359	}
	2360	//---------------------------------------------------------------------
	2361	void MeshSerializerImpl_v1_2::readMesh(DataStreamPtr& stream, Mesh* pMesh)
	2362	{
	2363	MeshSerializerImpl::readMesh(stream, pMesh);
	2364	// Always automatically build edge lists for this version
	2365	pMesh->mAutoBuildEdgeLists = true;
	2366
	2367	}
	2368	//---------------------------------------------------------------------
	2369	void MeshSerializerImpl_v1_2::readGeometry(DataStreamPtr& stream, Mesh* pMesh,
	2370	VertexData* dest)
	2371	{
	2372	unsigned short texCoordSet = 0;
	2373
	2374	unsigned short bindIdx = 0;
	2375
	2376	dest->vertexStart = 0;
	2377
	2378	unsigned int vertexCount = 0;
	2379	readInts(stream, &vertexCount, 1);
	2380	dest->vertexCount = vertexCount;
	2381
	2382	// Vertex buffers
	2383
	2384	readGeometryPositions(bindIdx, stream, pMesh, dest);
	2385	++bindIdx;
	2386
	2387	// Find optional geometry streams
	2388	if (!stream->eof())
	2389	{
	2390	unsigned short streamID = readChunk(stream);
	2391	while(!stream->eof() &&
	2392	(streamID == M_GEOMETRY_NORMALS \|\|
	2393	streamID == M_GEOMETRY_COLOURS \|\|
	2394	streamID == M_GEOMETRY_TEXCOORDS ))
	2395	{
	2396	switch (streamID)
	2397	{
	2398	case M_GEOMETRY_NORMALS:
	2399	readGeometryNormals(bindIdx++, stream, pMesh, dest);
	2400	break;
	2401	case M_GEOMETRY_COLOURS:
	2402	readGeometryColours(bindIdx++, stream, pMesh, dest);
	2403	break;
	2404	case M_GEOMETRY_TEXCOORDS:
	2405	readGeometryTexCoords(bindIdx++, stream, pMesh, dest, texCoordSet++);
	2406	break;
	2407	}
	2408	// Get next stream
	2409	if (!stream->eof())
	2410	{
	2411	streamID = readChunk(stream);
	2412	}
	2413	}
	2414	if (!stream->eof())
	2415	{
	2416	// Backpedal back to start of non-submesh stream
	2417	stream->skip(-STREAM_OVERHEAD_SIZE);
	2418	}
	2419	}
	2420	}
	2421	//---------------------------------------------------------------------
	2422	void MeshSerializerImpl_v1_2::readGeometryPositions(unsigned short bindIdx,
	2423	DataStreamPtr& stream, Mesh* pMesh, VertexData* dest)
	2424	{
	2425	float *pFloat = 0;
	2426	HardwareVertexBufferSharedPtr vbuf;
	2427	// float* pVertices (x, y, z order x numVertices)
	2428	dest->vertexDeclaration->addElement(bindIdx, 0, VET_FLOAT3, VES_POSITION);
	2429	vbuf = HardwareBufferManager::getSingleton().createVertexBuffer(
	2430	dest->vertexDeclaration->getVertexSize(bindIdx),
	2431	dest->vertexCount,
	2432	pMesh->mVertexBufferUsage,
	2433	pMesh->mIndexBufferShadowBuffer);
	2434	pFloat = static_cast<float*>(
	2435	vbuf->lock(HardwareBuffer::HBL_DISCARD));
	2436	readFloats(stream, pFloat, dest->vertexCount * 3);
	2437	vbuf->unlock();
	2438	dest->vertexBufferBinding->setBinding(bindIdx, vbuf);
	2439	}
	2440	//---------------------------------------------------------------------
	2441	void MeshSerializerImpl_v1_2::readGeometryNormals(unsigned short bindIdx,
	2442	DataStreamPtr& stream, Mesh* pMesh, VertexData* dest)
	2443	{
	2444	float *pFloat = 0;
	2445	HardwareVertexBufferSharedPtr vbuf;
	2446	// float* pNormals (x, y, z order x numVertices)
	2447	dest->vertexDeclaration->addElement(bindIdx, 0, VET_FLOAT3, VES_NORMAL);
	2448	vbuf = HardwareBufferManager::getSingleton().createVertexBuffer(
	2449	dest->vertexDeclaration->getVertexSize(bindIdx),
	2450	dest->vertexCount,
	2451	pMesh->mVertexBufferUsage,
	2452	pMesh->mVertexBufferShadowBuffer);
	2453	pFloat = static_cast<float*>(
	2454	vbuf->lock(HardwareBuffer::HBL_DISCARD));
	2455	readFloats(stream, pFloat, dest->vertexCount * 3);
	2456	vbuf->unlock();
	2457	dest->vertexBufferBinding->setBinding(bindIdx, vbuf);
	2458	}
	2459	//---------------------------------------------------------------------
	2460	void MeshSerializerImpl_v1_2::readGeometryColours(unsigned short bindIdx,
	2461	DataStreamPtr& stream, Mesh* pMesh, VertexData* dest)
	2462	{
	2463	RGBA* pRGBA = 0;
	2464	HardwareVertexBufferSharedPtr vbuf;
	2465	// unsigned long* pColours (RGBA 8888 format x numVertices)
	2466	dest->vertexDeclaration->addElement(bindIdx, 0, VET_COLOUR, VES_DIFFUSE);
	2467	vbuf = HardwareBufferManager::getSingleton().createVertexBuffer(
	2468	dest->vertexDeclaration->getVertexSize(bindIdx),
	2469	dest->vertexCount,
	2470	pMesh->mVertexBufferUsage,
	2471	pMesh->mVertexBufferShadowBuffer);
	2472	pRGBA = static_cast<RGBA*>(
	2473	vbuf->lock(HardwareBuffer::HBL_DISCARD));
	2474	readInts(stream, pRGBA, dest->vertexCount);
	2475	vbuf->unlock();
	2476	dest->vertexBufferBinding->setBinding(bindIdx, vbuf);
	2477	}
	2478	//---------------------------------------------------------------------
	2479	void MeshSerializerImpl_v1_2::readGeometryTexCoords(unsigned short bindIdx,
	2480	DataStreamPtr& stream, Mesh* pMesh, VertexData* dest, unsigned short texCoordSet)
	2481	{
	2482	float *pFloat = 0;
	2483	HardwareVertexBufferSharedPtr vbuf;
	2484	// unsigned short dimensions (1 for 1D, 2 for 2D, 3 for 3D)
	2485	unsigned short dim;
	2486	readShorts(stream, &dim, 1);
	2487	// float* pTexCoords (u [v] [w] order, dimensions x numVertices)
	2488	dest->vertexDeclaration->addElement(
	2489	bindIdx,
	2490	0,
	2491	VertexElement::multiplyTypeCount(VET_FLOAT1, dim),
	2492	VES_TEXTURE_COORDINATES,
	2493	texCoordSet);
	2494	vbuf = HardwareBufferManager::getSingleton().createVertexBuffer(
	2495	dest->vertexDeclaration->getVertexSize(bindIdx),
	2496	dest->vertexCount,
	2497	pMesh->mVertexBufferUsage,
	2498	pMesh->mVertexBufferShadowBuffer);
	2499	pFloat = static_cast<float*>(
	2500	vbuf->lock(HardwareBuffer::HBL_DISCARD));
	2501	readFloats(stream, pFloat, dest->vertexCount * dim);
	2502	vbuf->unlock();
	2503	dest->vertexBufferBinding->setBinding(bindIdx, vbuf);
	2504	}
	2505	//---------------------------------------------------------------------
	2506	//---------------------------------------------------------------------
	2507	//---------------------------------------------------------------------
	2508	MeshSerializerImpl_v1_1::MeshSerializerImpl_v1_1()
	2509	{
	2510	// Version number
	2511	mVersion = "[MeshSerializer_v1.10]";
	2512	}
	2513	//---------------------------------------------------------------------
	2514	MeshSerializerImpl_v1_1::~MeshSerializerImpl_v1_1()
	2515	{
	2516	}
	2517	//---------------------------------------------------------------------
	2518	void MeshSerializerImpl_v1_1::readGeometryTexCoords(unsigned short bindIdx,
	2519	DataStreamPtr& stream, Mesh* pMesh, VertexData* dest, unsigned short texCoordSet)
	2520	{
	2521	float *pFloat = 0;
	2522	HardwareVertexBufferSharedPtr vbuf;
	2523	// unsigned short dimensions (1 for 1D, 2 for 2D, 3 for 3D)
	2524	unsigned short dim;
	2525	readShorts(stream, &dim, 1);
	2526	// float* pTexCoords (u [v] [w] order, dimensions x numVertices)
	2527	dest->vertexDeclaration->addElement(
	2528	bindIdx,
	2529	0,
	2530	VertexElement::multiplyTypeCount(VET_FLOAT1, dim),
	2531	VES_TEXTURE_COORDINATES,
	2532	texCoordSet);
	2533	vbuf = HardwareBufferManager::getSingleton().createVertexBuffer(
	2534	dest->vertexDeclaration->getVertexSize(bindIdx),
	2535	dest->vertexCount,
	2536	pMesh->getVertexBufferUsage(),
	2537	pMesh->isVertexBufferShadowed());
	2538	pFloat = static_cast<float*>(
	2539	vbuf->lock(HardwareBuffer::HBL_DISCARD));
	2540	readFloats(stream, pFloat, dest->vertexCount * dim);
	2541
	2542	// Adjust individual v values to (1 - v)
	2543	if (dim == 2)
	2544	{
	2545	for (size_t i = 0; i < dest->vertexCount; ++i)
	2546	{
	2547	++pFloat; // skip u
	2548	pFloat = 1.0 - pFloat; // v = 1 - v
	2549	++pFloat;
	2550	}
	2551
	2552	}
	2553	vbuf->unlock();
	2554	dest->vertexBufferBinding->setBinding(bindIdx, vbuf);
	2555	}
	2556	//---------------------------------------------------------------------
	2557	//---------------------------------------------------------------------
	2558	//---------------------------------------------------------------------
	2559
	2560
	2561
	2562
	2563	}
	2564

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

Context Navigation

source: OGRE/trunk/ogrenew/OgreMain/src/OgreMeshSerializerImpl.cpp @ 692

Download in other formats: