Context Navigation

source: OGRE/trunk/ogrenew/OgreMain/src/OgreMesh.cpp @ 657

Revision 657, 67.5 KB checked in by mattausch, 19 years ago (diff)
added ogre dependencies and patched ogre sources

Rev	Line
[657]	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	#include "OgreMesh.h"
	27
	28	#include "OgreSubMesh.h"
	29	#include "OgreMaterialManager.h"
	30	#include "OgreLogManager.h"
	31	#include "OgreMeshSerializer.h"
	32	#include "OgreSkeletonManager.h"
	33	#include "OgreHardwareBufferManager.h"
	34	#include "OgreStringConverter.h"
	35	#include "OgreException.h"
	36	#include "OgreMeshManager.h"
	37	#include "OgreEdgeListBuilder.h"
	38
	39	namespace Ogre {
	40	//-----------------------------------------------------------------------
	41	MeshPtr::MeshPtr(const ResourcePtr& r) : SharedPtr<Mesh>()
	42	{
	43	// lock & copy other mutex pointer
	44	OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
	45	OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
	46	pRep = static_cast<Mesh*>(r.getPointer());
	47	pUseCount = r.useCountPointer();
	48	if (pUseCount)
	49	{
	50	++(*pUseCount);
	51	}
	52	}
	53	//-----------------------------------------------------------------------
	54	MeshPtr& MeshPtr::operator=(const ResourcePtr& r)
	55	{
	56	if (pRep == static_cast<Mesh*>(r.getPointer()))
	57	return *this;
	58	release();
	59	// lock & copy other mutex pointer
	60	OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
	61	OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
	62	pRep = static_cast<Mesh*>(r.getPointer());
	63	pUseCount = r.useCountPointer();
	64	if (pUseCount)
	65	{
	66	++(*pUseCount);
	67	}
	68	return *this;
	69	}
	70	//-----------------------------------------------------------------------
	71	void MeshPtr::destroy(void)
	72	{
	73	// We're only overriding so that we can destroy after full definition of Mesh
	74	SharedPtr<Mesh>::destroy();
	75	}
	76	//-----------------------------------------------------------------------
	77	//-----------------------------------------------------------------------
	78	//-----------------------------------------------------------------------
	79	Mesh::Mesh(ResourceManager* creator, const String& name, ResourceHandle handle,
	80	const String& group, bool isManual, ManualResourceLoader* loader)
	81	: Resource(creator, name, handle, group, isManual, loader),
	82	mBoundRadius(0.0f),
	83	mBoneAssignmentsOutOfDate(false),
	84	mIsLodManual(false),
	85	mNumLods(1),
	86	mVertexBufferUsage(HardwareBuffer::HBU_STATIC_WRITE_ONLY),
	87	mIndexBufferUsage(HardwareBuffer::HBU_STATIC_WRITE_ONLY),
	88	mVertexBufferShadowBuffer(true),
	89	mIndexBufferShadowBuffer(true),
	90	mPreparedForShadowVolumes(false),
	91	mEdgeListsBuilt(false),
	92	mAutoBuildEdgeLists(true), // will be set to false by serializers of 1.30 and above
	93	sharedVertexData(0)
	94	{
	95
	96	setSkeletonName("");
	97	// Init first (manual) lod
	98	MeshLodUsage lod;
	99	lod.fromDepthSquared = 0.0f;
	100	lod.edgeData = NULL;
	101	lod.manualMesh.setNull();
	102	mMeshLodUsageList.push_back(lod);
	103
	104	}
	105	//-----------------------------------------------------------------------
	106	Mesh::~Mesh()
	107	{
	108	// have to call this here reather than in Resource destructor
	109	// since calling virtual methods in base destructors causes crash
	110	unload();
	111	}
	112	//-----------------------------------------------------------------------
	113	SubMesh* Mesh::createSubMesh()
	114	{
	115	SubMesh* sub = new SubMesh();
	116	sub->parent = this;
	117
	118	mSubMeshList.push_back(sub);
	119
	120	return sub;
	121	}
	122	//-----------------------------------------------------------------------
	123	SubMesh* Mesh::createSubMesh(const String& name)
	124	{
	125	SubMesh *sub = createSubMesh();
	126	nameSubMesh(name, (ushort)mSubMeshList.size()-1);
	127	return sub ;
	128	}
	129	//-----------------------------------------------------------------------
	130	unsigned short Mesh::getNumSubMeshes() const
	131	{
	132	return static_cast< unsigned short >( mSubMeshList.size() );
	133	}
	134
	135	//---------------------------------------------------------------------
	136	void Mesh::nameSubMesh(const String& name, ushort index)
	137	{
	138	mSubMeshNameMap[name] = index ;
	139	}
	140
	141	//-----------------------------------------------------------------------
	142	SubMesh* Mesh::getSubMesh(const String& name) const
	143	{
	144	ushort index = _getSubMeshIndex(name);
	145	return getSubMesh(index);
	146	}
	147	//-----------------------------------------------------------------------
	148	SubMesh* Mesh::getSubMesh(unsigned short index) const
	149	{
	150	if (index >= mSubMeshList.size())
	151	{
	152	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	153	"Index out of bounds.",
	154	"Mesh::getSubMesh");
	155	}
	156
	157	return mSubMeshList[index];
	158	}
	159	//-----------------------------------------------------------------------
	160	void Mesh::load(void)
	161	{
	162	OGRE_LOCK_AUTO_MUTEX
	163
	164	// Overridden to ensure edge lists get built from manual or
	165	// loaded meshes
	166	Resource::load();
	167
	168	// Prepare for shadow volumes?
	169	if (MeshManager::getSingleton().getPrepareAllMeshesForShadowVolumes())
	170	{
	171	if (mEdgeListsBuilt \|\| mAutoBuildEdgeLists)
	172	{
	173	prepareForShadowVolume();
	174	}
	175
	176	if (!mEdgeListsBuilt && mAutoBuildEdgeLists)
	177	{
	178	buildEdgeList();
	179	}
	180	}
	181	}
	182	//-----------------------------------------------------------------------
	183	void Mesh::loadImpl()
	184	{
	185	// Load from specified 'name'
	186	MeshSerializer serializer;
	187	LogManager::getSingleton().logMessage("Mesh: Loading " + mName + ".");
	188
	189	DataStreamPtr stream =
	190	ResourceGroupManager::getSingleton().openResource(mName, mGroup);
	191	serializer.importMesh(stream, this);
	192
	193	}
	194
	195	//-----------------------------------------------------------------------
	196	void Mesh::unloadImpl()
	197	{
	198	// Teardown submeshes
	199	for (SubMeshList::iterator i = mSubMeshList.begin();
	200	i != mSubMeshList.end(); ++i)
	201	{
	202	delete *i;
	203	}
	204	if (sharedVertexData)
	205	{
	206	delete sharedVertexData;
	207	sharedVertexData = NULL;
	208	}
	209	// Clear SubMesh lists
	210	mSubMeshList.clear();
	211	mSubMeshNameMap.clear();
	212	// Removes all LOD data
	213	removeLodLevels();
	214	mPreparedForShadowVolumes = false;
	215
	216	// Clear bone assignments
	217	mBoneAssignments.clear();
	218	mBoneAssignmentsOutOfDate = false;
	219
	220	// Removes reference to skeleton
	221	setSkeletonName(StringUtil::BLANK);
	222	}
	223
	224	//-----------------------------------------------------------------------
	225	MeshPtr Mesh::clone(const String& newName, const String& newGroup)
	226	{
	227	// This is a bit like a copy constructor, but with the additional aspect of registering the clone with
	228	// the MeshManager
	229
	230	// New Mesh is assumed to be manually defined rather than loaded since you're cloning it for a reason
	231	String theGroup;
	232	if (newGroup == StringUtil::BLANK)
	233	{
	234	theGroup = this->getGroup();
	235	}
	236	else
	237	{
	238	theGroup = newGroup;
	239	}
	240	MeshPtr newMesh = MeshManager::getSingleton().createManual(newName, theGroup);
	241
	242	// Copy submeshes first
	243	std::vector<SubMesh*>::iterator subi;
	244	SubMesh* newSub;
	245	for (subi = mSubMeshList.begin(); subi != mSubMeshList.end(); ++subi)
	246	{
	247	newSub = newMesh->createSubMesh();
	248	newSub->mMaterialName = (*subi)->mMaterialName;
	249	newSub->mMatInitialised = (*subi)->mMatInitialised;
	250	newSub->operationType = (*subi)->operationType;
	251	newSub->useSharedVertices = (*subi)->useSharedVertices;
	252
	253	if (!(*subi)->useSharedVertices)
	254	{
	255	// Copy unique vertex data
	256	newSub->vertexData = (*subi)->vertexData->clone();
	257	}
	258
	259	// Copy index data
	260	delete newSub->indexData;
	261	newSub->indexData = (*subi)->indexData->clone();
	262	// Copy any bone assignments
	263	newSub->mBoneAssignments = (*subi)->mBoneAssignments;
	264	newSub->mBoneAssignmentsOutOfDate = (*subi)->mBoneAssignmentsOutOfDate;
	265
	266	// Copy lod face lists
	267	newSub->mLodFaceList.reserve((*subi)->mLodFaceList.size());
	268	ProgressiveMesh::LODFaceList::const_iterator facei;
	269	for (facei = (subi)->mLodFaceList.begin(); facei != (subi)->mLodFaceList.end(); ++facei) {
	270	IndexData* newIndexData = (*facei)->clone();
	271	newSub->mLodFaceList.push_back(newIndexData);
	272	}
	273	}
	274
	275	// Copy shared geometry, if any
	276	if (sharedVertexData)
	277	{
	278	newMesh->sharedVertexData = sharedVertexData->clone();
	279	}
	280
	281	// Copy submesh names
	282	newMesh->mSubMeshNameMap = mSubMeshNameMap ;
	283	// Copy any bone assignments
	284	newMesh->mBoneAssignments = mBoneAssignments;
	285	newMesh->mBoneAssignmentsOutOfDate = mBoneAssignmentsOutOfDate;
	286	// Copy bounds
	287	newMesh->mAABB = mAABB;
	288	newMesh->mBoundRadius = mBoundRadius;
	289
	290	newMesh->mIsLodManual = mIsLodManual;
	291	newMesh->mNumLods = mNumLods;
	292	newMesh->mMeshLodUsageList = mMeshLodUsageList;
	293	// Unreference edge lists, otherwise we'll delete the same lot twice, build on demand
	294	MeshLodUsageList::iterator lodi;
	295	for (lodi = newMesh->mMeshLodUsageList.begin(); lodi != newMesh->mMeshLodUsageList.end(); ++lodi) {
	296	MeshLodUsage& lod = *lodi;
	297	lod.edgeData = NULL;
	298	// TODO: Copy manual lod meshes
	299	}
	300
	301	newMesh->mVertexBufferUsage = mVertexBufferUsage;
	302	newMesh->mIndexBufferUsage = mIndexBufferUsage;
	303	newMesh->mVertexBufferShadowBuffer = mVertexBufferShadowBuffer;
	304	newMesh->mIndexBufferShadowBuffer = mIndexBufferShadowBuffer;
	305
	306	newMesh->mSkeletonName = mSkeletonName;
	307	newMesh->mSkeleton = mSkeleton;
	308
	309	// mPreparedForShadowVolumes, mEdgeListsBuilt and edgeData of mMeshLodUsageList
	310	// will up to date on demand
	311
	312	newMesh->load();
	313	newMesh->touch();
	314
	315	return newMesh;
	316
	317	}
	318	//-----------------------------------------------------------------------
	319	const AxisAlignedBox& Mesh::getBounds(void) const
	320	{
	321	return mAABB;
	322	}
	323	//-----------------------------------------------------------------------
	324	void Mesh::_setBounds(const AxisAlignedBox& bounds, bool pad)
	325	{
	326	mAABB = bounds;
	327	Vector3 max = mAABB.getMaximum();
	328	Vector3 min = mAABB.getMinimum();
	329
	330	// Set sphere bounds; not the tightest by since we're using
	331	// manual AABB it is the only way
	332	Real sqLen1 = min.squaredLength();
	333	Real sqLen2 = max.squaredLength();
	334
	335	mBoundRadius = Math::Sqrt(std::max(sqLen1, sqLen2));
	336	if (pad)
	337	{
	338	// Pad out the AABB a little, helps with most bounds tests
	339	Vector3 scaler = (max - min) * MeshManager::getSingleton().getBoundsPaddingFactor();
	340	mAABB.setExtents(min - scaler, max + scaler);
	341	// Pad out the sphere a little too
	342	mBoundRadius = mBoundRadius + (mBoundRadius * MeshManager::getSingleton().getBoundsPaddingFactor());
	343	}
	344	else
	345	{
	346	mAABB.setExtents(min, max);
	347	mBoundRadius = mBoundRadius;
	348	}
	349
	350	}
	351	//-----------------------------------------------------------------------
	352	void Mesh::_setBoundingSphereRadius(Real radius)
	353	{
	354	mBoundRadius = radius;
	355	}
	356	//-----------------------------------------------------------------------
	357	void Mesh::setSkeletonName(const String& skelName)
	358	{
	359	mSkeletonName = skelName;
	360
	361	if (skelName == "")
	362	{
	363	// No skeleton
	364	mSkeleton.setNull();
	365	}
	366	else
	367	{
	368	// Load skeleton
	369	try {
	370	mSkeleton = SkeletonManager::getSingleton().load(skelName, mGroup);
	371	}
	372	catch (...)
	373	{
	374	mSkeleton.setNull();
	375	// Log this error
	376	String msg = "Unable to load skeleton ";
	377	msg += skelName + " for Mesh " + mName
	378	+ ". This Mesh will not be animated. "
	379	+ "You can ignore this message if you are using an offline tool.";
	380	LogManager::getSingleton().logMessage(msg);
	381
	382	}
	383
	384
	385	}
	386	}
	387	//-----------------------------------------------------------------------
	388	bool Mesh::hasSkeleton(void) const
	389	{
	390	return !(mSkeletonName.empty());
	391	}
	392	//-----------------------------------------------------------------------
	393	const SkeletonPtr& Mesh::getSkeleton(void) const
	394	{
	395	return mSkeleton;
	396	}
	397	//-----------------------------------------------------------------------
	398	void Mesh::addBoneAssignment(const VertexBoneAssignment& vertBoneAssign)
	399	{
	400	mBoneAssignments.insert(
	401	VertexBoneAssignmentList::value_type(vertBoneAssign.vertexIndex, vertBoneAssign));
	402	mBoneAssignmentsOutOfDate = true;
	403	}
	404	//-----------------------------------------------------------------------
	405	void Mesh::clearBoneAssignments(void)
	406	{
	407	mBoneAssignments.clear();
	408	mBoneAssignmentsOutOfDate = true;
	409	}
	410	//-----------------------------------------------------------------------
	411	void Mesh::_initAnimationState(AnimationStateSet* animSet)
	412	{
	413	// Delegate to Skeleton
	414	assert(!mSkeleton.isNull() && "Skeleton not present");
	415	mSkeleton->_initAnimationState(animSet);
	416
	417	// Take the opportunity to update the compiled bone assignments
	418	if (mBoneAssignmentsOutOfDate)
	419	_compileBoneAssignments();
	420
	421	SubMeshList::iterator i;
	422	for (i = mSubMeshList.begin(); i != mSubMeshList.end(); ++i)
	423	{
	424	if ((*i)->mBoneAssignmentsOutOfDate)
	425	{
	426	(*i)->_compileBoneAssignments();
	427	}
	428	}
	429	}
	430	//-----------------------------------------------------------------------
	431	typedef std::multimap<Real, Mesh::VertexBoneAssignmentList::iterator> WeightIteratorMap;
	432	unsigned short Mesh::_rationaliseBoneAssignments(size_t vertexCount, Mesh::VertexBoneAssignmentList& assignments)
	433	{
	434	// Iterate through, finding the largest # bones per vertex
	435	unsigned short maxBones = 0;
	436	unsigned short currBones;
	437	currBones = 0;
	438	VertexBoneAssignmentList::iterator i;
	439
	440	for (size_t v = 0; v < vertexCount; ++v)
	441	{
	442	// Get number of entries for this vertex
	443	currBones = static_cast<unsigned short>(assignments.count(v));
	444
	445	// Deal with max bones update
	446	// (note this will record maxBones even if they exceed limit)
	447	if (maxBones < currBones)
	448	maxBones = currBones;
	449	// does the number of bone assignments exceed limit?
	450	if (currBones > OGRE_MAX_BLEND_WEIGHTS)
	451	{
	452	// To many bone assignments on this vertex
	453	// Find the start & end (end is in iterator terms ie exclusive)
	454	std::pair<VertexBoneAssignmentList::iterator, VertexBoneAssignmentList::iterator> range;
	455	// map to sort by weight
	456	WeightIteratorMap weightToAssignmentMap;
	457	range = assignments.equal_range(v);
	458	// Add all the assignments to map
	459	for (i = range.first; i != range.second; ++i)
	460	{
	461	// insert value weight->iterator
	462	weightToAssignmentMap.insert(
	463	WeightIteratorMap::value_type(i->second.weight, i));
	464	}
	465	// Reverse iterate over weight map, remove lowest n
	466	unsigned short numToRemove = currBones - OGRE_MAX_BLEND_WEIGHTS;
	467	WeightIteratorMap::iterator remIt = weightToAssignmentMap.begin();
	468
	469	while (numToRemove--)
	470	{
	471	// Erase this one
	472	assignments.erase(remIt->second);
	473	++remIt;
	474	}
	475	} // if (currBones > OGRE_MAX_BLEND_WEIGHTS)
	476
	477	// Make sure the weights are normalised
	478	// Do this irrespective of whether we had to remove assignments or not
	479	// since it gives us a guarantee that weights are normalised
	480	// We assume this, so it's a good idea since some modellers may not
	481	std::pair<VertexBoneAssignmentList::iterator, VertexBoneAssignmentList::iterator> normalise_range = assignments.equal_range(v);
	482	Real totalWeight = 0;
	483	// Find total first
	484	for (i = normalise_range.first; i != normalise_range.second; ++i)
	485	{
	486	totalWeight += i->second.weight;
	487	}
	488	// Now normalise if total weight is outside tolerance
	489	if (!Math::RealEqual(totalWeight, 1.0f))
	490	{
	491	for (i = normalise_range.first; i != normalise_range.second; ++i)
	492	{
	493	i->second.weight = i->second.weight / totalWeight;
	494	}
	495	}
	496
	497	}
	498
	499	if (maxBones > OGRE_MAX_BLEND_WEIGHTS)
	500	{
	501	// Warn that we've reduced bone assignments
	502	LogManager::getSingleton().logMessage("WARNING: the mesh '" + mName + "' "
	503	"includes vertices with more than " +
	504	StringConverter::toString(OGRE_MAX_BLEND_WEIGHTS) + " bone assignments. "
	505	"The lowest weighted assignments beyond this limit have been removed, so "
	506	"your animation may look slightly different. To eliminate this, reduce "
	507	"the number of bone assignments per vertex on your mesh to " +
	508	StringConverter::toString(OGRE_MAX_BLEND_WEIGHTS) + ".");
	509	// we've adjusted them down to the max
	510	maxBones = OGRE_MAX_BLEND_WEIGHTS;
	511
	512	}
	513
	514	return maxBones;
	515	}
	516	//-----------------------------------------------------------------------
	517	void Mesh::_compileBoneAssignments(void)
	518	{
	519	unsigned short maxBones =
	520	_rationaliseBoneAssignments(sharedVertexData->vertexCount, mBoneAssignments);
	521
	522	if (maxBones == 0)
	523	{
	524	// No bone assignments
	525	return;
	526	}
	527
	528	compileBoneAssignments(mBoneAssignments, maxBones,
	529	sharedVertexData);
	530	mBoneAssignmentsOutOfDate = false;
	531
	532	}
	533	//---------------------------------------------------------------------
	534	void Mesh::compileBoneAssignments(
	535	const VertexBoneAssignmentList& boneAssignments,
	536	unsigned short numBlendWeightsPerVertex,
	537	VertexData* targetVertexData)
	538	{
	539	// Create or reuse blend weight / indexes buffer
	540	// Indices are always a UBYTE4 no matter how many weights per vertex
	541	// Weights are more specific though since they are Reals
	542	VertexDeclaration* decl = targetVertexData->vertexDeclaration;
	543	VertexBufferBinding* bind = targetVertexData->vertexBufferBinding;
	544	unsigned short bindIndex;
	545
	546	const VertexElement* testElem =
	547	decl->findElementBySemantic(VES_BLEND_INDICES);
	548	if (testElem)
	549	{
	550	// Already have a buffer, unset it & delete elements
	551	bindIndex = testElem->getSource();
	552	// unset will cause deletion of buffer
	553	bind->unsetBinding(bindIndex);
	554	decl->removeElement(VES_BLEND_INDICES);
	555	decl->removeElement(VES_BLEND_WEIGHTS);
	556	}
	557	else
	558	{
	559	// Get new binding
	560	bindIndex = bind->getNextIndex();
	561	}
	562
	563	HardwareVertexBufferSharedPtr vbuf =
	564	HardwareBufferManager::getSingleton().createVertexBuffer(
	565	sizeof(unsigned char)4 + sizeof(float)numBlendWeightsPerVertex,
	566	targetVertexData->vertexCount,
	567	HardwareBuffer::HBU_STATIC_WRITE_ONLY,
	568	true // use shadow buffer
	569	);
	570	// bind new buffer
	571	bind->setBinding(bindIndex, vbuf);
	572	const VertexElement pIdxElem, pWeightElem;
	573
	574	// add new vertex elements
	575	// Note, insert directly after all elements using the same source as
	576	// position to abide by pre-Dx9 format restrictions
	577	const VertexElement* firstElem = decl->getElement(0);
	578	if(firstElem->getSemantic() == VES_POSITION)
	579	{
	580	unsigned short insertPoint = 1;
	581	while (insertPoint < decl->getElementCount() &&
	582	decl->getElement(insertPoint)->getSource() == firstElem->getSource())
	583	{
	584	++insertPoint;
	585	}
	586	const VertexElement& idxElem =
	587	decl->insertElement(insertPoint, bindIndex, 0, VET_UBYTE4, VES_BLEND_INDICES);
	588	const VertexElement& wtElem =
	589	decl->insertElement(insertPoint+1, bindIndex, sizeof(unsigned char)*4,
	590	VertexElement::multiplyTypeCount(VET_FLOAT1, numBlendWeightsPerVertex),
	591	VES_BLEND_WEIGHTS);
	592	pIdxElem = &idxElem;
	593	pWeightElem = &wtElem;
	594	}
	595	else
	596	{
	597	// Position is not the first semantic, therefore this declaration is
	598	// not pre-Dx9 compatible anyway, so just tack it on the end
	599	const VertexElement& idxElem =
	600	decl->addElement(bindIndex, 0, VET_UBYTE4, VES_BLEND_INDICES);
	601	const VertexElement& wtElem =
	602	decl->addElement(bindIndex, sizeof(unsigned char)*4,
	603	VertexElement::multiplyTypeCount(VET_FLOAT1, numBlendWeightsPerVertex),
	604	VES_BLEND_WEIGHTS);
	605	pIdxElem = &idxElem;
	606	pWeightElem = &wtElem;
	607	}
	608
	609	// Assign data
	610	size_t v;
	611	VertexBoneAssignmentList::const_iterator i, iend;
	612	i = boneAssignments.begin();
	613	iend = boneAssignments.end();
	614	unsigned char pBase = static_cast<unsigned char>(
	615	vbuf->lock(HardwareBuffer::HBL_DISCARD));
	616	// Iterate by vertex
	617	float *pWeight;
	618	unsigned char *pIndex;
	619	for (v = 0; v < targetVertexData->vertexCount; ++v)
	620	{
	621	/// Convert to specific pointers
	622	pWeightElem->baseVertexPointerToElement(pBase, &pWeight);
	623	pIdxElem->baseVertexPointerToElement(pBase, &pIndex);
	624	for (unsigned short bone = 0; bone < numBlendWeightsPerVertex; ++bone)
	625	{
	626	// Do we still have data for this vertex?
	627	if (i != iend && i->second.vertexIndex == v)
	628	{
	629	// If so, write weight
	630	*pWeight++ = i->second.weight;
	631	*pIndex++ = i->second.boneIndex;
	632	++i;
	633	}
	634	else
	635	{
	636	// Ran out of assignments for this vertex, use weight 0 to indicate empty
	637	*pWeight++ = 0.0f;
	638	*pIndex++ = 0;
	639	}
	640	}
	641	pBase += vbuf->getVertexSize();
	642	}
	643
	644	vbuf->unlock();
	645
	646	}
	647	//---------------------------------------------------------------------
	648	void Mesh::_notifySkeleton(SkeletonPtr& pSkel)
	649	{
	650	mSkeleton = pSkel;
	651	mSkeletonName = pSkel->getName();
	652	}
	653	//---------------------------------------------------------------------
	654	Mesh::BoneAssignmentIterator Mesh::getBoneAssignmentIterator(void)
	655	{
	656	return BoneAssignmentIterator(mBoneAssignments.begin(),
	657	mBoneAssignments.end());
	658	}
	659	//---------------------------------------------------------------------
	660	const String& Mesh::getSkeletonName(void) const
	661	{
	662	return mSkeletonName;
	663	}
	664	//---------------------------------------------------------------------
	665	void Mesh::generateLodLevels(const LodDistanceList& lodDistances,
	666	ProgressiveMesh::VertexReductionQuota reductionMethod, Real reductionValue)
	667	{
	668	#if OGRE_DEBUG_MODE
	669	Real prev = 0;
	670	for (LodDistanceList::const_iterator it = lodDistances.begin();
	671	it != lodDistances.end(); ++it)
	672	{
	673	Real cur = (it) (*it);
	674	assert(cur >= prev && "The lod distances must be sort ascending");
	675	prev = cur;
	676	}
	677	#endif
	678
	679	removeLodLevels();
	680
	681	StringUtil::StrStreamType str;
	682	str << "Generating " << lodDistances.size()
	683	<< " lower LODs for mesh " << mName;
	684	LogManager::getSingleton().logMessage(str.str());
	685
	686	SubMeshList::iterator isub, isubend;
	687	isubend = mSubMeshList.end();
	688	for (isub = mSubMeshList.begin(); isub != isubend; ++isub)
	689	{
	690	// Set up data for reduction
	691	VertexData* pVertexData = (isub)->useSharedVertices ? sharedVertexData : (isub)->vertexData;
	692
	693	ProgressiveMesh pm(pVertexData, (*isub)->indexData);
	694	pm.build(
	695	static_cast<ushort>(lodDistances.size()),
	696	&((*isub)->mLodFaceList),
	697	reductionMethod, reductionValue);
	698
	699	}
	700
	701	// Iterate over the lods and record usage
	702	LodDistanceList::const_iterator idist, idistend;
	703	idistend = lodDistances.end();
	704	mMeshLodUsageList.resize(lodDistances.size() + 1);
	705	MeshLodUsageList::iterator ilod = mMeshLodUsageList.begin();
	706	for (idist = lodDistances.begin(); idist != idistend; ++idist)
	707	{
	708	// Record usage
	709	MeshLodUsage& lod = *++ilod;
	710	lod.fromDepthSquared = (idist) (*idist);
	711	lod.edgeData = 0;
	712	lod.manualMesh.setNull();
	713	}
	714	mNumLods = static_cast<ushort>(lodDistances.size() + 1);
	715	}
	716	//---------------------------------------------------------------------
	717	ushort Mesh::getNumLodLevels(void) const
	718	{
	719	return mNumLods;
	720	}
	721	//---------------------------------------------------------------------
	722	const MeshLodUsage& Mesh::getLodLevel(ushort index) const
	723	{
	724	assert(index < mMeshLodUsageList.size());
	725	if (mIsLodManual && index > 0 && mMeshLodUsageList[index].manualMesh.isNull())
	726	{
	727	// Load the mesh now
	728	try {
	729	mMeshLodUsageList[index].manualMesh =
	730	MeshManager::getSingleton().load(
	731	mMeshLodUsageList[index].manualName,
	732	mGroup);
	733	// get the edge data, if required
	734	if (!mMeshLodUsageList[index].edgeData)
	735	{
	736	mMeshLodUsageList[index].edgeData =
	737	mMeshLodUsageList[index].manualMesh->getEdgeList(0);
	738	}
	739	}
	740	catch (Exception& e)
	741	{
	742	StringUtil::StrStreamType str;
	743	str << "Error while loading manual LOD level "
	744	<< mMeshLodUsageList[index].manualName
	745	<< " - this LOD level will not be rendered. You can "
	746	<< "ignore this error in offline mesh tools.";
	747	LogManager::getSingleton().logMessage(str.str());
	748	}
	749
	750	}
	751	return mMeshLodUsageList[index];
	752	}
	753	//---------------------------------------------------------------------
	754	struct ManualLodSortLess :
	755	public std::binary_function<const MeshLodUsage&, const MeshLodUsage&, bool>
	756	{
	757	bool operator() (const MeshLodUsage& mesh1, const MeshLodUsage& mesh2)
	758	{
	759	// sort ascending by depth
	760	return mesh1.fromDepthSquared < mesh2.fromDepthSquared;
	761	}
	762	};
	763	void Mesh::createManualLodLevel(Real fromDepth, const String& meshName)
	764	{
	765
	766	// Basic prerequisites
	767	assert(fromDepth > 0 && "The LOD depth must be greater than zero");
	768	assert((mIsLodManual \|\| mNumLods == 1) && "Generated LODs already in use!");
	769
	770	mIsLodManual = true;
	771	MeshLodUsage lod;
	772	lod.fromDepthSquared = fromDepth * fromDepth;
	773	lod.manualName = meshName;
	774	lod.manualMesh.setNull();
	775	lod.edgeData = 0;
	776	mMeshLodUsageList.push_back(lod);
	777	++mNumLods;
	778
	779	std::sort(mMeshLodUsageList.begin(), mMeshLodUsageList.end(), ManualLodSortLess());
	780	}
	781	//---------------------------------------------------------------------
	782	void Mesh::updateManualLodLevel(ushort index, const String& meshName)
	783	{
	784
	785	// Basic prerequisites
	786	assert(mIsLodManual && "Not using manual LODs!");
	787	assert(index != 0 && "Can't modify first lod level (full detail)");
	788	assert(index < mMeshLodUsageList.size() && "Index out of bounds");
	789	// get lod
	790	MeshLodUsage* lod = &(mMeshLodUsageList[index]);
	791
	792	lod->manualName = meshName;
	793	lod->manualMesh.setNull();
	794	if (lod->edgeData) delete lod->edgeData;
	795	lod->edgeData = 0;
	796	}
	797	//---------------------------------------------------------------------
	798	ushort Mesh::getLodIndex(Real depth) const
	799	{
	800	return getLodIndexSquaredDepth(depth * depth);
	801	}
	802	//---------------------------------------------------------------------
	803	ushort Mesh::getLodIndexSquaredDepth(Real squaredDepth) const
	804	{
	805	MeshLodUsageList::const_iterator i, iend;
	806	iend = mMeshLodUsageList.end();
	807	ushort index = 0;
	808	for (i = mMeshLodUsageList.begin(); i != iend; ++i, ++index)
	809	{
	810	if (i->fromDepthSquared > squaredDepth)
	811	{
	812	return index - 1;
	813	}
	814	}
	815
	816	// If we fall all the way through, use the highest value
	817	return static_cast<ushort>(mMeshLodUsageList.size() - 1);
	818
	819
	820	}
	821	//---------------------------------------------------------------------
	822	void Mesh::_setLodInfo(unsigned short numLevels, bool isManual)
	823	{
	824	assert(!mEdgeListsBuilt && "Can't modify LOD after edge lists built");
	825
	826	// Basic prerequisites
	827	assert(numLevels > 0 && "Must be at least one level (full detail level must exist)");
	828
	829	mNumLods = numLevels;
	830	mMeshLodUsageList.resize(numLevels);
	831	// Resize submesh face data lists too
	832	for (SubMeshList::iterator i = mSubMeshList.begin(); i != mSubMeshList.end(); ++i)
	833	{
	834	(*i)->mLodFaceList.resize(numLevels - 1);
	835	}
	836	mIsLodManual = isManual;
	837	}
	838	//---------------------------------------------------------------------
	839	void Mesh::_setLodUsage(unsigned short level, MeshLodUsage& usage)
	840	{
	841	assert(!mEdgeListsBuilt && "Can't modify LOD after edge lists built");
	842
	843	// Basic prerequisites
	844	assert(level != 0 && "Can't modify first lod level (full detail)");
	845	assert(level < mMeshLodUsageList.size() && "Index out of bounds");
	846
	847	mMeshLodUsageList[level] = usage;
	848	}
	849	//---------------------------------------------------------------------
	850	void Mesh::_setSubMeshLodFaceList(unsigned short subIdx, unsigned short level,
	851	IndexData* facedata)
	852	{
	853	assert(!mEdgeListsBuilt && "Can't modify LOD after edge lists built");
	854
	855	// Basic prerequisites
	856	assert(!mIsLodManual && "Not using generated LODs!");
	857	assert(subIdx <= mSubMeshList.size() && "Index out of bounds");
	858	assert(level != 0 && "Can't modify first lod level (full detail)");
	859	assert(level <= mSubMeshList[subIdx]->mLodFaceList.size() && "Index out of bounds");
	860
	861	SubMesh* sm = mSubMeshList[subIdx];
	862	sm->mLodFaceList[level - 1] = facedata;
	863
	864	}
	865	//---------------------------------------------------------------------
	866	ushort Mesh::_getSubMeshIndex(const String& name) const
	867	{
	868	SubMeshNameMap::const_iterator i = mSubMeshNameMap.find(name) ;
	869	if (i == mSubMeshNameMap.end())
	870	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "No SubMesh named " + name + " found.",
	871	"Mesh::_getSubMeshIndex");
	872
	873	return i->second;
	874	}
	875	//---------------------------------------------------------------------
	876	void Mesh::removeLodLevels(void)
	877	{
	878	if (!mIsLodManual)
	879	{
	880	// Remove data from SubMeshes
	881	SubMeshList::iterator isub, isubend;
	882	isubend = mSubMeshList.end();
	883	for (isub = mSubMeshList.begin(); isub != isubend; ++isub)
	884	{
	885	(*isub)->removeLodLevels();
	886	}
	887	}
	888
	889	freeEdgeList();
	890	mMeshLodUsageList.clear();
	891
	892	// Reinitialise
	893	mNumLods = 1;
	894	// Init first (manual) lod
	895	MeshLodUsage lod;
	896	lod.fromDepthSquared = 0.0f;
	897	lod.edgeData = 0;
	898	lod.manualMesh.setNull();
	899	mMeshLodUsageList.push_back(lod);
	900	mIsLodManual = false;
	901
	902
	903	}
	904	//---------------------------------------------------------------------
	905	Real Mesh::getBoundingSphereRadius(void) const
	906	{
	907	return mBoundRadius;
	908	}
	909	//---------------------------------------------------------------------
	910	void Mesh::setVertexBufferPolicy(HardwareBuffer::Usage vbUsage, bool shadowBuffer)
	911	{
	912	mVertexBufferUsage = vbUsage;
	913	mVertexBufferShadowBuffer = shadowBuffer;
	914	}
	915	//---------------------------------------------------------------------
	916	void Mesh::setIndexBufferPolicy(HardwareBuffer::Usage vbUsage, bool shadowBuffer)
	917	{
	918	mIndexBufferUsage = vbUsage;
	919	mIndexBufferShadowBuffer = shadowBuffer;
	920	}
	921	//---------------------------------------------------------------------
	922	void Mesh::organiseTangentsBuffer(VertexData *vertexData,
	923	unsigned short destCoordSet)
	924	{
	925	VertexDeclaration *vDecl = vertexData->vertexDeclaration ;
	926	VertexBufferBinding *vBind = vertexData->vertexBufferBinding ;
	927
	928	const VertexElement *tex3D = vDecl->findElementBySemantic(VES_TEXTURE_COORDINATES, destCoordSet);
	929	bool needsToBeCreated = false;
	930
	931	if (!tex3D)
	932	{ // no tex coords with index 1
	933	needsToBeCreated = true ;
	934	}
	935	else if (tex3D->getType() != VET_FLOAT3)
	936	{
	937	// tex buffer exists, but not 3D
	938	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	939	"Texture coordinate set " + StringConverter::toString(destCoordSet) +
	940	"already exists but is not 3D, therefore cannot contain tangents. Pick "
	941	"an alternative destination coordinate set. ",
	942	"Mesh::organiseTangentsBuffer");
	943	}
	944
	945	HardwareVertexBufferSharedPtr newBuffer;
	946	if (needsToBeCreated)
	947	{
	948	// What we need to do, to be most efficient with our vertex streams,
	949	// is to tack the new 3D coordinate set onto the same buffer as the
	950	// previous texture coord set
	951	const VertexElement* prevTexCoordElem =
	952	vertexData->vertexDeclaration->findElementBySemantic(
	953	VES_TEXTURE_COORDINATES, destCoordSet - 1);
	954	if (!prevTexCoordElem)
	955	{
	956	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	957	"Cannot locate the texture coordinate element preceding the "
	958	"destination texture coordinate set to which to append the new "
	959	"tangents.", "Mesh::orgagniseTangentsBuffer");
	960	}
	961	// Find the buffer associated with this element
	962	HardwareVertexBufferSharedPtr origBuffer =
	963	vertexData->vertexBufferBinding->getBuffer(
	964	prevTexCoordElem->getSource());
	965	// Now create a new buffer, which includes the previous contents
	966	// plus extra space for the 3D coords
	967	newBuffer = HardwareBufferManager::getSingleton().createVertexBuffer(
	968	origBuffer->getVertexSize() + 3*sizeof(float),
	969	vertexData->vertexCount,
	970	origBuffer->getUsage(),
	971	origBuffer->hasShadowBuffer() );
	972	// Add the new element
	973	vDecl->addElement(
	974	prevTexCoordElem->getSource(),
	975	origBuffer->getVertexSize(),
	976	VET_FLOAT3,
	977	VES_TEXTURE_COORDINATES,
	978	destCoordSet);
	979	// Now copy the original data across
	980	unsigned char* pSrc = static_cast<unsigned char*>(
	981	origBuffer->lock(HardwareBuffer::HBL_READ_ONLY));
	982	unsigned char* pDest = static_cast<unsigned char*>(
	983	newBuffer->lock(HardwareBuffer::HBL_DISCARD));
	984	size_t vertSize = origBuffer->getVertexSize();
	985	for (size_t v = 0; v < vertexData->vertexCount; ++v)
	986	{
	987	// Copy original vertex data
	988	memcpy(pDest, pSrc, vertSize);
	989	pSrc += vertSize;
	990	pDest += vertSize;
	991	// Set the new part to 0 since we'll accumulate in this
	992	memset(pDest, 0, sizeof(float)*3);
	993	pDest += sizeof(float)*3;
	994	}
	995	origBuffer->unlock();
	996	newBuffer->unlock();
	997
	998	// Rebind the new buffer
	999	vBind->setBinding(prevTexCoordElem->getSource(), newBuffer);
	1000	}
	1001	}
	1002	//---------------------------------------------------------------------
	1003	void Mesh::buildTangentVectors(unsigned short sourceTexCoordSet,
	1004	unsigned short destTexCoordSet)
	1005	{
	1006	if (destTexCoordSet == 0)
	1007	{
	1008	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	1009	"Destination texture coordinate set must be greater than 0",
	1010	"Mesh::buildTangentVectors");
	1011	}
	1012
	1013	// our temp. buffers
	1014	uint32 vertInd[3];
	1015	Vector3 vertPos[3];
	1016	Real u[3], v[3];
	1017	// setup a new 3D texture coord-set buffer for every sub mesh
	1018	int nSubMesh = getNumSubMeshes();
	1019	bool sharedGeometryDone = false;
	1020	for (int sm = 0; sm < nSubMesh; sm++)
	1021	{
	1022	// retrieve buffer pointers
	1023	uint16 *pVIndices16; // the face indices buffer, read only
	1024	uint32 *pVIndices32; // the face indices buffer, read only
	1025	float *p2DTC; // pointer to 2D tex.coords, read only
	1026	float *p3DTC; // pointer to 3D tex.coords, write/read (discard)
	1027	float *pVPos; // vertex position buffer, read only
	1028
	1029	SubMesh *pSubMesh = getSubMesh(sm);
	1030
	1031	// retrieve buffer pointers
	1032	// first, indices
	1033	IndexData *indexData = pSubMesh->indexData;
	1034	HardwareIndexBufferSharedPtr buffIndex = indexData->indexBuffer;
	1035	bool use32bit = false;
	1036	if (buffIndex->getType() == HardwareIndexBuffer::IT_32BIT)
	1037	{
	1038	pVIndices32 = static_cast<uint32*>(
	1039	buffIndex->lock(HardwareBuffer::HBL_READ_ONLY));
	1040	use32bit = true;
	1041	}
	1042	else
	1043	{
	1044	pVIndices16 = static_cast<uint16*>(
	1045	buffIndex->lock(HardwareBuffer::HBL_READ_ONLY));
	1046	}
	1047	// then, vertices
	1048	VertexData *usedVertexData ;
	1049	if (pSubMesh->useSharedVertices) {
	1050	// Don't do shared geometry more than once
	1051	if (sharedGeometryDone)
	1052	continue;
	1053	usedVertexData = sharedVertexData;
	1054	sharedGeometryDone = true;
	1055	} else {
	1056	usedVertexData = pSubMesh->vertexData;
	1057	}
	1058	VertexDeclaration *vDecl = usedVertexData->vertexDeclaration;
	1059	VertexBufferBinding *vBind = usedVertexData->vertexBufferBinding;
	1060
	1061
	1062	// make sure we have a 3D coord to place data in
	1063	organiseTangentsBuffer(usedVertexData, destTexCoordSet);
	1064
	1065	// Get the target element
	1066	const VertexElement* destElem = vDecl->findElementBySemantic(VES_TEXTURE_COORDINATES, destTexCoordSet);
	1067	// Get the source element
	1068	const VertexElement* srcElem = vDecl->findElementBySemantic(VES_TEXTURE_COORDINATES, sourceTexCoordSet);
	1069
	1070	if (!srcElem \|\| srcElem->getType() != VET_FLOAT2)
	1071	{
	1072	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	1073	"SubMesh " + StringConverter::toString(sm) + " of Mesh " + mName +
	1074	" has no 2D texture coordinates at the selected set, therefore we cannot calculate tangents.",
	1075	"Mesh::buildTangentVectors");
	1076	}
	1077	HardwareVertexBufferSharedPtr srcBuf, destBuf, posBuf;
	1078	unsigned char pSrcBase, pDestBase, *pPosBase;
	1079	size_t srcInc, destInc, posInc;
	1080
	1081	srcBuf = vBind->getBuffer(srcElem->getSource());
	1082	// Is the source and destination buffer the same?
	1083	if (srcElem->getSource() == destElem->getSource())
	1084	{
	1085	// lock source for read and write
	1086	pSrcBase = static_cast<unsigned char*>(
	1087	srcBuf->lock(HardwareBuffer::HBL_NORMAL));
	1088	srcInc = srcBuf->getVertexSize();
	1089	pDestBase = pSrcBase;
	1090	destInc = srcInc;
	1091	}
	1092	else
	1093	{
	1094	pSrcBase = static_cast<unsigned char*>(
	1095	srcBuf->lock(HardwareBuffer::HBL_READ_ONLY));
	1096	srcInc = srcBuf->getVertexSize();
	1097	destBuf = vBind->getBuffer(destElem->getSource());
	1098	destInc = destBuf->getVertexSize();
	1099	pDestBase = static_cast<unsigned char*>(
	1100	destBuf->lock(HardwareBuffer::HBL_NORMAL));
	1101	}
	1102
	1103	// find a vertex coord buffer
	1104	const VertexElement *elemVPos = vDecl->findElementBySemantic(VES_POSITION);
	1105	if (elemVPos->getSource() == srcElem->getSource())
	1106	{
	1107	pPosBase = pSrcBase;
	1108	posInc = srcInc;
	1109	}
	1110	else if (elemVPos->getSource() == destElem->getSource())
	1111	{
	1112	pPosBase = pDestBase;
	1113	posInc = destInc;
	1114	}
	1115	else
	1116	{
	1117	// A different buffer
	1118	posBuf = vBind->getBuffer(elemVPos->getSource());
	1119	pPosBase = static_cast<unsigned char*>(
	1120	posBuf->lock(HardwareBuffer::HBL_READ_ONLY));
	1121	posInc = posBuf->getVertexSize();
	1122	}
	1123
	1124	size_t numFaces = indexData->indexCount / 3 ;
	1125
	1126	// loop through all faces to calculate the tangents and normals
	1127	size_t n;
	1128	for (n = 0; n < numFaces; ++n)
	1129	{
	1130	int i;
	1131	for (i = 0; i < 3; ++i)
	1132	{
	1133	// get indexes of vertices that form a polygon in the position buffer
	1134	if (use32bit)
	1135	{
	1136	vertInd[i] = *pVIndices32++;
	1137	}
	1138	else
	1139	{
	1140	vertInd[i] = *pVIndices16++;
	1141	}
	1142	// get the vertices positions from the position buffer
	1143	unsigned char* vBase = pPosBase + (posInc * vertInd[i]);
	1144	elemVPos->baseVertexPointerToElement(vBase, &pVPos);
	1145	vertPos[i].x = pVPos[0];
	1146	vertPos[i].y = pVPos[1];
	1147	vertPos[i].z = pVPos[2];
	1148	// get the vertices tex.coords from the 2D tex.coords buffer
	1149	vBase = pSrcBase + (srcInc * vertInd[i]);
	1150	srcElem->baseVertexPointerToElement(vBase, &p2DTC);
	1151	u[i] = p2DTC[0];
	1152	v[i] = p2DTC[1];
	1153	}
	1154	// calculate the TSB
	1155	Vector3 tangent = Math::calculateTangentSpaceVector(
	1156	vertPos[0], vertPos[1], vertPos[2],
	1157	u[0], v[0], u[1], v[1], u[2], v[2]);
	1158	// write new tex.coords
	1159	// note we only write the tangent, not the binormal since we can calculate
	1160	// the binormal in the vertex program
	1161	for (i = 0; i < 3; ++i)
	1162	{
	1163	// write values (they must be 0 and we must add them so we can average
	1164	// all the contributions from all the faces
	1165	unsigned char* vBase = pDestBase + (destInc * vertInd[i]);
	1166	destElem->baseVertexPointerToElement(vBase, &p3DTC);
	1167	p3DTC[0] += tangent.x;
	1168	p3DTC[1] += tangent.y;
	1169	p3DTC[2] += tangent.z;
	1170	}
	1171	}
	1172	// now loop through all vertices and normalize them
	1173	size_t numVerts = usedVertexData->vertexCount ;
	1174	for (n = 0; n < numVerts; ++n)
	1175	{
	1176	destElem->baseVertexPointerToElement(pDestBase, &p3DTC);
	1177	// read the vertex
	1178	Vector3 temp(p3DTC[0], p3DTC[1], p3DTC[2]);
	1179	// normalize the vertex
	1180	temp.normalise();
	1181	// write it back
	1182	p3DTC[0] = temp.x;
	1183	p3DTC[1] = temp.y;
	1184	p3DTC[2] = temp.z;
	1185
	1186	pDestBase += destInc;
	1187	}
	1188	// unlock buffers
	1189	srcBuf->unlock();
	1190	if (!destBuf.isNull())
	1191	{
	1192	destBuf->unlock();
	1193	}
	1194	if (!posBuf.isNull())
	1195	{
	1196	posBuf->unlock();
	1197	}
	1198	buffIndex->unlock();
	1199	}
	1200
	1201	}
	1202
	1203	//---------------------------------------------------------------------
	1204	bool Mesh::suggestTangentVectorBuildParams(unsigned short& outSourceCoordSet,
	1205	unsigned short& outDestCoordSet)
	1206	{
	1207	// Go through all the vertex data and locate source and dest (must agree)
	1208	bool sharedGeometryDone = false;
	1209	bool foundExisting = false;
	1210	bool firstOne = true;
	1211	SubMeshList::iterator i, iend;
	1212	iend = mSubMeshList.end();
	1213	for (i = mSubMeshList.begin(); i != iend; ++i)
	1214	{
	1215	SubMesh* sm = *i;
	1216	VertexData* vertexData;
	1217
	1218	if (sm->useSharedVertices)
	1219	{
	1220	if (sharedGeometryDone)
	1221	continue;
	1222	vertexData = sharedVertexData;
	1223	sharedGeometryDone = true;
	1224	}
	1225	else
	1226	{
	1227	vertexData = sm->vertexData;
	1228	}
	1229
	1230	const VertexElement *sourceElem = 0;
	1231	unsigned short proposedDest = 0;
	1232	unsigned short t = 0;
	1233	for (t = 0; t < OGRE_MAX_TEXTURE_COORD_SETS; ++t)
	1234	{
	1235	const VertexElement* testElem =
	1236	vertexData->vertexDeclaration->findElementBySemantic(
	1237	VES_TEXTURE_COORDINATES, t);
	1238	if (!testElem)
	1239	break; // finish if we've run out, t will be the target
	1240
	1241	if (!sourceElem)
	1242	{
	1243	// We're still looking for the source texture coords
	1244	if (testElem->getType() == VET_FLOAT2)
	1245	{
	1246	// Ok, we found it
	1247	sourceElem = testElem;
	1248	}
	1249	}
	1250	else
	1251	{
	1252	// We're looking for the destination
	1253	// Check to see if we've found a possible
	1254	if (testElem->getType() == VET_FLOAT3)
	1255	{
	1256	// This is a 3D set, might be tangents
	1257	foundExisting = true;
	1258	}
	1259
	1260	}
	1261
	1262	}
	1263
	1264	// After iterating, we should have a source and a possible destination (t)
	1265	if (!sourceElem)
	1266	{
	1267	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	1268	"Cannot locate an appropriate 2D texture coordinate set for "
	1269	"all the vertex data in this mesh to create tangents from. ",
	1270	"Mesh::suggestTangentVectorBuildParams");
	1271	}
	1272	// Check that we agree with previous decisions, if this is not the
	1273	// first one
	1274	if (!firstOne)
	1275	{
	1276	if (sourceElem->getIndex() != outSourceCoordSet)
	1277	{
	1278	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	1279	"Multiple sets of vertex data in this mesh disagree on "
	1280	"the appropriate index to use for the source texture coordinates. "
	1281	"This ambiguity must be rectified before tangents can be generated.",
	1282	"Mesh::suggestTangentVectorBuildParams");
	1283	}
	1284	if (t != outDestCoordSet)
	1285	{
	1286	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	1287	"Multiple sets of vertex data in this mesh disagree on "
	1288	"the appropriate index to use for the target texture coordinates. "
	1289	"This ambiguity must be rectified before tangents can be generated.",
	1290	"Mesh::suggestTangentVectorBuildParams");
	1291	}
	1292	}
	1293
	1294	// Otherwise, save this result
	1295	outSourceCoordSet = sourceElem->getIndex();
	1296	outDestCoordSet = t;
	1297
	1298	firstOne = false;
	1299
	1300	}
	1301
	1302	return foundExisting;
	1303
	1304	}
	1305	//---------------------------------------------------------------------
	1306	void Mesh::buildEdgeList(void)
	1307	{
	1308	if (mEdgeListsBuilt)
	1309	return;
	1310
	1311	// Loop over LODs
	1312	for (unsigned int lodIndex = 0; lodIndex < mMeshLodUsageList.size(); ++lodIndex)
	1313	{
	1314	// use getLodLevel to enforce loading of manual mesh lods
	1315	MeshLodUsage& usage = const_cast<MeshLodUsage&>(getLodLevel(lodIndex));
	1316
	1317	if (mIsLodManual && lodIndex != 0)
	1318	{
	1319	// Delegate edge building to manual mesh
	1320	// It should have already built it's own edge list while loading
	1321	if (!usage.manualMesh.isNull())
	1322	{
	1323	usage.edgeData = usage.manualMesh->getEdgeList(0);
	1324	}
	1325	}
	1326	else
	1327	{
	1328	// Build
	1329	EdgeListBuilder eb;
	1330	size_t vertexSetCount = 0;
	1331
	1332	if (sharedVertexData)
	1333	{
	1334	eb.addVertexData(sharedVertexData);
	1335	vertexSetCount++;
	1336	}
	1337
	1338	// Prepare the builder using the submesh information
	1339	SubMeshList::iterator i, iend;
	1340	iend = mSubMeshList.end();
	1341	for (i = mSubMeshList.begin(); i != iend; ++i)
	1342	{
	1343	SubMesh* s = *i;
	1344	if (s->useSharedVertices)
	1345	{
	1346	// Use shared vertex data, index as set 0
	1347	if (lodIndex == 0)
	1348	{
	1349	eb.addIndexData(s->indexData, 0, s->operationType);
	1350	}
	1351	else
	1352	{
	1353	eb.addIndexData(s->mLodFaceList[lodIndex-1], 0,
	1354	s->operationType);
	1355	}
	1356	}
	1357	else
	1358	{
	1359	// own vertex data, add it and reference it directly
	1360	eb.addVertexData(s->vertexData);
	1361	if (lodIndex == 0)
	1362	{
	1363	// Base index data
	1364	eb.addIndexData(s->indexData, vertexSetCount++,
	1365	s->operationType);
	1366	}
	1367	else
	1368	{
	1369	// LOD index data
	1370	eb.addIndexData(s->mLodFaceList[lodIndex-1],
	1371	vertexSetCount++, s->operationType);
	1372	}
	1373
	1374	}
	1375	}
	1376
	1377	usage.edgeData = eb.build();
	1378
	1379	#if OGRE_DEBUG_MODE
	1380	// Override default log
	1381	Log* log = LogManager::getSingleton().createLog(
	1382	mName + "_lod" + StringConverter::toString(lodIndex) +
	1383	"_prepshadow.log", false, false);
	1384	usage.edgeData->log(log);
	1385	#endif
	1386
	1387	}
	1388	}
	1389	mEdgeListsBuilt = true;
	1390	}
	1391	//---------------------------------------------------------------------
	1392	void Mesh::freeEdgeList(void)
	1393	{
	1394	if (!mEdgeListsBuilt)
	1395	return;
	1396
	1397	// Loop over LODs
	1398	MeshLodUsageList::iterator i, iend;
	1399	iend = mMeshLodUsageList.end();
	1400	unsigned short index = 0;
	1401	for (i = mMeshLodUsageList.begin(); i != iend; ++i, ++index)
	1402	{
	1403	MeshLodUsage& usage = *i;
	1404
	1405	if (!mIsLodManual \|\| index == 0)
	1406	{
	1407	// Only delete if we own this data
	1408	// Manual LODs > 0 own their own
	1409	delete usage.edgeData;
	1410	}
	1411	usage.edgeData = NULL;
	1412	}
	1413
	1414	mEdgeListsBuilt = false;
	1415	}
	1416	//---------------------------------------------------------------------
	1417	void Mesh::prepareForShadowVolume(void)
	1418	{
	1419	if (mPreparedForShadowVolumes)
	1420	return;
	1421
	1422	if (sharedVertexData)
	1423	{
	1424	sharedVertexData->prepareForShadowVolume();
	1425	}
	1426	SubMeshList::iterator i, iend;
	1427	iend = mSubMeshList.end();
	1428	for (i = mSubMeshList.begin(); i != iend; ++i)
	1429	{
	1430	SubMesh* s = *i;
	1431	if (!s->useSharedVertices)
	1432	{
	1433	s->vertexData->prepareForShadowVolume();
	1434	}
	1435	}
	1436	mPreparedForShadowVolumes = true;
	1437	}
	1438	//---------------------------------------------------------------------
	1439	EdgeData* Mesh::getEdgeList(unsigned int lodIndex)
	1440	{
	1441	// Build edge list on demand
	1442	if (!mEdgeListsBuilt && mAutoBuildEdgeLists)
	1443	{
	1444	buildEdgeList();
	1445	}
	1446
	1447	return getLodLevel(lodIndex).edgeData;
	1448	}
	1449	//---------------------------------------------------------------------
	1450	const EdgeData* Mesh::getEdgeList(unsigned int lodIndex) const
	1451	{
	1452	return getLodLevel(lodIndex).edgeData;
	1453	}
	1454	//---------------------------------------------------------------------
	1455	void Mesh::softwareVertexBlend(const VertexData* sourceVertexData,
	1456	const VertexData* targetVertexData, const Matrix4* pMatrices,
	1457	bool blendNormals)
	1458	{
	1459	// Source vectors
	1460	Vector3 sourceVec, sourceNorm;
	1461	// Accumulation vectors
	1462	Vector3 accumVecPos, accumVecNorm;
	1463
	1464	float pSrcPos, pSrcNorm, pDestPos, pDestNorm, *pBlendWeight;
	1465	unsigned char* pBlendIdx;
	1466	bool srcPosNormShareBuffer = false;
	1467	bool destPosNormShareBuffer = false;
	1468	bool weightsIndexesShareBuffer = false;
	1469
	1470
	1471	// Get elements for source
	1472	const VertexElement* srcElemPos =
	1473	sourceVertexData->vertexDeclaration->findElementBySemantic(VES_POSITION);
	1474	const VertexElement* srcElemNorm =
	1475	sourceVertexData->vertexDeclaration->findElementBySemantic(VES_NORMAL);
	1476	const VertexElement* srcElemBlendIndices =
	1477	sourceVertexData->vertexDeclaration->findElementBySemantic(VES_BLEND_INDICES);
	1478	const VertexElement* srcElemBlendWeights =
	1479	sourceVertexData->vertexDeclaration->findElementBySemantic(VES_BLEND_WEIGHTS);
	1480	assert (srcElemPos && srcElemBlendIndices && srcElemBlendWeights &&
	1481	"You must supply at least positions, blend indices and blend weights");
	1482	// Get elements for target
	1483	const VertexElement* destElemPos =
	1484	targetVertexData->vertexDeclaration->findElementBySemantic(VES_POSITION);
	1485	const VertexElement* destElemNorm =
	1486	targetVertexData->vertexDeclaration->findElementBySemantic(VES_NORMAL);
	1487
	1488	// Do we have normals and want to blend them?
	1489	bool includeNormals = blendNormals && (srcElemNorm != NULL) && (destElemNorm != NULL);
	1490
	1491
	1492	// Get buffers for source
	1493	HardwareVertexBufferSharedPtr srcPosBuf, srcNormBuf, srcIdxBuf, srcWeightBuf;
	1494	srcPosBuf = sourceVertexData->vertexBufferBinding->getBuffer(srcElemPos->getSource());
	1495	srcIdxBuf = sourceVertexData->vertexBufferBinding->getBuffer(srcElemBlendIndices->getSource());
	1496	srcWeightBuf = sourceVertexData->vertexBufferBinding->getBuffer(srcElemBlendWeights->getSource());
	1497	if (includeNormals)
	1498	{
	1499	srcNormBuf = sourceVertexData->vertexBufferBinding->getBuffer(srcElemNorm->getSource());
	1500	srcPosNormShareBuffer = (srcPosBuf.get() == srcNormBuf.get());
	1501	}
	1502	weightsIndexesShareBuffer = (srcIdxBuf.get() == srcWeightBuf.get());
	1503	// Get buffers for target
	1504	HardwareVertexBufferSharedPtr destPosBuf, destNormBuf;
	1505	destPosBuf = targetVertexData->vertexBufferBinding->getBuffer(destElemPos->getSource());
	1506	if (includeNormals)
	1507	{
	1508	destNormBuf = targetVertexData->vertexBufferBinding->getBuffer(destElemNorm->getSource());
	1509	destPosNormShareBuffer = (destPosBuf.get() == destNormBuf.get());
	1510	}
	1511
	1512	// Lock source buffers for reading
	1513	assert (srcElemPos->getOffset() == 0 &&
	1514	"Positions must be first element in dedicated buffer!");
	1515	pSrcPos = static_cast<float*>(
	1516	srcPosBuf->lock(HardwareBuffer::HBL_READ_ONLY));
	1517	if (includeNormals)
	1518	{
	1519	if (srcPosNormShareBuffer)
	1520	{
	1521	// Same buffer, must be packed directly after position
	1522	assert (srcElemNorm->getOffset() == sizeof(float) * 3 &&
	1523	"Normals must be packed directly after positions in buffer!");
	1524	// pSrcNorm will not be used
	1525	}
	1526	else
	1527	{
	1528	// Different buffer
	1529	assert (srcElemNorm->getOffset() == 0 &&
	1530	"Normals must be first element in dedicated buffer!");
	1531	pSrcNorm = static_cast<float*>(
	1532	srcNormBuf->lock(HardwareBuffer::HBL_READ_ONLY));
	1533	}
	1534	}
	1535
	1536	// Indices must be first in a buffer and be 4 bytes
	1537	assert(srcElemBlendIndices->getOffset() == 0 &&
	1538	srcElemBlendIndices->getType() == VET_UBYTE4 &&
	1539	"Blend indices must be first in a buffer and be VET_UBYTE4");
	1540	pBlendIdx = static_cast<unsigned char*>(
	1541	srcIdxBuf->lock(HardwareBuffer::HBL_READ_ONLY));
	1542	if (weightsIndexesShareBuffer)
	1543	{
	1544	// Weights must be packed directly after the indices
	1545	assert(srcElemBlendWeights->getOffset() == sizeof(unsigned char)*4 &&
	1546	"Blend weights must be directly after indices in the buffer");
	1547	srcElemBlendWeights->baseVertexPointerToElement(pBlendIdx, &pBlendWeight);
	1548	}
	1549	else
	1550	{
	1551	// Weights must be at the start of the buffer
	1552	assert(srcElemBlendWeights->getOffset() == 0 &&
	1553	"Blend weights must be at the start of a dedicated buffer");
	1554	// Lock buffer
	1555	pBlendWeight = static_cast<float*>(
	1556	srcWeightBuf->lock(HardwareBuffer::HBL_READ_ONLY));
	1557	}
	1558	unsigned short numWeightsPerVertex =
	1559	VertexElement::getTypeCount(srcElemBlendWeights->getType());
	1560
	1561
	1562	// Lock destination buffers for writing
	1563	assert (destElemPos->getOffset() == 0 &&
	1564	"Positions must be first element in dedicated buffer!");
	1565	pDestPos = static_cast<float*>(
	1566	destPosBuf->lock(HardwareBuffer::HBL_DISCARD));
	1567	if (includeNormals)
	1568	{
	1569	if (destPosNormShareBuffer)
	1570	{
	1571	// Same buffer, must be packed directly after position
	1572	assert (destElemNorm->getOffset() == sizeof(float) * 3 &&
	1573	"Normals must be packed directly after positions in buffer!");
	1574	// Must be no other information in the buffer
	1575	assert(destPosBuf->getVertexSize() ==
	1576	destElemPos->getSize() + destElemNorm->getSize() &&
	1577	"When software skinning, position & normal buffer must not include "
	1578	"any other vertex elements!");
	1579	// pDestNorm will not be used
	1580	}
	1581	else
	1582	{
	1583	// Different buffer
	1584	assert (destElemNorm->getOffset() == 0 &&
	1585	"Normals must be first element in dedicated buffer!");
	1586	// Must be no other information in the buffer
	1587	assert(destPosBuf->getVertexSize() ==
	1588	destElemPos->getSize() &&
	1589	"When software skinning, dedicated position buffer must not include "
	1590	"any other vertex elements!");
	1591	assert(destNormBuf->getVertexSize() ==
	1592	destElemNorm->getSize() &&
	1593	"When software skinning, dedicated normal buffer must not include "
	1594	"any other vertex elements!");
	1595	pDestNorm = static_cast<float*>(
	1596	destNormBuf->lock(HardwareBuffer::HBL_DISCARD));
	1597	}
	1598	}
	1599
	1600	// Loop per vertex
	1601	for (size_t vertIdx = 0; vertIdx < targetVertexData->vertexCount; ++vertIdx)
	1602	{
	1603	// Load source vertex elements
	1604	sourceVec.x = *pSrcPos++;
	1605	sourceVec.y = *pSrcPos++;
	1606	sourceVec.z = *pSrcPos++;
	1607
	1608	if (includeNormals)
	1609	{
	1610	if (srcPosNormShareBuffer)
	1611	{
	1612	sourceNorm.x = *pSrcPos++;
	1613	sourceNorm.y = *pSrcPos++;
	1614	sourceNorm.z = *pSrcPos++;
	1615	}
	1616	else
	1617	{
	1618	sourceNorm.x = *pSrcNorm++;
	1619	sourceNorm.y = *pSrcNorm++;
	1620	sourceNorm.z = *pSrcNorm++;
	1621	}
	1622	}
	1623	// Load accumulators
	1624	accumVecPos = Vector3::ZERO;
	1625	accumVecNorm = Vector3::ZERO;
	1626
	1627	// Loop per blend weight
	1628	for (unsigned short blendIdx = 0;
	1629	blendIdx < numWeightsPerVertex; ++blendIdx)
	1630	{
	1631	// Blend by multiplying source by blend matrix and scaling by weight
	1632	// Add to accumulator
	1633	// NB weights must be normalised!!
	1634	if (*pBlendWeight != 0.0)
	1635	{
	1636	// Blend position, use 3x4 matrix
	1637	const Matrix4& mat = pMatrices[*pBlendIdx];
	1638	accumVecPos.x +=
	1639	(mat[0][0] * sourceVec.x +
	1640	mat[0][1] * sourceVec.y +
	1641	mat[0][2] * sourceVec.z +
	1642	mat[0][3])
	1643	* (*pBlendWeight);
	1644	accumVecPos.y +=
	1645	(mat[1][0] * sourceVec.x +
	1646	mat[1][1] * sourceVec.y +
	1647	mat[1][2] * sourceVec.z +
	1648	mat[1][3])
	1649	* (*pBlendWeight);
	1650	accumVecPos.z +=
	1651	(mat[2][0] * sourceVec.x +
	1652	mat[2][1] * sourceVec.y +
	1653	mat[2][2] * sourceVec.z +
	1654	mat[2][3])
	1655	* (*pBlendWeight);
	1656	if (includeNormals)
	1657	{
	1658	// Blend normal
	1659	// We should blend by inverse transpose here, but because we're assuming the 3x3
	1660	// aspect of the matrix is orthogonal (no non-uniform scaling), the inverse transpose
	1661	// is equal to the main 3x3 matrix
	1662	// Note because it's a normal we just extract the rotational part, saves us renormalising here
	1663	accumVecNorm.x +=
	1664	(mat[0][0] * sourceNorm.x +
	1665	mat[0][1] * sourceNorm.y +
	1666	mat[0][2] * sourceNorm.z)
	1667	* (*pBlendWeight);
	1668	accumVecNorm.y +=
	1669	(mat[1][0] * sourceNorm.x +
	1670	mat[1][1] * sourceNorm.y +
	1671	mat[1][2] * sourceNorm.z)
	1672	* (*pBlendWeight);
	1673	accumVecNorm.z +=
	1674	(mat[2][0] * sourceNorm.x +
	1675	mat[2][1] * sourceNorm.y +
	1676	mat[2][2] * sourceNorm.z)
	1677	* (*pBlendWeight);
	1678	}
	1679
	1680	}
	1681	++pBlendWeight;
	1682	++pBlendIdx;
	1683	}
	1684	// Finish off blend info pointers
	1685	// Make sure we skip over 4 index elements no matter how many we used
	1686	pBlendIdx += 4 - numWeightsPerVertex;
	1687	if(weightsIndexesShareBuffer)
	1688	{
	1689	// Skip index over weights
	1690	pBlendIdx += sizeof(float) * numWeightsPerVertex;
	1691	// Re-base weights
	1692	srcElemBlendWeights->baseVertexPointerToElement(pBlendIdx, &pBlendWeight);
	1693	}
	1694
	1695
	1696	// Stored blended vertex in hardware buffer
	1697	*pDestPos++ = accumVecPos.x;
	1698	*pDestPos++ = accumVecPos.y;
	1699	*pDestPos++ = accumVecPos.z;
	1700
	1701	// Stored blended vertex in temp buffer
	1702	if (includeNormals)
	1703	{
	1704	// Normalise
	1705	accumVecNorm.normalise();
	1706	if (destPosNormShareBuffer)
	1707	{
	1708	// Pack into same buffer
	1709	*pDestPos++ = accumVecNorm.x;
	1710	*pDestPos++ = accumVecNorm.y;
	1711	*pDestPos++ = accumVecNorm.z;
	1712	}
	1713	else
	1714	{
	1715	*pDestNorm++ = accumVecNorm.x;
	1716	*pDestNorm++ = accumVecNorm.y;
	1717	*pDestNorm++ = accumVecNorm.z;
	1718	}
	1719	}
	1720	}
	1721	// Unlock source buffers
	1722	srcPosBuf->unlock();
	1723	srcIdxBuf->unlock();
	1724	if (!weightsIndexesShareBuffer)
	1725	{
	1726	srcWeightBuf->unlock();
	1727	}
	1728	if (includeNormals && !srcPosNormShareBuffer)
	1729	{
	1730	srcNormBuf->unlock();
	1731	}
	1732	// Unlock destination buffers
	1733	destPosBuf->unlock();
	1734	if (includeNormals && !destPosNormShareBuffer)
	1735	{
	1736	destNormBuf->unlock();
	1737
	1738	}
	1739
	1740
	1741
	1742	}
	1743	//---------------------------------------------------------------------
	1744	size_t Mesh::calculateSize(void) const
	1745	{
	1746	// calculate GPU size
	1747	size_t ret = 0;
	1748	size_t i;
	1749	// Shared vertices
	1750	if (sharedVertexData)
	1751	{
	1752	for (i = 0;
	1753	i < sharedVertexData->vertexBufferBinding->getBufferCount();
	1754	++i)
	1755	{
	1756	ret += sharedVertexData->vertexBufferBinding
	1757	->getBuffer(i)->getSizeInBytes();
	1758	}
	1759	}
	1760
	1761	SubMeshList::const_iterator si;
	1762	for (si = mSubMeshList.begin(); si != mSubMeshList.end(); ++si)
	1763	{
	1764	// Dedicated vertices
	1765	if (!(*si)->useSharedVertices)
	1766	{
	1767	for (i = 0;
	1768	i < (*si)->vertexData->vertexBufferBinding->getBufferCount();
	1769	++i)
	1770	{
	1771	ret += (*si)->vertexData->vertexBufferBinding
	1772	->getBuffer(i)->getSizeInBytes();
	1773	}
	1774	}
	1775	// Index data
	1776	ret += (*si)->indexData->indexBuffer->getSizeInBytes();
	1777
	1778	}
	1779	return ret;
	1780	}
	1781
	1782	}
	1783

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

Download in other formats: