Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/OgreMain/src/OgreInstancedGeometry.cpp @ 1

Last change on this file since 1 was 1, checked in by landauf, 17 years ago

File size: 68.1 KB

Rev	Line
[1]	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-2006 Torus Knot Software Ltd
	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	You may alternatively use this source under the terms of a specific version of
	25	the OGRE Unrestricted License provided you have obtained such a license from
	26	Torus Knot Software Ltd.
	27	-----------------------------------------------------------------------------
	28	*/
	29	#include "OgreStableHeaders.h"
	30	#include "OgreInstancedGeometry.h"
	31	#include "OgreEntity.h"
	32	#include "OgreSubEntity.h"
	33	#include "OgreSceneNode.h"
	34	#include "OgreException.h"
	35	#include "OgreMesh.h"
	36	#include "OgreSubMesh.h"
	37	#include "OgreLogManager.h"
	38	#include "OgreSceneManager.h"
	39	#include "OgreCamera.h"
	40	#include "OgreMaterialManager.h"
	41	#include "OgreRoot.h"
	42	#include "OgreRenderSystem.h"
	43	#include "OgreEdgeListBuilder.h"
	44	#include "OgreStringConverter.h"
	45
	46	namespace Ogre {
	47
	48	#define BatchInstance_RANGE 1024
	49	#define BatchInstance_HALF_RANGE 512
	50	#define BatchInstance_MAX_INDEX 511
	51	#define BatchInstance_MIN_INDEX -512
	52
	53	//--------------------------------------------------------------------------
	54	InstancedGeometry::InstancedGeometry(SceneManager* owner, const String& name):
	55	mOwner(owner),
	56	mName(name),
	57	mBuilt(false),
	58	mUpperDistance(0.0f),
	59	mSquaredUpperDistance(0.0f),
	60	mCastShadows(false),
	61	mBatchInstanceDimensions(Vector3(1000,1000,1000)),
	62	mHalfBatchInstanceDimensions(Vector3(500,500,500)),
	63	mOrigin(Vector3(0,0,0)),
	64	mVisible(true),
	65	mRenderQueueID(RENDER_QUEUE_MAIN),
	66	mRenderQueueIDSet(false),
	67	mObjectCount(0),
	68	mInstancedGeometryInstance(0),
	69	mSkeletonInstance(0)
	70	{
	71	mBaseSkeleton.setNull();
	72	}
	73	//--------------------------------------------------------------------------
	74	InstancedGeometry::~InstancedGeometry()
	75	{
	76	reset();
	77	if(mSkeletonInstance)
	78	delete mSkeletonInstance;
	79
	80
	81	}
	82	//--------------------------------------------------------------------------
	83	InstancedGeometry::BatchInstance*InstancedGeometry::getInstancedGeometryInstance(void)
	84	{
	85	if (!mInstancedGeometryInstance)
	86	{
	87	uint32 index = 0;
	88	// Make a name
	89	StringUtil::StrStreamType str;
	90	str << mName << ":" << index;
	91
	92	mInstancedGeometryInstance = new BatchInstance(this, str.str(), mOwner, index);
	93	mOwner->injectMovableObject(mInstancedGeometryInstance);
	94	mInstancedGeometryInstance->setVisible(mVisible);
	95	mInstancedGeometryInstance->setCastShadows(mCastShadows);
	96	if (mRenderQueueIDSet)
	97	{
	98	mInstancedGeometryInstance->setRenderQueueGroup(mRenderQueueID);
	99	}
	100	mBatchInstanceMap[index] = mInstancedGeometryInstance;
	101
	102
	103	}
	104	return mInstancedGeometryInstance;
	105	}
	106	//--------------------------------------------------------------------------
	107	InstancedGeometry::BatchInstance* InstancedGeometry::getBatchInstance(const AxisAlignedBox& bounds,
	108	bool autoCreate)
	109	{
	110	if (bounds.isNull())
	111	return 0;
	112
	113	// Get the BatchInstance which has the largest overlapping volume
	114	const Vector3 min = bounds.getMinimum();
	115	const Vector3 max = bounds.getMaximum();
	116
	117	// Get the min and max BatchInstance indexes
	118	ushort minx, miny, minz;
	119	ushort maxx, maxy, maxz;
	120	getBatchInstanceIndexes(min, minx, miny, minz);
	121	getBatchInstanceIndexes(max, maxx, maxy, maxz);
	122	Real maxVolume = 0.0f;
	123	ushort finalx =0 , finaly = 0, finalz = 0;
	124	for (ushort x = minx; x <= maxx; ++x)
	125	{
	126	for (ushort y = miny; y <= maxy; ++y)
	127	{
	128	for (ushort z = minz; z <= maxz; ++z)
	129	{
	130	Real vol = getVolumeIntersection(bounds, x, y, z);
	131	if (vol > maxVolume)
	132	{
	133	maxVolume = vol;
	134	finalx = x;
	135	finaly = y;
	136	finalz = z;
	137	}
	138
	139	}
	140	}
	141	}
	142
	143	assert(maxVolume > 0.0f &&
	144	"Static geometry: Problem determining closest volume match!");
	145
	146	return getBatchInstance(finalx, finaly, finalz, autoCreate);
	147
	148	}
	149	//--------------------------------------------------------------------------
	150	Real InstancedGeometry::getVolumeIntersection(const AxisAlignedBox& box,
	151	ushort x, ushort y, ushort z)
	152	{
	153	// Get bounds of indexed BatchInstance
	154	AxisAlignedBox BatchInstanceBounds = getBatchInstanceBounds(x, y, z);
	155	AxisAlignedBox intersectBox = BatchInstanceBounds.intersection(box);
	156	// return a 'volume' which ignores zero dimensions
	157	// since we only use this for relative comparisons of the same bounds
	158	// this will still be internally consistent
	159	Vector3 boxdiff = box.getMaximum() - box.getMinimum();
	160	Vector3 intersectDiff = intersectBox.getMaximum() - intersectBox.getMinimum();
	161
	162	return (boxdiff.x == 0 ? 1 : intersectDiff.x) *
	163	(boxdiff.y == 0 ? 1 : intersectDiff.y) *
	164	(boxdiff.z == 0 ? 1 : intersectDiff.z);
	165
	166	}
	167	//--------------------------------------------------------------------------
	168	AxisAlignedBox InstancedGeometry::getBatchInstanceBounds(ushort x, ushort y, ushort z)
	169	{
	170	Vector3 min(
	171	((Real)x - BatchInstance_HALF_RANGE) * mBatchInstanceDimensions.x + mOrigin.x,
	172	((Real)y - BatchInstance_HALF_RANGE) * mBatchInstanceDimensions.y + mOrigin.y,
	173	((Real)z - BatchInstance_HALF_RANGE) * mBatchInstanceDimensions.z + mOrigin.z
	174	);
	175	Vector3 max = min + mBatchInstanceDimensions;
	176	return AxisAlignedBox(min, max);
	177	}
	178	//--------------------------------------------------------------------------
	179	Vector3 InstancedGeometry::getBatchInstanceCentre(ushort x, ushort y, ushort z)
	180	{
	181	return Vector3(
	182	((Real)x - BatchInstance_HALF_RANGE) * mBatchInstanceDimensions.x + mOrigin.x
	183	+ mHalfBatchInstanceDimensions.x,
	184	((Real)y - BatchInstance_HALF_RANGE) * mBatchInstanceDimensions.y + mOrigin.y
	185	+ mHalfBatchInstanceDimensions.y,
	186	((Real)z - BatchInstance_HALF_RANGE) * mBatchInstanceDimensions.z + mOrigin.z
	187	+ mHalfBatchInstanceDimensions.z
	188	);
	189	}
	190	//--------------------------------------------------------------------------
	191	InstancedGeometry::BatchInstance* InstancedGeometry::getBatchInstance(
	192	ushort x, ushort y, ushort z, bool autoCreate)
	193	{
	194	uint32 index = packIndex(x, y, z);
	195	BatchInstance* ret = getBatchInstance(index);
	196	if (!ret && autoCreate)
	197	{
	198	// Make a name
	199	StringUtil::StrStreamType str;
	200	str << mName << ":" << index;
	201	// Calculate the BatchInstance centre
	202	Vector3 centre(0,0,0);// = getBatchInstanceCentre(x, y, z);
	203	ret = new BatchInstance(this, str.str(), mOwner, index/, centre/);
	204	mOwner->injectMovableObject(ret);
	205	ret->setVisible(mVisible);
	206	ret->setCastShadows(mCastShadows);
	207	if (mRenderQueueIDSet)
	208	{
	209	ret->setRenderQueueGroup(mRenderQueueID);
	210	}
	211	mBatchInstanceMap[index] = ret;
	212	}
	213	return ret;
	214	}
	215	//--------------------------------------------------------------------------
	216	InstancedGeometry::BatchInstance* InstancedGeometry::getBatchInstance(uint32 index)
	217	{
	218	BatchInstanceMap::iterator i = mBatchInstanceMap.find(index);
	219	if (i != mBatchInstanceMap.end())
	220	{
	221	return i->second;
	222	}
	223	else
	224	{
	225	return 0;
	226	}
	227
	228	}
	229	//--------------------------------------------------------------------------
	230	void InstancedGeometry::getBatchInstanceIndexes(const Vector3& point,
	231	ushort& x, ushort& y, ushort& z)
	232	{
	233	// Scale the point into multiples of BatchInstance and adjust for origin
	234	Vector3 scaledPoint = (point - mOrigin) / mBatchInstanceDimensions;
	235
	236	// Round down to 'bottom left' point which represents the cell index
	237	int ix = Math::IFloor(scaledPoint.x);
	238	int iy = Math::IFloor(scaledPoint.y);
	239	int iz = Math::IFloor(scaledPoint.z);
	240
	241	// Check bounds
	242	if (ix < BatchInstance_MIN_INDEX \|\| ix > BatchInstance_MAX_INDEX
	243	\|\| iy < BatchInstance_MIN_INDEX \|\| iy > BatchInstance_MAX_INDEX
	244	\|\| iz < BatchInstance_MIN_INDEX \|\| iz > BatchInstance_MAX_INDEX)
	245	{
	246	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	247	"Point out of bounds",
	248	"InstancedGeometry::getBatchInstanceIndexes");
	249	}
	250	// Adjust for the fact that we use unsigned values for simplicity
	251	// (requires less faffing about for negatives give 10-bit packing
	252	x = static_cast<ushort>(ix + BatchInstance_HALF_RANGE);
	253	y = static_cast<ushort>(iy + BatchInstance_HALF_RANGE);
	254	z = static_cast<ushort>(iz + BatchInstance_HALF_RANGE);
	255
	256
	257	}
	258	//--------------------------------------------------------------------------
	259	uint32 InstancedGeometry::packIndex(ushort x, ushort y, ushort z)
	260	{
	261	return x + (y << 10) + (z << 20);
	262	}
	263	//--------------------------------------------------------------------------
	264	InstancedGeometry::BatchInstance* InstancedGeometry::getBatchInstance(const Vector3& point,
	265	bool autoCreate)
	266	{
	267	ushort x, y, z;
	268	getBatchInstanceIndexes(point, x, y, z);
	269	return getBatchInstance(x, y, z, autoCreate);
	270	}
	271	//--------------------------------------------------------------------------
	272	AxisAlignedBox InstancedGeometry::calculateBounds(VertexData* vertexData,
	273	const Vector3& position, const Quaternion& orientation,
	274	const Vector3& scale)
	275	{
	276	const VertexElement* posElem =
	277	vertexData->vertexDeclaration->findElementBySemantic(
	278	VES_POSITION);
	279	HardwareVertexBufferSharedPtr vbuf =
	280	vertexData->vertexBufferBinding->getBuffer(posElem->getSource());
	281	unsigned char* vertex =
	282	static_cast<unsigned char*>(
	283	vbuf->lock(HardwareBuffer::HBL_READ_ONLY));
	284	float* pFloat;
	285
	286	Vector3 min, max;
	287	bool first = true;
	288
	289	for(size_t j = 0; j < vertexData->vertexCount; ++j, vertex += vbuf->getVertexSize())
	290	{
	291	posElem->baseVertexPointerToElement(vertex, &pFloat);
	292
	293	Vector3 pt;
	294
	295	pt.x = (*pFloat++);
	296	pt.y = (*pFloat++);
	297	pt.z = (*pFloat++);
	298	// Transform to world (scale, rotate, translate)
	299	pt = (orientation * (pt * scale)) + position;
	300	if (first)
	301	{
	302	min = max = pt;
	303	first = false;
	304	}
	305	else
	306	{
	307	min.makeFloor(pt);
	308	max.makeCeil(pt);
	309	}
	310
	311	}
	312	vbuf->unlock();
	313	return AxisAlignedBox(min, max);
	314	}
	315	//--------------------------------------------------------------------------
	316	void InstancedGeometry::addEntity(Entity* ent, const Vector3& position,
	317	const Quaternion& orientation, const Vector3& scale)
	318	{
	319
	320	const MeshPtr& msh = ent->getMesh();
	321	// Validate
	322	if (msh->isLodManual())
	323	{
	324	LogManager::getSingleton().logMessage(
	325	"WARNING (InstancedGeometry): Manual LOD is not supported. "
	326	"Using only highest LOD level for mesh " + msh->getName());
	327	}
	328
	329	//get the skeleton of the entity, if that's not already done
	330	if(!ent->getMesh()->getSkeleton().isNull()&&mBaseSkeleton.isNull())
	331	{
	332	mBaseSkeleton=ent->getMesh()->getSkeleton();
	333	mSkeletonInstance=new SkeletonInstance(mBaseSkeleton);
	334	mSkeletonInstance->load();
	335	mAnimationState=ent->getAllAnimationStates();
	336	}
	337	AxisAlignedBox sharedWorldBounds;
	338	// queue this entities submeshes and choice of material
	339	// also build the lists of geometry to be used for the source of lods
	340
	341
	342	for (uint i = 0; i < ent->getNumSubEntities(); ++i)
	343	{
	344	SubEntity* se = ent->getSubEntity(i);
	345	QueuedSubMesh* q = new QueuedSubMesh();
	346
	347	// Get the geometry for this SubMesh
	348	q->submesh = se->getSubMesh();
	349	q->geometryLodList = determineGeometry(q->submesh);
	350	q->materialName = se->getMaterialName();
	351	q->orientation = orientation;
	352	q->position = position;
	353	q->scale = scale;
	354	q->ID = mObjectCount;
	355	// Determine the bounds based on the highest LOD
	356	q->worldBounds = calculateBounds(
	357	(*q->geometryLodList)[0].vertexData,
	358	position, orientation, scale);
	359
	360	mQueuedSubMeshes.push_back(q);
	361	}
	362	mObjectCount++;
	363
	364	}
	365	//--------------------------------------------------------------------------
	366	InstancedGeometry::SubMeshLodGeometryLinkList*
	367	InstancedGeometry::determineGeometry(SubMesh* sm)
	368	{
	369	// First, determine if we've already seen this submesh before
	370	SubMeshGeometryLookup::iterator i =
	371	mSubMeshGeometryLookup.find(sm);
	372	if (i != mSubMeshGeometryLookup.end())
	373	{
	374	return i->second;
	375	}
	376	// Otherwise, we have to create a new one
	377	SubMeshLodGeometryLinkList* lodList = new SubMeshLodGeometryLinkList();
	378	mSubMeshGeometryLookup[sm] = lodList;
	379	ushort numLods = sm->parent->isLodManual() ? 1 :
	380	sm->parent->getNumLodLevels();
	381	lodList->resize(numLods);
	382	for (ushort lod = 0; lod < numLods; ++lod)
	383	{
	384	SubMeshLodGeometryLink& geomLink = (*lodList)[lod];
	385	IndexData *lodIndexData;
	386	if (lod == 0)
	387	{
	388	lodIndexData = sm->indexData;
	389	}
	390	else
	391	{
	392	lodIndexData = sm->mLodFaceList[lod - 1];
	393	}
	394	// Can use the original mesh geometry?
	395	if (sm->useSharedVertices)
	396	{
	397	if (sm->parent->getNumSubMeshes() == 1)
	398	{
	399	// Ok, this is actually our own anyway
	400	geomLink.vertexData = sm->parent->sharedVertexData;
	401	geomLink.indexData = lodIndexData;
	402	}
	403	else
	404	{
	405	// We have to split it
	406	splitGeometry(sm->parent->sharedVertexData,
	407	lodIndexData, &geomLink);
	408	}
	409	}
	410	else
	411	{
	412	if (lod == 0)
	413	{
	414	// Ok, we can use the existing geometry; should be in full
	415	// use by just this SubMesh
	416	geomLink.vertexData = sm->vertexData;
	417	geomLink.indexData = sm->indexData;
	418	}
	419	else
	420	{
	421	// We have to split it
	422	splitGeometry(sm->vertexData,
	423	lodIndexData, &geomLink);
	424	}
	425	}
	426	assert (geomLink.vertexData->vertexStart == 0 &&
	427	"Cannot use vertexStart > 0 on indexed geometry due to "
	428	"rendersystem incompatibilities - see the docs!");
	429	}
	430
	431
	432	return lodList;
	433	}
	434	//--------------------------------------------------------------------------
	435	void InstancedGeometry::splitGeometry(VertexData* vd, IndexData* id,
	436	InstancedGeometry::SubMeshLodGeometryLink* targetGeomLink)
	437	{
	438	// Firstly we need to scan to see how many vertices are being used
	439	// and while we're at it, build the remap we can use later
	440	bool use32bitIndexes =
	441	id->indexBuffer->getType() == HardwareIndexBuffer::IT_32BIT;
	442	uint16 *p16;
	443	uint32 *p32;
	444	IndexRemap indexRemap;
	445	if (use32bitIndexes)
	446	{
	447	p32 = static_cast<uint32*>(id->indexBuffer->lock(
	448	id->indexStart,
	449	id->indexCount * id->indexBuffer->getIndexSize(),
	450	HardwareBuffer::HBL_READ_ONLY));
	451	buildIndexRemap(p32, id->indexCount, indexRemap);
	452	id->indexBuffer->unlock();
	453	}
	454	else
	455	{
	456	p16 = static_cast<uint16*>(id->indexBuffer->lock(
	457	id->indexStart,
	458	id->indexCount * id->indexBuffer->getIndexSize(),
	459	HardwareBuffer::HBL_READ_ONLY));
	460	buildIndexRemap(p16, id->indexCount, indexRemap);
	461	id->indexBuffer->unlock();
	462	}
	463	if (indexRemap.size() == vd->vertexCount)
	464	{
	465	// ha, complete usage after all
	466	targetGeomLink->vertexData = vd;
	467	targetGeomLink->indexData = id;
	468	return;
	469	}
	470
	471
	472	// Create the new vertex data records
	473	targetGeomLink->vertexData = vd->clone(false);
	474	// Convenience
	475	VertexData* newvd = targetGeomLink->vertexData;
	476	//IndexData* newid = targetGeomLink->indexData;
	477	// Update the vertex count
	478	newvd->vertexCount = indexRemap.size();
	479
	480	size_t numvbufs = vd->vertexBufferBinding->getBufferCount();
	481	// Copy buffers from old to new
	482	for (unsigned short b = 0; b < numvbufs; ++b)
	483	{
	484	// Lock old buffer
	485	HardwareVertexBufferSharedPtr oldBuf =
	486	vd->vertexBufferBinding->getBuffer(b);
	487	// Create new buffer
	488	HardwareVertexBufferSharedPtr newBuf =
	489	HardwareBufferManager::getSingleton().createVertexBuffer(
	490	oldBuf->getVertexSize(),
	491	indexRemap.size(),
	492	HardwareBuffer::HBU_STATIC);
	493	// rebind
	494	newvd->vertexBufferBinding->setBinding(b, newBuf);
	495
	496	// Copy all the elements of the buffer across, by iterating over
	497	// the IndexRemap which describes how to move the old vertices
	498	// to the new ones. By nature of the map the remap is in order of
	499	// indexes in the old buffer, but note that we're not guaranteed to
	500	// address every vertex (which is kinda why we're here)
	501	uchar* pSrcBase = static_cast<uchar*>(
	502	oldBuf->lock(HardwareBuffer::HBL_READ_ONLY));
	503	uchar* pDstBase = static_cast<uchar*>(
	504	newBuf->lock(HardwareBuffer::HBL_DISCARD));
	505	size_t vertexSize = oldBuf->getVertexSize();
	506	// Buffers should be the same size
	507	assert (vertexSize == newBuf->getVertexSize());
	508
	509	for (IndexRemap::iterator r = indexRemap.begin();
	510	r != indexRemap.end(); ++r)
	511	{
	512	assert (r->first < oldBuf->getNumVertices());
	513	assert (r->second < newBuf->getNumVertices());
	514
	515	uchar* pSrc = pSrcBase + r->first * vertexSize;
	516	uchar* pDst = pDstBase + r->second * vertexSize;
	517	memcpy(pDst, pSrc, vertexSize);
	518	}
	519	// unlock
	520	oldBuf->unlock();
	521	newBuf->unlock();
	522
	523	}
	524
	525	// Now create a new index buffer
	526	HardwareIndexBufferSharedPtr ibuf =
	527	HardwareBufferManager::getSingleton().createIndexBuffer(
	528	id->indexBuffer->getType(), id->indexCount,
	529	HardwareBuffer::HBU_STATIC);
	530
	531	if (use32bitIndexes)
	532	{
	533	uint32 pSrc32, pDst32;
	534	pSrc32 = static_cast<uint32*>(id->indexBuffer->lock(
	535	id->indexStart, id->indexCount * id->indexBuffer->getIndexSize(),
	536	HardwareBuffer::HBL_READ_ONLY));
	537	pDst32 = static_cast<uint32*>(ibuf->lock(
	538	HardwareBuffer::HBL_DISCARD));
	539	remapIndexes(pSrc32, pDst32, indexRemap, id->indexCount);
	540	id->indexBuffer->unlock();
	541	ibuf->unlock();
	542	}
	543	else
	544	{
	545	uint16 pSrc16, pDst16;
	546	pSrc16 = static_cast<uint16*>(id->indexBuffer->lock(
	547	id->indexStart, id->indexCount * id->indexBuffer->getIndexSize(),
	548	HardwareBuffer::HBL_READ_ONLY));
	549	pDst16 = static_cast<uint16*>(ibuf->lock(
	550	HardwareBuffer::HBL_DISCARD));
	551	remapIndexes(pSrc16, pDst16, indexRemap, id->indexCount);
	552	id->indexBuffer->unlock();
	553	ibuf->unlock();
	554	}
	555
	556	targetGeomLink->indexData = new IndexData();
	557	targetGeomLink->indexData->indexStart = 0;
	558	targetGeomLink->indexData->indexCount = id->indexCount;
	559	targetGeomLink->indexData->indexBuffer = ibuf;
	560
	561	// Store optimised geometry for deallocation later
	562	OptimisedSubMeshGeometry *optGeom = new OptimisedSubMeshGeometry();
	563	optGeom->indexData = targetGeomLink->indexData;
	564	optGeom->vertexData = targetGeomLink->vertexData;
	565	mOptimisedSubMeshGeometryList.push_back(optGeom);
	566	}
	567	//--------------------------------------------------------------------------
	568	void InstancedGeometry::addSceneNode(const SceneNode* node)
	569	{
	570	SceneNode::ConstObjectIterator obji = node->getAttachedObjectIterator();
	571	while (obji.hasMoreElements())
	572	{
	573	MovableObject* mobj = obji.getNext();
	574	if (mobj->getMovableType() == "Entity")
	575	{
	576	addEntity(static_cast<Entity*>(mobj),
	577	node->_getDerivedPosition(),
	578	node->_getDerivedOrientation(),
	579	node->_getDerivedScale());
	580	}
	581	}
	582	// Iterate through all the child-nodes
	583	SceneNode::ConstChildNodeIterator nodei = node->getChildIterator();
	584
	585	while (nodei.hasMoreElements())
	586	{
	587	const SceneNode* newNode = static_cast<const SceneNode*>(nodei.getNext());
	588	// Add this subnode and its children...
	589	addSceneNode( newNode );
	590	}
	591	}
	592	//--------------------------------------------------------------------------
	593	void InstancedGeometry::build(void)
	594	{
	595	// Make sure there's nothing from previous builds
	596	destroy();
	597
	598	// Firstly allocate meshes to BatchInstances
	599	for (QueuedSubMeshList::iterator qi = mQueuedSubMeshes.begin();
	600	qi != mQueuedSubMeshes.end(); ++qi)
	601	{
	602	QueuedSubMesh* qsm = *qi;
	603	//BatchInstance* BatchInstance = getBatchInstance(qsm->worldBounds, true);
	604	BatchInstance* batchInstance = getInstancedGeometryInstance();
	605	batchInstance->assign(qsm);
	606	}
	607
	608	// Now tell each BatchInstance to build itself
	609	for (BatchInstanceMap::iterator ri = mBatchInstanceMap.begin();
	610	ri != mBatchInstanceMap.end(); ++ri)
	611	{
	612	ri->second->build();
	613	}
	614
	615
	616	}
	617	//--------------------------------------------------------------------------
	618	void InstancedGeometry::addBatchInstance(void)
	619	{
	620
	621
	622	BatchInstanceIterator regIt = getBatchInstanceIterator();
	623	BatchInstance*lastBatchInstance=0 ;
	624	while(regIt.hasMoreElements())
	625	{
	626	lastBatchInstance= regIt.getNext();
	627	}
	628	uint32 index=(lastBatchInstance)?lastBatchInstance->getID()+1:0;
	629	//create a new BatchInstance
	630
	631	BatchInstance*ret = new BatchInstance(this, mName+":"+StringConverter::toString(index),
	632	mOwner, index);
	633
	634	ret->attachToScene();
	635
	636	mOwner->injectMovableObject(ret);
	637	ret->setVisible(mVisible);
	638	ret->setCastShadows(mCastShadows);
	639	mBatchInstanceMap[index] = ret;
	640
	641	if (mRenderQueueIDSet)
	642	{
	643	ret->setRenderQueueGroup(mRenderQueueID);
	644	}
	645
	646	const size_t numLod = lastBatchInstance->mLodSquaredDistances.size();
	647	ret->mLodSquaredDistances.resize(numLod);
	648	for (ushort lod = 0; lod < numLod; lod++)
	649	{
	650	ret->mLodSquaredDistances[lod] =
	651	lastBatchInstance->mLodSquaredDistances[lod];
	652	}
	653
	654
	655
	656	// update bounds
	657	AxisAlignedBox box(lastBatchInstance->mAABB.getMinimum(),lastBatchInstance->mAABB.getMaximum());
	658	ret->mAABB.merge(box);
	659
	660	ret->mBoundingRadius = lastBatchInstance->mBoundingRadius ;
	661	//now create news instanced objects
	662	BatchInstance::ObjectsMap::iterator objIt;
	663	for(objIt=lastBatchInstance->getInstancesMap().begin();objIt!=lastBatchInstance->getInstancesMap().end();objIt++)
	664	{
	665	InstancedObject* instancedObject = ret->isInstancedObjectPresent(objIt->first);
	666	if(instancedObject == NULL)
	667	{
	668	if(mBaseSkeleton.isNull())
	669	{
	670	instancedObject=new InstancedObject(objIt->first);
	671	}
	672	else
	673	{
	674	instancedObject=new InstancedObject(objIt->first,mSkeletonInstance,mAnimationState);
	675	}
	676	ret->addInstancedObject(objIt->first,instancedObject);
	677	}
	678
	679	}
	680
	681
	682
	683	BatchInstance::LODIterator lodIterator = lastBatchInstance->getLODIterator();
	684	//parse all the lod buckets of the BatchInstance
	685	while (lodIterator.hasMoreElements())
	686	{
	687
	688	LODBucket* lod = lodIterator.getNext();
	689	//create a new lod bucket for the new BatchInstance
	690	LODBucket* lodBucket= new LODBucket(ret,lod->getLod(),lod->getSquaredDistance());
	691
	692	//add the lod bucket to the BatchInstance list
	693	ret->updateContainers(lodBucket);
	694
	695	LODBucket::MaterialIterator matIt = lod->getMaterialIterator();
	696	//parse all the material buckets of the lod bucket
	697	while (matIt.hasMoreElements())
	698	{
	699
	700	MaterialBucket*mat = matIt.getNext();
	701	//create a new material bucket
	702	String materialName=mat->getMaterialName();
	703	MaterialBucket* matBucket = new MaterialBucket(lodBucket,materialName);
	704
	705	//add the material bucket to the lod buckets list and map
	706	lodBucket->updateContainers(matBucket, materialName);
	707
	708	MaterialBucket::GeometryIterator geomIt = mat->getGeometryIterator();
	709	//parse all the geometry buckets of the material bucket
	710	while(geomIt.hasMoreElements())
	711	{
	712	//get the source geometry bucket
	713	GeometryBucket *geom = geomIt.getNext();
	714	//create a new geometry bucket
	715	GeometryBucket *geomBucket = new GeometryBucket(matBucket,geom->getFormatString(),geom);
	716
	717	//update the material bucket map of the material bucket
	718	matBucket->updateContainers(geomBucket, geomBucket->getFormatString() );
	719
	720	//copy bounding informations
	721	geomBucket->getAABB()=geom->getAABB();
	722	geomBucket->setBoundingBox( geom->getBoundingBox());
	723	//now setups the news InstancedObjects.
	724	for(objIt=ret->getInstancesMap().begin();objIt!=ret->getInstancesMap().end();objIt++)
	725	{
	726	//get the destination IntanciedObject
	727	InstancedObject*obj=objIt->second;
	728	InstancedObject::GeometryBucketList::iterator findIt;
	729	//check if the bucket is not already in the list
	730	findIt=std::find(obj->getGeometryBucketList().begin(),obj->getGeometryBucketList().end(),geomBucket);
	731	if(findIt==obj->getGeometryBucketList().end())
	732	obj->addBucketToList(geomBucket);
	733	}
	734
	735
	736	}
	737	}
	738	}
	739	}
	740	//--------------------------------------------------------------------------
	741	void InstancedGeometry::BatchInstance::updateContainers(LODBucket* bucket )
	742	{
	743	mLodBucketList.push_back(bucket);
	744	}
	745	//--------------------------------------------------------------------------
	746	void InstancedGeometry::LODBucket::updateContainers(MaterialBucket* bucket, String& name )
	747	{
	748	mMaterialBucketMap[name] = bucket;
	749	}
	750
	751	//--------------------------------------------------------------------------
	752	String InstancedGeometry::GeometryBucket::getFormatString(void) const
	753	{
	754	return mFormatString;
	755	}
	756	//--------------------------------------------------------------------------
	757	void InstancedGeometry::BatchInstance::attachToScene()
	758	{
	759
	760	mNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(mName/,mCentre/);
	761	mNode->attachObject(this);
	762	}
	763	//--------------------------------------------------------------------------
	764	void InstancedGeometry::MaterialBucket::updateContainers(InstancedGeometry::GeometryBucket* bucket, const String & format)
	765	{
	766	mCurrentGeometryMap[format]=bucket;
	767	mGeometryBucketList.push_back(bucket);
	768	}
	769	void InstancedGeometry::MaterialBucket:: setMaterial(const String & name)
	770	{
	771	mMaterial=MaterialManager::getSingleton().getByName(name);
	772	};
	773	//--------------------------------------------------------------------------
	774	void InstancedGeometry::destroy(void)
	775	{
	776	RenderOperationVector::iterator it;
	777	for(it=mRenderOps.begin();it!=mRenderOps.end();++it)
	778	{
	779	delete (*it)->vertexData;
	780	delete (*it)->indexData;
	781
	782	}
	783	// delete the BatchInstances
	784	for (BatchInstanceMap::iterator i = mBatchInstanceMap.begin();
	785	i != mBatchInstanceMap.end(); ++i)
	786	{
	787	mOwner->extractMovableObject(i->second);
	788	delete i->second;
	789
	790	}
	791	mBatchInstanceMap.clear();
	792	}
	793	//--------------------------------------------------------------------------
	794	void InstancedGeometry::reset(void)
	795	{
	796	destroy();
	797
	798	for (QueuedSubMeshList::iterator i = mQueuedSubMeshes.begin();
	799	i != mQueuedSubMeshes.end(); ++i)
	800	{
	801	delete *i;
	802
	803	}
	804	mQueuedSubMeshes.clear();
	805	// Delete precached geoemtry lists
	806	for (SubMeshGeometryLookup::iterator l = mSubMeshGeometryLookup.begin();
	807	l != mSubMeshGeometryLookup.end(); ++l)
	808	{
	809	delete l->second;
	810
	811	}
	812	mSubMeshGeometryLookup.clear();
	813	// Delete optimised geometry
	814	for (OptimisedSubMeshGeometryList::iterator o = mOptimisedSubMeshGeometryList.begin();
	815	o != mOptimisedSubMeshGeometryList.end(); ++o)
	816	{
	817	delete *o;
	818
	819	}
	820	mOptimisedSubMeshGeometryList.clear();
	821
	822	}
	823	//--------------------------------------------------------------------------
	824	void InstancedGeometry::setVisible(bool visible)
	825	{
	826
	827	mVisible = visible;
	828	// tell any existing BatchInstances
	829	for (BatchInstanceMap::iterator ri = mBatchInstanceMap.begin();
	830	ri != mBatchInstanceMap.end(); ++ri)
	831	{
	832
	833
	834	ri->second->setVisible(visible);
	835	}
	836	}
	837	//--------------------------------------------------------------------------
	838	void InstancedGeometry::setCastShadows(bool castShadows)
	839	{
	840	mCastShadows = castShadows;
	841	// tell any existing BatchInstances
	842	for (BatchInstanceMap::iterator ri = mBatchInstanceMap.begin();
	843	ri != mBatchInstanceMap.end(); ++ri)
	844	{
	845	ri->second->setCastShadows(castShadows);
	846	}
	847
	848	}
	849	//--------------------------------------------------------------------------
	850	void InstancedGeometry::setRenderQueueGroup(uint8 queueID)
	851	{
	852	assert(queueID <= RENDER_QUEUE_MAX && "Render queue out of range!");
	853	mRenderQueueIDSet = true;
	854	mRenderQueueID = queueID;
	855	// tell any existing BatchInstances
	856	for (BatchInstanceMap::iterator ri = mBatchInstanceMap.begin();
	857	ri != mBatchInstanceMap.end(); ++ri)
	858	{
	859	ri->second->setRenderQueueGroup(queueID);
	860	}
	861	}
	862	//--------------------------------------------------------------------------
	863	uint8 InstancedGeometry::getRenderQueueGroup(void) const
	864	{
	865	return mRenderQueueID;
	866	}
	867	//--------------------------------------------------------------------------
	868	void InstancedGeometry::dump(const String& filename) const
	869	{
	870	std::ofstream of(filename.c_str());
	871	of << "Static Geometry Report for " << mName << std::endl;
	872	of << "-------------------------------------------------" << std::endl;
	873	of << "Number of queued submeshes: " << mQueuedSubMeshes.size() << std::endl;
	874	of << "Number of BatchInstances: " << mBatchInstanceMap.size() << std::endl;
	875	of << "BatchInstance dimensions: " << mBatchInstanceDimensions << std::endl;
	876	of << "Origin: " << mOrigin << std::endl;
	877	of << "Max distance: " << mUpperDistance << std::endl;
	878	of << "Casts shadows?: " << mCastShadows << std::endl;
	879	of << std::endl;
	880	for (BatchInstanceMap::const_iterator ri = mBatchInstanceMap.begin();
	881	ri != mBatchInstanceMap.end(); ++ri)
	882	{
	883	ri->second->dump(of);
	884	}
	885	of << "-------------------------------------------------" << std::endl;
	886	}
	887	//--------------------------------------------------------------------------
	888	InstancedGeometry::InstancedObject::InstancedObject(int index,SkeletonInstance skeleton, AnimationStateSetanimations):mIndex(index),
	889	mTransformation(Matrix4::ZERO),
	890	mOrientation(Quaternion::IDENTITY),
	891	mScale(Vector3::UNIT_SCALE),
	892	mPosition(Vector3::ZERO),
	893	mSkeletonInstance(skeleton),
	894	mBoneWorldMatrices(NULL),
	895	mBoneMatrices(NULL),
	896	mNumBoneMatrices(0),
	897	mFrameAnimationLastUpdated(std::numeric_limits<unsigned long>::max())
	898
	899	{
	900
	901	mSkeletonInstance->load();
	902
	903	mAnimationState = new AnimationStateSet();
	904	mNumBoneMatrices = mSkeletonInstance->getNumBones();
	905	mBoneMatrices = new Matrix4[mNumBoneMatrices];
	906	AnimationStateIterator it=animations->getAnimationStateIterator();
	907	while (it.hasMoreElements())
	908	{
	909	AnimationState*anim= it.getNext();
	910	mAnimationState->createAnimationState(anim->getAnimationName(),anim->getTimePosition(),anim->getLength(),
	911	anim->getWeight());
	912
	913	}
	914
	915	}
	916	//--------------------------------------------------------------------------
	917	InstancedGeometry::InstancedObject::InstancedObject(int index):mIndex(index),
	918	mTransformation(Matrix4::ZERO),
	919	mOrientation(Quaternion::IDENTITY),
	920	mScale(Vector3::UNIT_SCALE),
	921	mPosition(Vector3::ZERO),
	922	mSkeletonInstance(0),
	923	mBoneWorldMatrices(0),
	924	mBoneMatrices(0),
	925	mAnimationState(0),
	926	mNumBoneMatrices(0),
	927	mFrameAnimationLastUpdated(std::numeric_limits<unsigned long>::max())
	928	{
	929	}
	930	//--------------------------------------------------------------------------
	931	InstancedGeometry::InstancedObject::~InstancedObject()
	932	{
	933	mGeometryBucketList.clear();
	934	delete mAnimationState;
	935	delete[] mBoneMatrices;
	936	delete[] mBoneWorldMatrices;
	937	}
	938	//--------------------------------------------------------------------------
	939	void InstancedGeometry::InstancedObject::addBucketToList(GeometryBucket*bucket)
	940	{
	941	mGeometryBucketList.push_back(bucket);
	942	}
	943	//--------------------------------------------------------------------------
	944	void InstancedGeometry::InstancedObject::setPosition( Vector3 position)
	945	{
	946
	947	mPosition=position;
	948	needUpdate();
	949	BatchInstanceparentBatchInstance=((mGeometryBucketList.begin()))->getParent()->getParent()->getParent();
	950	parentBatchInstance->updateBoundingBox();
	951
	952	}
	953	//--------------------------------------------------------------------------
	954	void InstancedGeometry::InstancedObject::translate(const Vector3 &d)
	955	{
	956	mPosition += d;
	957	needUpdate();
	958	}
	959	//--------------------------------------------------------------------------
	960	void InstancedGeometry::InstancedObject::translate(const Matrix3 & axes,const Vector3 &move)
	961	{
	962	Vector3 derived = axes * move;
	963	translate(derived);
	964	}
	965	//--------------------------------------------------------------------------
	966	Matrix3 InstancedGeometry::InstancedObject::getLocalAxes() const
	967	{
	968	Vector3 axisX = Vector3::UNIT_X;
	969	Vector3 axisY = Vector3::UNIT_Y;
	970	Vector3 axisZ = Vector3::UNIT_Z;
	971
	972	axisX = mOrientation * axisX;
	973	axisY = mOrientation * axisY;
	974	axisZ = mOrientation * axisZ;
	975
	976	return Matrix3(axisX.x, axisY.x, axisZ.x,
	977	axisX.y, axisY.y, axisZ.y,
	978	axisX.z, axisY.z, axisZ.z);
	979	}
	980	//--------------------------------------------------------------------------
	981	Vector3 & InstancedGeometry::InstancedObject::getPosition(void)
	982	{
	983	return mPosition;
	984	}
	985	//--------------------------------------------------------------------------
	986	void InstancedGeometry::InstancedObject::yaw(const Radian&angle)
	987	{
	988	Quaternion q;
	989	q.FromAngleAxis(angle,Vector3::UNIT_Y);
	990	rotate(q);
	991	}
	992	//--------------------------------------------------------------------------
	993	void InstancedGeometry::InstancedObject::pitch(const Radian&angle)
	994	{
	995	Quaternion q;
	996	q.FromAngleAxis(angle,Vector3::UNIT_X);
	997	rotate(q);
	998	}
	999	//--------------------------------------------------------------------------
	1000	void InstancedGeometry::InstancedObject::roll(const Radian&angle)
	1001	{
	1002	Quaternion q;
	1003	q.FromAngleAxis(angle,Vector3::UNIT_Z);
	1004	rotate(q);
	1005
	1006	}
	1007	//--------------------------------------------------------------------------
	1008	void InstancedGeometry::InstancedObject::setScale(const Vector3&scale)
	1009	{
	1010	mScale=scale;
	1011	needUpdate();
	1012	}
	1013	//--------------------------------------------------------------------------
	1014	void InstancedGeometry::InstancedObject::rotate(const Quaternion& q)
	1015	{
	1016
	1017	mOrientation = mOrientation * q;
	1018	needUpdate();
	1019	}
	1020	//--------------------------------------------------------------------------
	1021	void InstancedGeometry::InstancedObject::needUpdate()
	1022	{
	1023	mTransformation.makeTransform(
	1024	mPosition,
	1025	mScale,
	1026	mOrientation);
	1027
	1028
	1029	}
	1030	//--------------------------------------------------------------------------
	1031	void InstancedGeometry::InstancedObject::updateAnimation(void)
	1032	{
	1033
	1034	if(mSkeletonInstance)
	1035	{
	1036	GeometryBucketList::iterator it;
	1037	mSkeletonInstance->setAnimationState(*mAnimationState);
	1038	mSkeletonInstance->_getBoneMatrices(mBoneMatrices);
	1039
	1040	// Allocate bone world matrices on demand, for better memory footprint
	1041	// when using software animation.
	1042	if (!mBoneWorldMatrices)
	1043	{
	1044	mBoneWorldMatrices = new Matrix4[mNumBoneMatrices];
	1045	}
	1046
	1047	for (unsigned short i = 0; i < mNumBoneMatrices; ++i)
	1048	{
	1049	mBoneWorldMatrices[i] = mTransformation * mBoneMatrices[i];
	1050
	1051	}
	1052
	1053
	1054
	1055	}
	1056
	1057	}
	1058	//--------------------------------------------------------------------------
	1059	AnimationState* InstancedGeometry::InstancedObject::getAnimationState(const String& name) const
	1060	{
	1061	if (!mAnimationState)
	1062	{
	1063	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Object is not animated",
	1064	"InstancedGeometry::InstancedObject::getAnimationState");
	1065	}
	1066	// AnimationStateIterator it=mAnimationState->getAnimationStateIterator();
	1067	// while (it.hasMoreElements())
	1068	// {
	1069	// AnimationState*anim= it.getNext();
	1070	//
	1071	//
	1072	// }
	1073	return mAnimationState->getAnimationState(name);
	1074	}
	1075	//--------------------------------------------------------------------------
	1076	InstancedGeometry::BatchInstanceIterator InstancedGeometry::getBatchInstanceIterator(void)
	1077	{
	1078	return BatchInstanceIterator(mBatchInstanceMap.begin(), mBatchInstanceMap.end());
	1079	}
	1080	//--------------------------------------------------------------------------
	1081	InstancedGeometry::BatchInstance::BatchInstance(InstancedGeometry* parent, const String& name,
	1082	SceneManager* mgr, uint32 BatchInstanceID)
	1083	: MovableObject(name), mParent(parent), mSceneMgr(mgr), mNode(0),
	1084	mBatchInstanceID(BatchInstanceID), mBoundingRadius(0.0f),
	1085	mCurrentLod(0)
	1086	{
	1087	// First LOD mandatory, and always from 0
	1088	mLodSquaredDistances.push_back(0.0f);
	1089	}
	1090	//--------------------------------------------------------------------------
	1091	InstancedGeometry::BatchInstance::~BatchInstance()
	1092	{
	1093	if (mNode)
	1094	{
	1095	mNode->getParentSceneNode()->removeChild(mNode);
	1096	mSceneMgr->destroySceneNode(mNode->getName());
	1097	mNode = 0;
	1098	}
	1099	// delete
	1100	for (LODBucketList::iterator i = mLodBucketList.begin();
	1101	i != mLodBucketList.end(); ++i)
	1102	{
	1103	delete *i;
	1104	}
	1105	mLodBucketList.clear();
	1106	ObjectsMap::iterator o;
	1107
	1108	for(o=mInstancesMap.begin();o!=mInstancesMap.end();o++)
	1109	{
	1110	delete o->second;
	1111	}
	1112	mInstancesMap.clear();
	1113	// no need to delete queued meshes, these are managed in InstancedGeometry
	1114	}
	1115	//--------------------------------------------------------------------------
	1116	void InstancedGeometry::BatchInstance::assign(QueuedSubMesh* qmesh)
	1117	{
	1118	mQueuedSubMeshes.push_back(qmesh);
	1119	// update lod distances
	1120	ushort lodLevels = qmesh->submesh->parent->getNumLodLevels();
	1121	assert(qmesh->geometryLodList->size() == lodLevels);
	1122
	1123	while(mLodSquaredDistances.size() < lodLevels)
	1124	{
	1125	mLodSquaredDistances.push_back(0.0f);
	1126	}
	1127	// Make sure LOD levels are max of all at the requested level
	1128	for (ushort lod = 1; lod < lodLevels; ++lod)
	1129	{
	1130	const MeshLodUsage& meshLod =
	1131	qmesh->submesh->parent->getLodLevel(lod);
	1132	mLodSquaredDistances[lod] = std::max(mLodSquaredDistances[lod],
	1133	meshLod.fromDepthSquared);
	1134	}
	1135
	1136	// update bounds
	1137	// Transform world bounds relative to our centre
	1138	AxisAlignedBox localBounds(
	1139	qmesh->worldBounds.getMinimum() ,
	1140	qmesh->worldBounds.getMaximum());
	1141	mAABB.merge(localBounds);
	1142	mBoundingRadius = std::max(mBoundingRadius, localBounds.getMinimum().length());
	1143	mBoundingRadius = std::max(mBoundingRadius, localBounds.getMaximum().length());
	1144
	1145	}
	1146	//--------------------------------------------------------------------------
	1147	void InstancedGeometry::BatchInstance::build()
	1148	{
	1149	// Create a node
	1150	mNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(mName);
	1151	mNode->attachObject(this);
	1152	// We need to create enough LOD buckets to deal with the highest LOD
	1153	// we encountered in all the meshes queued
	1154	for (ushort lod = 0; lod < mLodSquaredDistances.size(); ++lod)
	1155	{
	1156	LODBucket* lodBucket =
	1157	new LODBucket(this, lod, mLodSquaredDistances[lod]);
	1158	mLodBucketList.push_back(lodBucket);
	1159	// Now iterate over the meshes and assign to LODs
	1160	// LOD bucket will pick the right LOD to use
	1161	QueuedSubMeshList::iterator qi, qiend;
	1162	qiend = mQueuedSubMeshes.end();
	1163	for (qi = mQueuedSubMeshes.begin(); qi != qiend; ++qi)
	1164	{
	1165	lodBucket->assign(*qi, lod);
	1166	}
	1167	// now build
	1168	lodBucket->build();
	1169	}
	1170
	1171
	1172	}
	1173
	1174	//--------------------------------------------------------------------------
	1175	void InstancedGeometry::BatchInstance::updateBoundingBox()
	1176	{
	1177
	1178	Vector3 *Positions = new Vector3[mInstancesMap.size()];
	1179
	1180	ObjectsMap::iterator objIt;
	1181	size_t k = 0;
	1182	for(objIt=mInstancesMap.begin();objIt!=mInstancesMap.end();objIt++)
	1183	{
	1184	Positions[k++] = objIt->second->getPosition();
	1185	}
	1186
	1187	LODIterator lodIterator = getLODIterator();
	1188	while (lodIterator.hasMoreElements())
	1189	{
	1190	LODBucket* lod = lodIterator.getNext();
	1191	LODBucket::MaterialIterator matIt = lod->getMaterialIterator();
	1192	while (matIt.hasMoreElements())
	1193	{
	1194	MaterialBucket*mat = matIt.getNext();
	1195	MaterialBucket::GeometryIterator geomIt = mat->getGeometryIterator();
	1196	while(geomIt.hasMoreElements())
	1197	{
	1198	// to generate the boundingBox
	1199	Real Xmin= Positions[0].x;
	1200	Real Ymin= Positions[0].y;
	1201	Real Zmin= Positions[0].z;
	1202
	1203	Real Xmax= Positions[0].x;
	1204	Real Ymax= Positions[0].y;
	1205	Real Zmax= Positions[0].z;
	1206
	1207	GeometryBucket*geom=geomIt.getNext();
	1208	for (size_t i = 0; i < mInstancesMap.size (); i++)
	1209	{
	1210	if(Positions[i].x<Xmin)
	1211	Xmin = Positions[i].x;
	1212	if(Positions[i].y<Ymin)
	1213	Ymin = Positions[i].y;
	1214	if(Positions[i].z<Zmin)
	1215	Zmin = Positions[i].z;
	1216	if(Positions[i].x>Xmax)
	1217	Xmax = Positions[i].x;
	1218	if(Positions[i].y>Ymax)
	1219	Ymax = Positions[i].y;
	1220	if(Positions[i].z>Zmax)
	1221	Zmax = Positions[i].z;
	1222	}
	1223	geom->setBoundingBox(AxisAlignedBox(Xmin,Ymin,Zmin,Xmax,Ymax,Zmax));
	1224	mAABB=AxisAlignedBox(
	1225	Vector3(Xmin,Ymin,Zmin) + geom->getAABB().getMinimum(),
	1226	Vector3(Xmax,Ymax,Zmax) + geom->getAABB().getMaximum());
	1227
	1228	}
	1229	}
	1230	}
	1231
	1232	delete [] Positions;
	1233	}
	1234
	1235
	1236
	1237
	1238
	1239
	1240
	1241
	1242	//--------------------------------------------------------------------------
	1243	void InstancedGeometry::BatchInstance::addInstancedObject(int index,InstancedObject* object)
	1244	{
	1245	mInstancesMap[index]=object;
	1246	}
	1247	//--------------------------------------------------------------------------
	1248	InstancedGeometry::InstancedObject* InstancedGeometry::BatchInstance::isInstancedObjectPresent(int index)
	1249	{
	1250	if (mInstancesMap.find(index)!=mInstancesMap.end())
	1251	return mInstancesMap[index];
	1252	else return NULL;
	1253	}
	1254	//--------------------------------------------------------------------------
	1255	InstancedGeometry::InstancedObject** InstancedGeometry::BatchInstance::getObjectsAsArray(unsigned short & size)
	1256	{
	1257	size = static_cast <unsigned short> (mInstancesMap.size());
	1258	ObjectsMap::iterator it;
	1259	InstancedObject** array=new InstancedObject*[size];
	1260	int i=0;
	1261	for(it=mInstancesMap.begin();it!=mInstancesMap.end();it++)
	1262	{
	1263	array[i]=it->second;
	1264	i++;
	1265	}
	1266	return array;
	1267	}
	1268	//--------------------------------------------------------------------------
	1269
	1270	const String& InstancedGeometry::BatchInstance::getMovableType(void) const
	1271	{
	1272	static String sType = "InstancedGeometry";
	1273	return sType;
	1274	}
	1275	//--------------------------------------------------------------------------
	1276	void InstancedGeometry::BatchInstance::_notifyCurrentCamera(Camera* cam)
	1277	{
	1278	// Calculate squared view depth
	1279	Vector3 diff = cam->getDerivedPosition() ;
	1280	Real squaredDepth = diff.squaredLength();
	1281
	1282	// Determine whether to still render
	1283	Real renderingDist = mParent->getRenderingDistance();
	1284	if (renderingDist > 0)
	1285	{
	1286	// Max distance to still render
	1287	Real maxDist = renderingDist + mBoundingRadius;
	1288	if (squaredDepth > Math::Sqr(maxDist))
	1289	{
	1290	mBeyondFarDistance = true;
	1291	return;
	1292	}
	1293	}
	1294
	1295	mBeyondFarDistance = false;
	1296
	1297	// Distance from the edge of the bounding sphere
	1298	mCamDistanceSquared = squaredDepth - mBoundingRadius * mBoundingRadius;
	1299	// Clamp to 0
	1300	mCamDistanceSquared = std::max(static_cast<Real>(0.0), mCamDistanceSquared);
	1301
	1302	// Determine active lod
	1303	mCurrentLod = static_cast<ushort>(mLodSquaredDistances.size() - 1);
	1304	assert (!mLodSquaredDistances.empty());
	1305	mCurrentLod = static_cast <unsigned short> (mLodSquaredDistances.size() - 1);
	1306
	1307	for (ushort i = 0; i < mLodSquaredDistances.size(); ++i)
	1308	{
	1309	if (mLodSquaredDistances[i] > mCamDistanceSquared)
	1310	{
	1311	mCurrentLod = i - 1;
	1312	break;
	1313	}
	1314	}
	1315
	1316	}
	1317	//--------------------------------------------------------------------------
	1318	const AxisAlignedBox& InstancedGeometry::BatchInstance::getBoundingBox(void) const
	1319	{
	1320	return mAABB;
	1321	}
	1322	//--------------------------------------------------------------------------
	1323	void InstancedGeometry::BatchInstance::setBoundingBox(AxisAlignedBox & box)
	1324	{
	1325	mAABB=box;
	1326	}
	1327	//--------------------------------------------------------------------------
	1328	Real InstancedGeometry::BatchInstance::getBoundingRadius(void) const
	1329	{
	1330	return mBoundingRadius;
	1331	}
	1332	//--------------------------------------------------------------------------
	1333	void InstancedGeometry::BatchInstance::_updateRenderQueue(RenderQueue* queue)
	1334	{
	1335	ObjectsMap::iterator it;
	1336	//we parse the Instanced Object map to update the animations.
	1337
	1338	for (it=mInstancesMap.begin();it!=mInstancesMap.end();++it)
	1339	{
	1340	it->second->updateAnimation();
	1341
	1342	}
	1343
	1344	mLodBucketList[mCurrentLod]->addRenderables(queue, mRenderQueueID,
	1345	mCamDistanceSquared);
	1346	}
	1347	//--------------------------------------------------------------------------
	1348	bool InstancedGeometry::BatchInstance::isVisible(void) const
	1349	{
	1350	return mVisible && !mBeyondFarDistance;
	1351	}
	1352	//--------------------------------------------------------------------------
	1353	InstancedGeometry::BatchInstance::LODIterator
	1354	InstancedGeometry::BatchInstance::getLODIterator(void)
	1355	{
	1356	return LODIterator(mLodBucketList.begin(), mLodBucketList.end());
	1357	}
	1358	//--------------------------------------------------------------------------
	1359	const LightList& InstancedGeometry::BatchInstance::getLights(void) const
	1360	{
	1361	return queryLights();
	1362	}
	1363	//--------------------------------------------------------------------------
	1364	void InstancedGeometry::BatchInstance::dump(std::ofstream& of) const
	1365	{
	1366	of << "BatchInstance " << mBatchInstanceID << std::endl;
	1367	of << "--------------------------" << std::endl;
	1368	of << "Local AABB: " << mAABB << std::endl;
	1369	of << "Bounding radius: " << mBoundingRadius << std::endl;
	1370	of << "Number of LODs: " << mLodBucketList.size() << std::endl;
	1371
	1372	for (LODBucketList::const_iterator i = mLodBucketList.begin();
	1373	i != mLodBucketList.end(); ++i)
	1374	{
	1375	(*i)->dump(of);
	1376	}
	1377	of << "--------------------------" << std::endl;
	1378	}
	1379	//--------------------------------------------------------------------------
	1380	//--------------------------------------------------------------------------
	1381	InstancedGeometry::LODBucket::LODBucket(BatchInstance* parent, unsigned short lod,
	1382	Real lodDist)
	1383	: mParent(parent), mLod(lod), mSquaredDistance(lodDist)
	1384	{
	1385	}
	1386	//--------------------------------------------------------------------------
	1387	InstancedGeometry::LODBucket::~LODBucket()
	1388	{
	1389	// delete
	1390	for (MaterialBucketMap::iterator i = mMaterialBucketMap.begin();
	1391	i != mMaterialBucketMap.end(); ++i)
	1392	{
	1393	delete i->second;
	1394	}
	1395	mMaterialBucketMap.clear();
	1396	for(QueuedGeometryList::iterator qi = mQueuedGeometryList.begin();
	1397	qi != mQueuedGeometryList.end(); ++qi)
	1398	{
	1399	delete *qi;
	1400	}
	1401	mQueuedGeometryList.clear();
	1402	// no need to delete queued meshes, these are managed in InstancedGeometry
	1403	}
	1404	//--------------------------------------------------------------------------
	1405	void InstancedGeometry::LODBucket::assign(QueuedSubMesh* qmesh, ushort atLod)
	1406	{
	1407	QueuedGeometry* q = new QueuedGeometry();
	1408	mQueuedGeometryList.push_back(q);
	1409	q->position = qmesh->position;
	1410	q->orientation = qmesh->orientation;
	1411	q->scale = qmesh->scale;
	1412	q->ID = qmesh->ID;
	1413	if (qmesh->geometryLodList->size() > atLod)
	1414	{
	1415	// This submesh has enough lods, use the right one
	1416	q->geometry = &(*qmesh->geometryLodList)[atLod];
	1417	}
	1418	else
	1419	{
	1420	// Not enough lods, use the lowest one we have
	1421	q->geometry =
	1422	&(*qmesh->geometryLodList)[qmesh->geometryLodList->size() - 1];
	1423	}
	1424	// Locate a material bucket
	1425	MaterialBucket* mbucket = 0;
	1426	MaterialBucketMap::iterator m =
	1427	mMaterialBucketMap.find(qmesh->materialName);
	1428	if (m != mMaterialBucketMap.end())
	1429	{
	1430	mbucket = m->second;
	1431	}
	1432	else
	1433	{
	1434	mbucket = new MaterialBucket(this, qmesh->materialName);
	1435	mMaterialBucketMap[qmesh->materialName] = mbucket;
	1436	}
	1437	mbucket->assign(q);
	1438	}
	1439	//--------------------------------------------------------------------------
	1440	void InstancedGeometry::LODBucket::build()
	1441	{
	1442	// Just pass this on to child buckets
	1443
	1444	for (MaterialBucketMap::iterator i = mMaterialBucketMap.begin();
	1445	i != mMaterialBucketMap.end(); ++i)
	1446	{
	1447	i->second->build();
	1448	}
	1449	}
	1450	//--------------------------------------------------------------------------
	1451	void InstancedGeometry::LODBucket::addRenderables(RenderQueue* queue,
	1452	uint8 group, Real camDistanceSquared)
	1453	{
	1454	// Just pass this on to child buckets
	1455	MaterialBucketMap::iterator i, iend;
	1456	iend = mMaterialBucketMap.end();
	1457	int j=0;
	1458	for (i = mMaterialBucketMap.begin(); i != iend; ++i)
	1459	{
	1460	i->second->addRenderables(queue, group, camDistanceSquared);
	1461	j++;
	1462	}
	1463	}
	1464	//--------------------------------------------------------------------------
	1465	InstancedGeometry::LODBucket::MaterialIterator
	1466	InstancedGeometry::LODBucket::getMaterialIterator(void)
	1467	{
	1468	return MaterialIterator(
	1469	mMaterialBucketMap.begin(), mMaterialBucketMap.end());
	1470	}
	1471	//--------------------------------------------------------------------------
	1472	void InstancedGeometry::LODBucket::dump(std::ofstream& of) const
	1473	{
	1474	of << "LOD Bucket " << mLod << std::endl;
	1475	of << "------------------" << std::endl;
	1476	of << "Distance: " << Math::Sqrt(mSquaredDistance) << std::endl;
	1477	of << "Number of Materials: " << mMaterialBucketMap.size() << std::endl;
	1478	for (MaterialBucketMap::const_iterator i = mMaterialBucketMap.begin();
	1479	i != mMaterialBucketMap.end(); ++i)
	1480	{
	1481	i->second->dump(of);
	1482	}
	1483	of << "------------------" << std::endl;
	1484
	1485	}
	1486	//--------------------------------------------------------------------------
	1487	//--------------------------------------------------------------------------
	1488	InstancedGeometry::MaterialBucket::MaterialBucket(LODBucket* parent,
	1489	const String& materialName)
	1490	: mParent(parent), mMaterialName(materialName),mLastIndex(0)
	1491	{
	1492	mMaterial = MaterialManager::getSingleton().getByName(mMaterialName);
	1493	}
	1494	//--------------------------------------------------------------------------
	1495	InstancedGeometry::MaterialBucket::~MaterialBucket()
	1496	{
	1497	// delete
	1498	for (GeometryBucketList::iterator i = mGeometryBucketList.begin();
	1499	i != mGeometryBucketList.end(); ++i)
	1500	{
	1501	delete *i;
	1502	}
	1503	mGeometryBucketList.clear();
	1504	// no need to delete queued meshes, these are managed in InstancedGeometry
	1505
	1506	}
	1507	//--------------------------------------------------------------------------
	1508
	1509	void InstancedGeometry::MaterialBucket::assign(QueuedGeometry* qgeom)
	1510	{
	1511	// Look up any current geometry
	1512	String formatString = getGeometryFormatString(qgeom->geometry);
	1513	CurrentGeometryMap::iterator gi = mCurrentGeometryMap.find(formatString);
	1514	bool newBucket = true;
	1515	if (gi != mCurrentGeometryMap.end())
	1516	{
	1517	// Found existing geometry, try to assign
	1518	newBucket = !gi->second->assign(qgeom);
	1519	// Note that this bucket will be replaced as the 'current'
	1520	// for this format string below since it's out of space
	1521	}
	1522	// Do we need to create a new one?
	1523	if (newBucket)
	1524	{
	1525	GeometryBucket* gbucket = new GeometryBucket(this, formatString,
	1526	qgeom->geometry->vertexData, qgeom->geometry->indexData);
	1527	// Add to main list
	1528	mGeometryBucketList.push_back(gbucket);
	1529	// Also index in 'current' list
	1530	mCurrentGeometryMap[formatString] = gbucket;
	1531	if (!gbucket->assign(qgeom))
	1532	{
	1533	OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
	1534	"Somehow we couldn't fit the requested geometry even in a "
	1535	"brand new GeometryBucket!! Must be a bug, please report.",
	1536	"InstancedGeometry::MaterialBucket::assign");
	1537	}
	1538	}
	1539	}
	1540	//--------------------------------------------------------------------------
	1541	void InstancedGeometry::MaterialBucket::build()
	1542	{
	1543	mMaterial = MaterialManager::getSingleton().getByName(mMaterialName);
	1544	if (mMaterial.isNull())
	1545	{
	1546	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	1547	"Material '" + mMaterialName + "' not found.",
	1548	"InstancedGeometry::MaterialBucket::build");
	1549	}
	1550	mMaterial->load();
	1551	// tell the geometry buckets to build
	1552
	1553	for (GeometryBucketList::iterator i = mGeometryBucketList.begin();
	1554	i != mGeometryBucketList.end(); ++i)
	1555	{
	1556	(*i)->build();
	1557	}
	1558	}
	1559	//--------------------------------------------------------------------------
	1560	void InstancedGeometry::MaterialBucket::addRenderables(RenderQueue* queue,
	1561	uint8 group, Real camDistanceSquared)
	1562	{
	1563
	1564	// Determine the current material technique
	1565	mTechnique = mMaterial->getTechnique(
	1566	mMaterial->getLodIndexSquaredDepth(camDistanceSquared));
	1567	GeometryBucketList::iterator i, iend;
	1568	iend = mGeometryBucketList.end();
	1569	int j=0;
	1570
	1571	for (i = mGeometryBucketList.begin(); i != iend; ++i)
	1572	{
	1573	queue->addRenderable(*i, group);
	1574	j++;
	1575	}
	1576
	1577	}
	1578	//--------------------------------------------------------------------------
	1579	String InstancedGeometry::MaterialBucket::getGeometryFormatString(
	1580	SubMeshLodGeometryLink* geom)
	1581	{
	1582	// Formulate an identifying string for the geometry format
	1583	// Must take into account the vertex declaration and the index type
	1584	// Format is (all lines separated by '\|'):
	1585	// Index type
	1586	// Vertex element (repeating)
	1587	// source
	1588	// semantic
	1589	// type
	1590	StringUtil::StrStreamType str;
	1591
	1592	str << geom->indexData->indexBuffer->getType() << "\|";
	1593	const VertexDeclaration::VertexElementList& elemList =
	1594	geom->vertexData->vertexDeclaration->getElements();
	1595	VertexDeclaration::VertexElementList::const_iterator ei, eiend;
	1596	eiend = elemList.end();
	1597	for (ei = elemList.begin(); ei != eiend; ++ei)
	1598	{
	1599	const VertexElement& elem = *ei;
	1600	str << elem.getSource() << "\|";
	1601	str << elem.getSource() << "\|";
	1602	str << elem.getSemantic() << "\|";
	1603	str << elem.getType() << "\|";
	1604	}
	1605
	1606	return str.str();
	1607
	1608	}
	1609	//--------------------------------------------------------------------------
	1610	InstancedGeometry::MaterialBucket::GeometryIterator
	1611	InstancedGeometry::MaterialBucket::getGeometryIterator(void)
	1612	{
	1613	return GeometryIterator(
	1614	mGeometryBucketList.begin(), mGeometryBucketList.end());
	1615	}
	1616	//--------------------------------------------------------------------------
	1617	void InstancedGeometry::MaterialBucket::dump(std::ofstream& of) const
	1618	{
	1619	of << "Material Bucket " << mMaterialName << std::endl;
	1620	of << "--------------------------------------------------" << std::endl;
	1621	of << "Geometry buckets: " << mGeometryBucketList.size() << std::endl;
	1622	for (GeometryBucketList::const_iterator i = mGeometryBucketList.begin();
	1623	i != mGeometryBucketList.end(); ++i)
	1624	{
	1625	(*i)->dump(of);
	1626	}
	1627	of << "--------------------------------------------------" << std::endl;
	1628
	1629	}
	1630	//--------------------------------------------------------------------------
	1631	//--------------------------------------------------------------------------
	1632	InstancedGeometry::GeometryBucket::GeometryBucket(MaterialBucket* parent,
	1633	const String& formatString, const VertexData* vData,
	1634	const IndexData* iData)
	1635	: SimpleRenderable(),
	1636	mParent(parent),
	1637	mFormatString(formatString),
	1638	mVertexData(0),
	1639	mIndexData(0)
	1640	{
	1641	mBatch=mParent->getParent()->getParent()->getParent();
	1642	if(!mBatch->getBaseSkeleton().isNull())
	1643	setCustomParameter(0,Vector4(mBatch->getBaseSkeleton()->getNumBones(),0,0,0));
	1644	//mRenderOperation=new RenderOperation();
	1645	// Clone the structure from the example
	1646	mVertexData = vData->clone(false);
	1647
	1648	mRenderOp.useIndexes = true;
	1649	mRenderOp.indexData = new IndexData();
	1650
	1651	mRenderOp.indexData->indexCount = 0;
	1652	mRenderOp.indexData->indexStart = 0;
	1653	mRenderOp.vertexData = new VertexData();
	1654	mRenderOp.vertexData->vertexCount = 0;
	1655
	1656	mRenderOp.vertexData->vertexDeclaration = vData->vertexDeclaration->clone();
	1657	mIndexType = iData->indexBuffer->getType();
	1658	// Derive the max vertices
	1659	if (mIndexType == HardwareIndexBuffer::IT_32BIT)
	1660	{
	1661	mMaxVertexIndex = 0xFFFFFFFF;
	1662	}
	1663	else
	1664	{
	1665	mMaxVertexIndex = 0xFFFF;
	1666	}
	1667
	1668
	1669	size_t offset=0, tcOffset=0;
	1670	unsigned short texCoordOffset=0;
	1671	unsigned short texCoordSource=0;
	1672	for(ushort i=0;i<mRenderOp.vertexData->vertexDeclaration->getElementCount();i++)
	1673	{
	1674
	1675	if(mRenderOp.vertexData->vertexDeclaration->getElement(i)->getSemantic() == VES_TEXTURE_COORDINATES)
	1676	{
	1677	texCoordOffset++;
	1678	texCoordSource=mRenderOp.vertexData->vertexDeclaration->getElement(i)->getSource();
	1679	tcOffset=mRenderOp.vertexData->vertexDeclaration->getElement(i)->getOffset()+VertexElement::getTypeSize(
	1680	mRenderOp.vertexData->vertexDeclaration->getElement(i)->getType());
	1681	}
	1682	offset+= VertexElement::getTypeSize(
	1683	mRenderOp.vertexData->vertexDeclaration->getElement(i)->getType());
	1684	}
	1685
	1686	mRenderOp.vertexData->vertexDeclaration->addElement(texCoordSource,tcOffset, VET_FLOAT1, VES_TEXTURE_COORDINATES,texCoordOffset);
	1687
	1688	mTexCoordIndex=texCoordOffset;
	1689
	1690
	1691
	1692	}
	1693	//--------------------------------------------------------------------------
	1694	InstancedGeometry::GeometryBucket::GeometryBucket(MaterialBucket* parent,
	1695	const String& formatString,GeometryBucket* bucket)
	1696	: SimpleRenderable(),
	1697	mParent(parent),
	1698	mFormatString(formatString),
	1699	mVertexData(0),
	1700	mIndexData(0)
	1701	{
	1702
	1703	mBatch=mParent->getParent()->getParent()->getParent();
	1704	if(!mBatch->getBaseSkeleton().isNull())
	1705	setCustomParameter(0,Vector4(mBatch->getBaseSkeleton()->getNumBones(),0,0,0));
	1706	bucket->getRenderOperation(mRenderOp);
	1707	mVertexData=mRenderOp.vertexData;
	1708	mIndexData=mRenderOp.indexData;
	1709	setBoundingBox(AxisAlignedBox(-10000,-10000,-10000,
	1710	10000,10000,10000));
	1711
	1712	}
	1713	//--------------------------------------------------------------------------
	1714	InstancedGeometry::GeometryBucket::~GeometryBucket()
	1715	{
	1716	}
	1717
	1718	//--------------------------------------------------------------------------
	1719	Real InstancedGeometry::GeometryBucket::getBoundingRadius(void) const
	1720	{
	1721	return 1;
	1722	}
	1723	//--------------------------------------------------------------------------
	1724	const MaterialPtr& InstancedGeometry::GeometryBucket::getMaterial(void) const
	1725	{
	1726	return mParent->getMaterial();
	1727	}
	1728	//--------------------------------------------------------------------------
	1729	Technique* InstancedGeometry::GeometryBucket::getTechnique(void) const
	1730	{
	1731	return mParent->getCurrentTechnique();
	1732	}
	1733	//--------------------------------------------------------------------------
	1734	void InstancedGeometry::GeometryBucket::getWorldTransforms(Matrix4* xform) const
	1735	{
	1736	// Should be the identity transform, but lets allow transformation of the
	1737	// nodes the BatchInstances are attached to for kicks
	1738	if(mBatch->getBaseSkeleton().isNull())
	1739	{
	1740	BatchInstance::ObjectsMap::iterator it,itbegin,itend,newit;
	1741	itbegin=mParent->getParent()->getParent()->getInstancesMap().begin();
	1742	itend=mParent->getParent()->getParent()->getInstancesMap().end();
	1743
	1744	for (it=itbegin;
	1745	it!=itend;
	1746	++it,++xform)
	1747	{
	1748
	1749	*xform = it->second->mTransformation;
	1750	}
	1751	}
	1752	else
	1753	{
	1754	BatchInstance::ObjectsMap::iterator it,itbegin,itend,newit;
	1755	itbegin=mParent->getParent()->getParent()->getInstancesMap().begin();
	1756	itend=mParent->getParent()->getParent()->getInstancesMap().end();
	1757
	1758	for (it=itbegin;
	1759	it!=itend;
	1760	++it)
	1761	{
	1762
	1763	for(int i=0;i<it->second->mNumBoneMatrices;++i,++xform)
	1764	{
	1765	*xform = it->second->mBoneWorldMatrices[i];
	1766	}
	1767	}
	1768
	1769	}
	1770
	1771	}
	1772	//--------------------------------------------------------------------------
	1773	unsigned short InstancedGeometry::GeometryBucket::getNumWorldTransforms(void) const
	1774	{
	1775	if(mBatch->getBaseSkeleton().isNull())
	1776	{
	1777	BatchInstance* batch=mParent->getParent()->getParent();
	1778	return static_cast<ushort>(batch->getInstancesMap().size());
	1779	}
	1780	else
	1781	{
	1782	BatchInstance* batch=mParent->getParent()->getParent();
	1783	return static_cast<ushort>(
	1784	mBatch->getBaseSkeleton()->getNumBones()*batch->getInstancesMap().size());
	1785	}
	1786	}
	1787	//--------------------------------------------------------------------------
	1788	const Quaternion& InstancedGeometry::GeometryBucket::getWorldOrientation(void) const
	1789	{
	1790	return Quaternion::IDENTITY;
	1791	}
	1792	//--------------------------------------------------------------------------
	1793	const Vector3& InstancedGeometry::GeometryBucket::getWorldPosition(void) const
	1794	{
	1795	return Vector3::ZERO;
	1796	}
	1797	//--------------------------------------------------------------------------
	1798	Real InstancedGeometry::GeometryBucket::getSquaredViewDepth(const Camera* cam) const
	1799	{
	1800	return mParent->getParent()->getSquaredDistance();
	1801	}
	1802	//--------------------------------------------------------------------------
	1803	const LightList& InstancedGeometry::GeometryBucket::getLights(void) const
	1804	{
	1805	return mParent->getParent()->getParent()->getLights();
	1806	}
	1807	//--------------------------------------------------------------------------
	1808	bool InstancedGeometry::GeometryBucket::getCastsShadows(void) const
	1809	{
	1810	return mParent->getParent()->getParent()->getCastShadows();
	1811	}
	1812	//--------------------------------------------------------------------------
	1813	bool InstancedGeometry::GeometryBucket::assign(QueuedGeometry* qgeom)
	1814	{
	1815	// Do we have enough space?
	1816	if (mRenderOp.vertexData->vertexCount + qgeom->geometry->vertexData->vertexCount
	1817	> mMaxVertexIndex)
	1818	{
	1819	return false;
	1820	}
	1821
	1822	mQueuedGeometry.push_back(qgeom);
	1823	mRenderOp.vertexData->vertexCount += qgeom->geometry->vertexData->vertexCount;
	1824	mRenderOp.indexData->indexCount += qgeom->geometry->indexData->indexCount;
	1825
	1826	return true;
	1827	}
	1828
	1829	//--------------------------------------------------------------------------
	1830	void InstancedGeometry::GeometryBucket::build()
	1831	{
	1832
	1833
	1834
	1835	// Ok, here's where we transfer the vertices and indexes to the shared
	1836	// buffers
	1837	// Shortcuts
	1838	VertexDeclaration* dcl = mRenderOp.vertexData->vertexDeclaration;
	1839	VertexBufferBinding* binds =mVertexData->vertexBufferBinding;
	1840
	1841	// create index buffer, and lock
	1842	mRenderOp.indexData->indexBuffer = HardwareBufferManager::getSingleton()
	1843	.createIndexBuffer(mIndexType, mRenderOp.indexData->indexCount,
	1844	HardwareBuffer::HBU_STATIC_WRITE_ONLY);
	1845	uint32* p32Dest = 0;
	1846	uint16* p16Dest = 0;
	1847
	1848	if (mIndexType == HardwareIndexBuffer::IT_32BIT)
	1849	{
	1850	p32Dest = static_cast<uint32*>(
	1851	mRenderOp.indexData->indexBuffer->lock(HardwareBuffer::HBL_DISCARD));
	1852	}
	1853	else
	1854	{
	1855	p16Dest = static_cast<uint16*>(
	1856	mRenderOp.indexData->indexBuffer->lock(HardwareBuffer::HBL_DISCARD));
	1857	}
	1858
	1859	// create all vertex buffers, and lock
	1860	ushort b;
	1861	//ushort posBufferIdx = dcl->findElementBySemantic(VES_POSITION)->getSource();
	1862
	1863	std::vector<uchar*> destBufferLocks;
	1864	std::vector<VertexDeclaration::VertexElementList> bufferElements;
	1865
	1866	for (b = 0; b < binds->getBufferCount(); ++b)
	1867	{
	1868
	1869	size_t vertexCount = mRenderOp.vertexData->vertexCount;
	1870
	1871	HardwareVertexBufferSharedPtr vbuf =
	1872	HardwareBufferManager::getSingleton().createVertexBuffer(
	1873	dcl->getVertexSize(b),
	1874	vertexCount,
	1875	HardwareBuffer::HBU_STATIC_WRITE_ONLY);
	1876	binds->setBinding(b, vbuf);
	1877	uchar* pLock = static_cast<uchar*>(
	1878	vbuf->lock(HardwareBuffer::HBL_DISCARD));
	1879	destBufferLocks.push_back(pLock);
	1880	// Pre-cache vertex elements per buffer
	1881	bufferElements.push_back(dcl->findElementsBySource(b));
	1882	mRenderOp.vertexData->vertexBufferBinding->setBinding(b,vbuf);
	1883	}
	1884
	1885
	1886	// Iterate over the geometry items
	1887	size_t indexOffset = 0;
	1888
	1889	QueuedGeometryList::iterator gi, giend;
	1890	giend = mQueuedGeometry.end();
	1891
	1892	// to generate the boundingBox
	1893	Real Xmin,Ymin,Zmin,Xmax,Ymax,Zmax;
	1894	Xmin=0;
	1895	Ymin=0;
	1896	Zmin=0;
	1897	Xmax=0;
	1898	Ymax=0;
	1899	Zmax=0;
	1900	QueuedGeometry* precGeom = *(mQueuedGeometry.begin());
	1901	int index=0;
	1902	if( mParent->getLastIndex()!=0)
	1903	index=mParent->getLastIndex()+1;
	1904
	1905	for (gi = mQueuedGeometry.begin(); gi != giend; ++gi)
	1906	{
	1907
	1908	QueuedGeometry* geom = *gi;
	1909	if(precGeom->ID!=geom->ID)
	1910	index++;
	1911
	1912	//create a new instanced object
	1913	InstancedObject* instancedObject = mParent->getParent()->getParent()->isInstancedObjectPresent(index);
	1914	if(instancedObject == NULL)
	1915	{
	1916	if(mBatch->getBaseSkeleton().isNull())
	1917	{
	1918	instancedObject=new InstancedObject(index);
	1919	}
	1920	else
	1921	{
	1922	instancedObject=new InstancedObject(index,mBatch->getBaseSkeletonInstance(),
	1923	mBatch->getBaseAnimationState());
	1924	}
	1925	mParent->getParent()->getParent()->addInstancedObject(index,instancedObject);
	1926
	1927	}
	1928	instancedObject->addBucketToList(this);
	1929
	1930
	1931
	1932	// Copy indexes across with offset
	1933	IndexData* srcIdxData = geom->geometry->indexData;
	1934	if (mIndexType == HardwareIndexBuffer::IT_32BIT)
	1935	{
	1936	// Lock source indexes
	1937	uint32* pSrc = static_cast<uint32*>(
	1938	srcIdxData->indexBuffer->lock(
	1939	srcIdxData->indexStart,
	1940	srcIdxData->indexCount * srcIdxData->indexBuffer->getIndexSize(),
	1941	HardwareBuffer::HBL_READ_ONLY));
	1942
	1943	copyIndexes(pSrc, p32Dest, srcIdxData->indexCount, indexOffset);
	1944	p32Dest += srcIdxData->indexCount;
	1945	srcIdxData->indexBuffer->unlock();
	1946	}
	1947	else
	1948	{
	1949
	1950	// Lock source indexes
	1951	uint16* pSrc = static_cast<uint16*>(
	1952	srcIdxData->indexBuffer->lock(
	1953	srcIdxData->indexStart,
	1954	srcIdxData->indexCount * srcIdxData->indexBuffer->getIndexSize(),
	1955	HardwareBuffer::HBL_READ_ONLY));
	1956
	1957	copyIndexes(pSrc, p16Dest, srcIdxData->indexCount, indexOffset);
	1958	p16Dest += srcIdxData->indexCount;
	1959	srcIdxData->indexBuffer->unlock();
	1960	}
	1961
	1962	// Now deal with vertex buffers
	1963	// we can rely on buffer counts / formats being the same
	1964	VertexData* srcVData = geom->geometry->vertexData;
	1965	VertexBufferBinding* srcBinds = srcVData->vertexBufferBinding;
	1966
	1967	for (b = 0; b < binds->getBufferCount(); ++b)
	1968	{
	1969
	1970	// lock source
	1971	HardwareVertexBufferSharedPtr srcBuf =
	1972	srcBinds->getBuffer(b);
	1973	uchar* pSrcBase = static_cast<uchar*>(
	1974	srcBuf->lock(HardwareBuffer::HBL_READ_ONLY));
	1975	// Get buffer lock pointer, we'll update this later
	1976	uchar* pDstBase = destBufferLocks[b];
	1977	size_t bufInc = srcBuf->getVertexSize();
	1978
	1979	// Iterate over vertices
	1980	float pSrcReal, pDstReal;
	1981	Vector3 tmp;
	1982
	1983
	1984
	1985	for (size_t v = 0; v < srcVData->vertexCount; ++v)
	1986	{
	1987	//to know if the current buffer is the one with the buffer or not
	1988	bool isTheBufferWithIndex=false;
	1989	// Iterate over vertex elements
	1990	VertexDeclaration::VertexElementList& elems =
	1991	bufferElements[b];
	1992	VertexDeclaration::VertexElementList::iterator ei;
	1993
	1994	for (ei = elems.begin(); ei != elems.end(); ++ei)
	1995	{
	1996	VertexElement& elem = *ei;
	1997	elem.baseVertexPointerToElement(pSrcBase, &pSrcReal);
	1998	elem.baseVertexPointerToElement(pDstBase, &pDstReal);
	1999	if(elem.getSemantic()==VES_TEXTURE_COORDINATES && elem.getIndex()==mTexCoordIndex)
	2000	{
	2001	isTheBufferWithIndex=true;
	2002	*pDstReal++=index;
	2003	}
	2004	else
	2005	{
	2006	switch (elem.getSemantic())
	2007	{
	2008	case VES_POSITION:
	2009	tmp.x = *pSrcReal++;
	2010	tmp.y = *pSrcReal++;
	2011	tmp.z = *pSrcReal++;
	2012	*pDstReal++ = tmp.x;
	2013	*pDstReal++ = tmp.y;
	2014	*pDstReal++ = tmp.z;
	2015	if(tmp.x<Xmin)
	2016	Xmin = tmp.x;
	2017	if(tmp.y<Ymin)
	2018	Ymin = tmp.y;
	2019	if(tmp.z<Zmin)
	2020	Zmin = tmp.z;
	2021	if(tmp.x>Xmax)
	2022	Xmax = tmp.x;
	2023	if(tmp.y>Ymax)
	2024	Ymax = tmp.y;
	2025	if(tmp.z>Zmax)
	2026	Zmax = tmp.z;
	2027	default:
	2028	// just raw copy
	2029	memcpy(pDstReal, pSrcReal,
	2030	VertexElement::getTypeSize(elem.getType()));
	2031	break;
	2032	};
	2033
	2034	}
	2035
	2036
	2037	}
	2038	if (isTheBufferWithIndex)
	2039	pDstBase += bufInc+4;
	2040	else
	2041	pDstBase += bufInc;
	2042	pSrcBase += bufInc;
	2043
	2044	}
	2045
	2046	// Update pointer
	2047	destBufferLocks[b] = pDstBase;
	2048	srcBuf->unlock();
	2049
	2050
	2051	}
	2052	indexOffset += geom->geometry->vertexData->vertexCount;
	2053
	2054
	2055	precGeom=geom;
	2056
	2057	}
	2058	mParent->setLastIndex(index);
	2059	// Unlock everything
	2060	mRenderOp.indexData->indexBuffer->unlock();
	2061	for (b = 0; b < binds->getBufferCount(); ++b)
	2062	{
	2063	binds->getBuffer(b)->unlock();
	2064	}
	2065
	2066	delete mVertexData;
	2067	delete mIndexData;
	2068
	2069	mVertexData=mRenderOp.vertexData;
	2070	mIndexData=mRenderOp.indexData;
	2071	mBatch->getRenderOperationVector().push_back(&mRenderOp);
	2072	setBoundingBox(AxisAlignedBox(Xmin,Ymin,Zmin,Xmax,Ymax,Zmax));
	2073	mAABB=AxisAlignedBox(Xmin,Ymin,Zmin,Xmax,Ymax,Zmax);
	2074
	2075	}
	2076	//--------------------------------------------------------------------------
	2077	void InstancedGeometry::GeometryBucket::dump(std::ofstream& of) const
	2078	{
	2079	of << "Geometry Bucket" << std::endl;
	2080	of << "---------------" << std::endl;
	2081	of << "Format string: " << mFormatString << std::endl;
	2082	of << "Geometry items: " << mQueuedGeometry.size() << std::endl;
	2083	of << "---------------" << std::endl;
	2084
	2085	}
	2086	//--------------------------------------------------------------------------
	2087
	2088	}
	2089

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

Download in other formats: