Context Navigation

OgreVertexIndexData.cpp @ 692

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

Rev	Line
[692]	1	/*
	2	-----------------------------------------------------------------------------
	3	This source file is part of OGRE
	4	(Object-oriented Graphics Rendering Engine)
	5	For the latest info, see http://www.ogre3d.org/
	6
	7	Copyright (c) 2000-2005 The OGRE Team
	8	Also see acknowledgements in Readme.html
	9
	10	This program is free software; you can redistribute it and/or modify it under
	11	the terms of the GNU Lesser General Public License as published by the Free Software
	12	Foundation; either version 2 of the License, or (at your option) any later
	13	version.
	14
	15	This program is distributed in the hope that it will be useful, but WITHOUT
	16	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
	17	FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
	18
	19	You should have received a copy of the GNU Lesser General Public License along with
	20	this program; if not, write to the Free Software Foundation, Inc., 59 Temple
	21	Place - Suite 330, Boston, MA 02111-1307, USA, or go to
	22	http://www.gnu.org/copyleft/lesser.txt.
	23	-----------------------------------------------------------------------------
	24	*/
	25	#include "OgreStableHeaders.h"
	26	#include "OgreVertexIndexData.h"
	27	#include "OgreHardwareBufferManager.h"
	28	#include "OgreHardwareVertexBuffer.h"
	29	#include "OgreHardwareIndexBuffer.h"
	30	#include "OgreVector3.h"
	31	#include "OgreAxisAlignedBox.h"
	32	#include "OgreRoot.h"
	33	#include "OgreRenderSystem.h"
	34	#include "OgreException.h"
	35
	36	namespace Ogre {
	37
	38	//-----------------------------------------------------------------------
	39	VertexData::VertexData()
	40	{
	41	vertexBufferBinding = HardwareBufferManager::getSingleton().
	42	createVertexBufferBinding();
	43	vertexDeclaration = HardwareBufferManager::getSingleton().
	44	createVertexDeclaration();
	45	vertexCount = 0;
	46	vertexStart = 0;
	47	hwAnimDataItemsUsed = 0;
	48
	49	}
	50	//-----------------------------------------------------------------------
	51	VertexData::~VertexData()
	52	{
	53	HardwareBufferManager::getSingleton().
	54	destroyVertexBufferBinding(vertexBufferBinding);
	55	HardwareBufferManager::getSingleton().destroyVertexDeclaration(vertexDeclaration);
	56
	57	}
	58	//-----------------------------------------------------------------------
	59	VertexData* VertexData::clone(bool copyData) const
	60	{
	61	VertexData* dest = new VertexData();
	62
	63	// Copy vertex buffers in turn
	64	const VertexBufferBinding::VertexBufferBindingMap bindings =
	65	this->vertexBufferBinding->getBindings();
	66	VertexBufferBinding::VertexBufferBindingMap::const_iterator vbi, vbend;
	67	vbend = bindings.end();
	68	for (vbi = bindings.begin(); vbi != vbend; ++vbi)
	69	{
	70	HardwareVertexBufferSharedPtr srcbuf = vbi->second;
	71	HardwareVertexBufferSharedPtr dstBuf;
	72	if (copyData)
	73	{
	74	// create new buffer with the same settings
	75	dstBuf =
	76	HardwareBufferManager::getSingleton().createVertexBuffer(
	77	srcbuf->getVertexSize(), srcbuf->getNumVertices(), srcbuf->getUsage(),
	78	srcbuf->hasShadowBuffer());
	79
	80	// copy data
	81	dstBuf->copyData(*srcbuf, 0, 0, srcbuf->getSizeInBytes(), true);
	82	}
	83	else
	84	{
	85	// don't copy, point at existing buffer
	86	dstBuf = srcbuf;
	87	}
	88
	89	// Copy binding
	90	dest->vertexBufferBinding->setBinding(vbi->first, dstBuf);
	91	}
	92
	93	// Basic vertex info
	94	dest->vertexStart = this->vertexStart;
	95	dest->vertexCount = this->vertexCount;
	96	// Copy elements
	97	const VertexDeclaration::VertexElementList elems =
	98	this->vertexDeclaration->getElements();
	99	VertexDeclaration::VertexElementList::const_iterator ei, eiend;
	100	eiend = elems.end();
	101	for (ei = elems.begin(); ei != eiend; ++ei)
	102	{
	103	dest->vertexDeclaration->addElement(
	104	ei->getSource(),
	105	ei->getOffset(),
	106	ei->getType(),
	107	ei->getSemantic(),
	108	ei->getIndex() );
	109	}
	110
	111	// Copy hardware shadow buffer if set up
	112	if (!hardwareShadowVolWBuffer.isNull())
	113	{
	114	dest->hardwareShadowVolWBuffer =
	115	HardwareBufferManager::getSingleton().createVertexBuffer(
	116	hardwareShadowVolWBuffer->getVertexSize(),
	117	hardwareShadowVolWBuffer->getNumVertices(),
	118	hardwareShadowVolWBuffer->getUsage(),
	119	hardwareShadowVolWBuffer->hasShadowBuffer());
	120
	121	// copy data
	122	dest->hardwareShadowVolWBuffer->copyData(
	123	*hardwareShadowVolWBuffer, 0, 0,
	124	hardwareShadowVolWBuffer->getSizeInBytes(), true);
	125	}
	126
	127	// copy anim data
	128	dest->hwAnimationDataList = hwAnimationDataList;
	129	dest->hwAnimDataItemsUsed = hwAnimDataItemsUsed;
	130
	131
	132	return dest;
	133	}
	134	//-----------------------------------------------------------------------
	135	void VertexData::prepareForShadowVolume(void)
	136	{
	137	/* NOTE
	138	I would dearly, dearly love to just use a 4D position buffer in order to
	139	store the extra 'w' value I need to differentiate between extruded and
	140	non-extruded sections of the buffer, so that vertex programs could use that.
	141	Hey, it works fine for GL. However, D3D9 in it's infinite stupidity, does not
	142	support 4d position vertices in the fixed-function pipeline. If you use them,
	143	you just see nothing. Since we can't know whether the application is going to use
	144	fixed function or vertex programs, we have to stick to 3d position vertices and
	145	store the 'w' in a separate 1D texture coordinate buffer, which is only used
	146	when rendering the shadow.
	147	*/
	148
	149	// Upfront, lets check whether we have vertex program capability
	150	RenderSystem* rend = Root::getSingleton().getRenderSystem();
	151	bool useVertexPrograms = false;
	152	if (rend && rend->getCapabilities()->hasCapability(RSC_VERTEX_PROGRAM))
	153	{
	154	useVertexPrograms = true;
	155	}
	156
	157
	158	// Look for a position element
	159	const VertexElement* posElem = vertexDeclaration->findElementBySemantic(VES_POSITION);
	160	if (posElem)
	161	{
	162	size_t v;
	163	unsigned posOldSource = posElem->getSource();
	164
	165	HardwareVertexBufferSharedPtr vbuf = vertexBufferBinding->getBuffer(posOldSource);
	166	bool wasSharedBuffer = false;
	167	// Are there other elements in the buffer except for the position?
	168	if (vbuf->getVertexSize() > posElem->getSize())
	169	{
	170	// We need to create another buffer to contain the remaining elements
	171	// Most drivers don't like gaps in the declaration, and in any case it's waste
	172	wasSharedBuffer = true;
	173	}
	174	HardwareVertexBufferSharedPtr newPosBuffer, newRemainderBuffer;
	175	if (wasSharedBuffer)
	176	{
	177	newRemainderBuffer = HardwareBufferManager::getSingleton().createVertexBuffer(
	178	vbuf->getVertexSize() - posElem->getSize(), vbuf->getNumVertices(), vbuf->getUsage(),
	179	vbuf->hasShadowBuffer());
	180	}
	181	// Allocate new position buffer, will be FLOAT3 and 2x the size
	182	size_t oldVertexCount = vbuf->getNumVertices();
	183	size_t newVertexCount = oldVertexCount * 2;
	184	newPosBuffer = HardwareBufferManager::getSingleton().createVertexBuffer(
	185	VertexElement::getTypeSize(VET_FLOAT3), newVertexCount, vbuf->getUsage(),
	186	vbuf->hasShadowBuffer());
	187
	188	// Iterate over the old buffer, copying the appropriate elements and initialising the rest
	189	float* pSrc;
	190	unsigned char pBaseSrc = static_cast<unsigned char>(
	191	vbuf->lock(HardwareBuffer::HBL_READ_ONLY));
	192	// Point first destination pointer at the start of the new position buffer,
	193	// the other one half way along
	194	float pDest = static_cast<float>(newPosBuffer->lock(HardwareBuffer::HBL_DISCARD));
	195	float* pDest2 = pDest + oldVertexCount * 3;
	196
	197	// Precalculate any dimensions of vertex areas outside the position
	198	size_t prePosVertexSize, postPosVertexSize, postPosVertexOffset;
	199	unsigned char *pBaseDestRem = 0;
	200	if (wasSharedBuffer)
	201	{
	202	pBaseDestRem = static_cast<unsigned char*>(
	203	newRemainderBuffer->lock(HardwareBuffer::HBL_DISCARD));
	204	prePosVertexSize = posElem->getOffset();
	205	postPosVertexOffset = prePosVertexSize + posElem->getSize();
	206	postPosVertexSize = vbuf->getVertexSize() - postPosVertexOffset;
	207	// the 2 separate bits together should be the same size as the remainder buffer vertex
	208	assert (newRemainderBuffer->getVertexSize() == prePosVertexSize + postPosVertexSize);
	209
	210	// Iterate over the vertices
	211	for (v = 0; v < oldVertexCount; ++v)
	212	{
	213	// Copy position, into both buffers
	214	posElem->baseVertexPointerToElement(pBaseSrc, &pSrc);
	215	pDest++ = pDest2++ = *pSrc++;
	216	pDest++ = pDest2++ = *pSrc++;
	217	pDest++ = pDest2++ = *pSrc++;
	218
	219	// now deal with any other elements
	220	// Basically we just memcpy the vertex excluding the position
	221	if (prePosVertexSize > 0)
	222	memcpy(pBaseDestRem, pBaseSrc, prePosVertexSize);
	223	if (postPosVertexSize > 0)
	224	memcpy(pBaseDestRem + prePosVertexSize,
	225	pBaseSrc + postPosVertexOffset, postPosVertexSize);
	226	pBaseDestRem += newRemainderBuffer->getVertexSize();
	227
	228	pBaseSrc += vbuf->getVertexSize();
	229
	230	} // next vertex
	231	}
	232	else
	233	{
	234	// Unshared buffer, can block copy the whole thing
	235	memcpy(pDest, pBaseSrc, vbuf->getSizeInBytes());
	236	memcpy(pDest2, pBaseSrc, vbuf->getSizeInBytes());
	237	}
	238
	239	vbuf->unlock();
	240	newPosBuffer->unlock();
	241	if (wasSharedBuffer)
	242	newRemainderBuffer->unlock();
	243
	244	// At this stage, he original vertex buffer is going to be destroyed
	245	// So we should force the deallocation of any temporary copies
	246	HardwareBufferManager::getSingleton()._forceReleaseBufferCopies(vbuf);
	247
	248	if (useVertexPrograms)
	249	{
	250	// Now it's time to set up the w buffer
	251	hardwareShadowVolWBuffer = HardwareBufferManager::getSingleton().createVertexBuffer(
	252	sizeof(float), newVertexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY, false);
	253	// Fill the first half with 1.0, second half with 0.0
	254	pDest = static_cast<float*>(
	255	hardwareShadowVolWBuffer->lock(HardwareBuffer::HBL_DISCARD));
	256	for (v = 0; v < oldVertexCount; ++v)
	257	{
	258	*pDest++ = 1.0f;
	259	}
	260	for (v = 0; v < oldVertexCount; ++v)
	261	{
	262	*pDest++ = 0.0f;
	263	}
	264	hardwareShadowVolWBuffer->unlock();
	265	}
	266
	267	unsigned short newPosBufferSource;
	268	if (wasSharedBuffer)
	269	{
	270	// Get the a new buffer binding index
	271	newPosBufferSource= vertexBufferBinding->getNextIndex();
	272	// Re-bind the old index to the remainder buffer
	273	vertexBufferBinding->setBinding(posOldSource, newRemainderBuffer);
	274	}
	275	else
	276	{
	277	// We can just re-use the same source idex for the new position buffer
	278	newPosBufferSource = posOldSource;
	279	}
	280	// Bind the new position buffer
	281	vertexBufferBinding->setBinding(newPosBufferSource, newPosBuffer);
	282
	283	// Now, alter the vertex declaration to change the position source
	284	// and the offsets of elements using the same buffer
	285	VertexDeclaration::VertexElementList::const_iterator elemi =
	286	vertexDeclaration->getElements().begin();
	287	VertexDeclaration::VertexElementList::const_iterator elemiend =
	288	vertexDeclaration->getElements().end();
	289	unsigned short idx;
	290	for(idx = 0; elemi != elemiend; ++elemi, ++idx)
	291	{
	292	if (&(*elemi) == posElem)
	293	{
	294	// Modify position to point at new position buffer
	295	vertexDeclaration->modifyElement(
	296	idx,
	297	newPosBufferSource, // new source buffer
	298	0, // no offset now
	299	VET_FLOAT3,
	300	VES_POSITION);
	301	}
	302	else if (wasSharedBuffer &&
	303	elemi->getSource() == posOldSource &&
	304	elemi->getOffset() > prePosVertexSize )
	305	{
	306	// This element came after position, remove the position's
	307	// size
	308	vertexDeclaration->modifyElement(
	309	idx,
	310	posOldSource, // same old source
	311	elemi->getOffset() - posElem->getSize(), // less offset now
	312	elemi->getType(),
	313	elemi->getSemantic(),
	314	elemi->getIndex());
	315
	316	}
	317
	318	}
	319
	320
	321	// Note that we don't change vertexCount, because the other buffer(s) are still the same
	322	// size after all
	323
	324
	325	}
	326	}
	327	//-----------------------------------------------------------------------
	328	void VertexData::reorganiseBuffers(VertexDeclaration* newDeclaration, const BufferUsageList& bufferUsages)
	329	{
	330	// Firstly, close up any gaps in the buffer sources which might have arisen
	331	newDeclaration->closeGapsInSource();
	332
	333	// Build up a list of both old and new elements in each buffer
	334	unsigned short buf = 0;
	335	std::vector<void*> oldBufferLocks;
	336	std::vector<size_t> oldBufferVertexSizes;
	337	std::vector<void*> newBufferLocks;
	338	std::vector<size_t> newBufferVertexSizes;
	339	VertexBufferBinding* newBinding =
	340	HardwareBufferManager::getSingleton().createVertexBufferBinding();
	341	const VertexBufferBinding::VertexBufferBindingMap& oldBindingMap = vertexBufferBinding->getBindings();
	342	VertexBufferBinding::VertexBufferBindingMap::const_iterator itBinding;
	343
	344	// Pre-allocate old buffer locks
	345	if (!oldBindingMap.empty())
	346	{
	347	size_t count = oldBindingMap.rbegin()->first + 1;
	348	oldBufferLocks.resize(count);
	349	oldBufferVertexSizes.resize(count);
	350	}
	351	// Lock all the old buffers for reading
	352	for (itBinding = oldBindingMap.begin(); itBinding != oldBindingMap.end(); ++itBinding)
	353	{
	354	assert(itBinding->second->getNumVertices() >= vertexCount);
	355
	356	oldBufferVertexSizes[itBinding->first] =
	357	itBinding->second->getVertexSize();
	358	oldBufferLocks[itBinding->first] =
	359	itBinding->second->lock(
	360	HardwareBuffer::HBL_READ_ONLY);
	361	}
	362
	363	// Create new buffers and lock all for writing
	364	buf = 0;
	365	while (!newDeclaration->findElementsBySource(buf).empty())
	366	{
	367	size_t vertexSize = newDeclaration->getVertexSize(buf);
	368
	369	HardwareVertexBufferSharedPtr vbuf =
	370	HardwareBufferManager::getSingleton().createVertexBuffer(
	371	vertexSize,
	372	vertexCount,
	373	bufferUsages[buf]);
	374	newBinding->setBinding(buf, vbuf);
	375
	376	newBufferVertexSizes.push_back(vertexSize);
	377	newBufferLocks.push_back(
	378	vbuf->lock(HardwareBuffer::HBL_DISCARD));
	379	buf++;
	380	}
	381
	382	// Map from new to old elements
	383	typedef std::map<const VertexElement, const VertexElement> NewToOldElementMap;
	384	NewToOldElementMap newToOldElementMap;
	385	const VertexDeclaration::VertexElementList& newElemList = newDeclaration->getElements();
	386	VertexDeclaration::VertexElementList::const_iterator ei, eiend;
	387	eiend = newElemList.end();
	388	for (ei = newElemList.begin(); ei != eiend; ++ei)
	389	{
	390	// Find corresponding old element
	391	const VertexElement* oldElem =
	392	vertexDeclaration->findElementBySemantic(
	393	(ei).getSemantic(), (ei).getIndex());
	394	if (!oldElem)
	395	{
	396	// Error, cannot create new elements with this method
	397	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	398	"Element not found in old vertex declaration",
	399	"VertexData::reorganiseBuffers");
	400	}
	401	newToOldElementMap[&(*ei)] = oldElem;
	402	}
	403	// Now iterate over the new buffers, pulling data out of the old ones
	404	// For each vertex
	405	for (size_t v = 0; v < vertexCount; ++v)
	406	{
	407	// For each (new) element
	408	for (ei = newElemList.begin(); ei != eiend; ++ei)
	409	{
	410	const VertexElement* newElem = &(*ei);
	411	NewToOldElementMap::iterator noi = newToOldElementMap.find(newElem);
	412	const VertexElement* oldElem = noi->second;
	413	unsigned short oldBufferNo = oldElem->getSource();
	414	unsigned short newBufferNo = newElem->getSource();
	415	void* pSrcBase = static_cast<void*>(
	416	static_cast<unsigned char*>(oldBufferLocks[oldBufferNo])
	417	+ v * oldBufferVertexSizes[oldBufferNo]);
	418	void* pDstBase = static_cast<void*>(
	419	static_cast<unsigned char*>(newBufferLocks[newBufferNo])
	420	+ v * newBufferVertexSizes[newBufferNo]);
	421	void pSrc, pDst;
	422	oldElem->baseVertexPointerToElement(pSrcBase, &pSrc);
	423	newElem->baseVertexPointerToElement(pDstBase, &pDst);
	424
	425	memcpy(pDst, pSrc, newElem->getSize());
	426
	427	}
	428	}
	429
	430	// Unlock all buffers
	431	for (itBinding = oldBindingMap.begin(); itBinding != oldBindingMap.end(); ++itBinding)
	432	{
	433	itBinding->second->unlock();
	434	}
	435	for (buf = 0; buf < newBinding->getBufferCount(); ++buf)
	436	{
	437	newBinding->getBuffer(buf)->unlock();
	438	}
	439
	440	// Delete old binding & declaration
	441	HardwareBufferManager::getSingleton().
	442	destroyVertexBufferBinding(vertexBufferBinding);
	443	HardwareBufferManager::getSingleton().destroyVertexDeclaration(vertexDeclaration);
	444
	445	// Assign new binding and declaration
	446	vertexDeclaration = newDeclaration;
	447	vertexBufferBinding = newBinding;
	448
	449	}
	450	//-----------------------------------------------------------------------
	451	void VertexData::reorganiseBuffers(VertexDeclaration* newDeclaration)
	452	{
	453	// Derive the buffer usages from looking at where the source has come
	454	// from
	455	BufferUsageList usages;
	456	for (unsigned short b = 0; b <= newDeclaration->getMaxSource(); ++b)
	457	{
	458	VertexDeclaration::VertexElementList destElems = newDeclaration->findElementsBySource(b);
	459	// Initialise with most restrictive version
	460	// (not really a usable option, but these flags will be removed)
	461	HardwareBuffer::Usage final = static_cast<HardwareBuffer::Usage>(
	462	HardwareBuffer::HBU_STATIC_WRITE_ONLY \| HardwareBuffer::HBU_DISCARDABLE);
	463	VertexDeclaration::VertexElementList::iterator v;
	464	for (v = destElems.begin(); v != destElems.end(); ++v)
	465	{
	466	VertexElement& destelem = *v;
	467	// get source
	468	const VertexElement* srcelem =
	469	vertexDeclaration->findElementBySemantic(
	470	destelem.getSemantic(), destelem.getIndex());
	471	// get buffer
	472	HardwareVertexBufferSharedPtr srcbuf =
	473	vertexBufferBinding->getBuffer(srcelem->getIndex());
	474	// improve flexibility only
	475	if (srcbuf->getUsage() & HardwareBuffer::HBU_DYNAMIC)
	476	{
	477	// remove static
	478	final = static_cast<HardwareBuffer::Usage>(
	479	final & ~HardwareBuffer::HBU_STATIC);
	480	// add dynamic
	481	final = static_cast<HardwareBuffer::Usage>(
	482	final \| HardwareBuffer::HBU_DYNAMIC);
	483	}
	484	if (!(srcbuf->getUsage() & HardwareBuffer::HBU_WRITE_ONLY))
	485	{
	486	// remove write only
	487	final = static_cast<HardwareBuffer::Usage>(
	488	final & ~HardwareBuffer::HBU_WRITE_ONLY);
	489	}
	490	if (!(srcbuf->getUsage() & HardwareBuffer::HBU_DISCARDABLE))
	491	{
	492	// remove discardable
	493	final = static_cast<HardwareBuffer::Usage>(
	494	final & ~HardwareBuffer::HBU_DISCARDABLE);
	495	}
	496
	497	}
	498	usages.push_back(final);
	499	}
	500	// Call specific method
	501	reorganiseBuffers(newDeclaration, usages);
	502
	503	}
	504	//-----------------------------------------------------------------------
	505	void VertexData::convertPackedColour(
	506	VertexElementType srcType, VertexElementType destType)
	507	{
	508	if (destType != VET_COLOUR_ABGR && destType != VET_COLOUR_ARGB)
	509	{
	510	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	511	"Invalid destType parameter", "VertexData::convertPackedColour");
	512	}
	513	if (srcType != VET_COLOUR_ABGR && srcType != VET_COLOUR_ARGB)
	514	{
	515	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	516	"Invalid srcType parameter", "VertexData::convertPackedColour");
	517	}
	518
	519	const VertexBufferBinding::VertexBufferBindingMap& bindMap =
	520	vertexBufferBinding->getBindings();
	521	VertexBufferBinding::VertexBufferBindingMap::const_iterator bindi;
	522	for (bindi = bindMap.begin(); bindi != bindMap.end(); ++bindi)
	523	{
	524	VertexDeclaration::VertexElementList elems =
	525	vertexDeclaration->findElementsBySource(bindi->first);
	526	bool conversionNeeded = false;
	527	VertexDeclaration::VertexElementList::iterator elemi;
	528	for (elemi = elems.begin(); elemi != elems.end(); ++elemi)
	529	{
	530	VertexElement& elem = *elemi;
	531	if (elem.getType() == VET_COLOUR \|\|
	532	((elem.getType() == VET_COLOUR_ABGR \|\| elem.getType() == VET_COLOUR_ARGB)
	533	&& elem.getType() != destType))
	534	{
	535	conversionNeeded = true;
	536	}
	537	}
	538
	539	if (conversionNeeded)
	540	{
	541	void* pBase = bindi->second->lock(HardwareBuffer::HBL_NORMAL);
	542
	543	for (size_t v = 0; v < bindi->second->getNumVertices(); ++v)
	544	{
	545
	546	for (elemi = elems.begin(); elemi != elems.end(); ++elemi)
	547	{
	548	VertexElement& elem = *elemi;
	549	VertexElementType currType = (elem.getType() == VET_COLOUR) ?
	550	srcType : elem.getType();
	551	if (elem.getType() == VET_COLOUR \|\|
	552	((elem.getType() == VET_COLOUR_ABGR \|\| elem.getType() == VET_COLOUR_ARGB)
	553	&& elem.getType() != destType))
	554	{
	555	uint32* pRGBA;
	556	elem.baseVertexPointerToElement(pBase, &pRGBA);
	557	VertexElement::convertColourValue(currType, destType, pRGBA);
	558	}
	559	}
	560	pBase = static_cast<void*>(
	561	static_cast<char*>(pBase) + bindi->second->getVertexSize());
	562	}
	563	bindi->second->unlock();
	564
	565	// Modify the elements to reflect the changed type
	566	const VertexDeclaration::VertexElementList& allelems =
	567	vertexDeclaration->getElements();
	568	VertexDeclaration::VertexElementList::const_iterator ai;
	569	unsigned short elemIndex = 0;
	570	for (ai = allelems.begin(); ai != allelems.end(); ++ai, ++elemIndex)
	571	{
	572	const VertexElement& elem = *ai;
	573	if (elem.getType() == VET_COLOUR \|\|
	574	((elem.getType() == VET_COLOUR_ABGR \|\| elem.getType() == VET_COLOUR_ARGB)
	575	&& elem.getType() != destType))
	576	{
	577	vertexDeclaration->modifyElement(elemIndex,
	578	elem.getSource(), elem.getOffset(), destType,
	579	elem.getSemantic(), elem.getIndex());
	580	}
	581	}
	582
	583	}
	584
	585
	586	} // each buffer
	587
	588
	589	}
	590	//-----------------------------------------------------------------------
	591	void VertexData::allocateHardwareAnimationElements(ushort count)
	592	{
	593	// Find first free texture coord set
	594	unsigned short texCoord = 0;
	595	const VertexDeclaration::VertexElementList& vel = vertexDeclaration->getElements();
	596	for (VertexDeclaration::VertexElementList::const_iterator i = vel.begin();
	597	i != vel.end(); ++i)
	598	{
	599	const VertexElement& el = *i;
	600	if (el.getSemantic() == VES_TEXTURE_COORDINATES)
	601	{
	602	++texCoord;
	603	}
	604	}
	605	assert(texCoord <= OGRE_MAX_TEXTURE_COORD_SETS);
	606
	607	// Increase to correct size
	608	for (ushort c = hwAnimationDataList.size(); c < count; ++c)
	609	{
	610	// Create a new 3D texture coordinate set
	611	HardwareAnimationData data;
	612	data.targetVertexElement = &(vertexDeclaration->addElement(
	613	vertexBufferBinding->getNextIndex(), 0, VET_FLOAT3, VES_TEXTURE_COORDINATES, texCoord++));
	614
	615	hwAnimationDataList.push_back(data);
	616	// Vertex buffer will not be bound yet, we expect this to be done by the
	617	// caller when it becomes appropriate (e.g. through a VertexAnimationTrack)
	618	}
	619	}
	620	//-----------------------------------------------------------------------
	621	//-----------------------------------------------------------------------
	622	IndexData::IndexData()
	623	{
	624	indexCount = 0;
	625	indexStart = 0;
	626
	627	}
	628	//-----------------------------------------------------------------------
	629	IndexData::~IndexData()
	630	{
	631	}
	632	//-----------------------------------------------------------------------
	633	IndexData* IndexData::clone(bool copyData) const
	634	{
	635	IndexData* dest = new IndexData();
	636	if (indexBuffer.get())
	637	{
	638	if (copyData)
	639	{
	640	dest->indexBuffer = HardwareBufferManager::getSingleton().
	641	createIndexBuffer(indexBuffer->getType(), indexBuffer->getNumIndexes(),
	642	indexBuffer->getUsage(), indexBuffer->hasShadowBuffer());
	643	dest->indexBuffer->copyData(*indexBuffer, 0, 0, indexBuffer->getSizeInBytes(), true);
	644	}
	645	else
	646	{
	647	dest->indexBuffer = indexBuffer;
	648	}
	649	}
	650	dest->indexCount = indexCount;
	651	dest->indexStart = indexStart;
	652	return dest;
	653	}
	654	//-----------------------------------------------------------------------
	655	//-----------------------------------------------------------------------
	656	// Local Utility class for vertex cache optimizer
	657	class Triangle
	658	{
	659	public:
	660	enum EdgeMatchType {
	661	AB, BC, CA, ANY, NONE
	662	};
	663
	664	union {
	665	struct {
	666	uint32 a, b, c;
	667	};
	668	uint32 val[3];
	669	};
	670
	671	inline Triangle()
	672	{
	673	}
	674
	675	inline Triangle( uint32 ta, uint32 tb, uint32 tc )
	676	: a( ta ), b( tb ), c( tc )
	677	{
	678	}
	679
	680	inline Triangle( uint32 t[3] )
	681	: a( t[0] ), b( t[1] ), c( t[2] )
	682	{
	683	}
	684
	685	inline Triangle( const Triangle& t )
	686	: a( t.a ), b( t.b ), c( t.c )
	687	{
	688	}
	689
	690	inline bool sharesEdge(const Triangle& t) const
	691	{
	692	return( a == t.a && b == t.c \|\|
	693	a == t.b && b == t.a \|\|
	694	a == t.c && b == t.b \|\|
	695	b == t.a && c == t.c \|\|
	696	b == t.b && c == t.a \|\|
	697	b == t.c && c == t.b \|\|
	698	c == t.a && a == t.c \|\|
	699	c == t.b && a == t.a \|\|
	700	c == t.c && a == t.b );
	701	}
	702
	703	inline bool sharesEdge(const uint32 ea, const uint32 eb, const Triangle& t) const
	704	{
	705	return( ea == t.a && eb == t.c \|\|
	706	ea == t.b && eb == t.a \|\|
	707	ea == t.c && eb == t.b );
	708	}
	709
	710	inline bool sharesEdge(const EdgeMatchType edge, const Triangle& t) const
	711	{
	712	if (edge == AB)
	713	return sharesEdge(a, b, t);
	714	else if (edge == BC)
	715	return sharesEdge(b, c, t);
	716	else if (edge == CA)
	717	return sharesEdge(c, a, t);
	718	else
	719	return (edge == ANY) == sharesEdge(t);
	720	}
	721
	722	inline EdgeMatchType endoSharedEdge(const Triangle& t) const
	723	{
	724	if (sharesEdge(a, b, t)) return AB;
	725	if (sharesEdge(b, c, t)) return BC;
	726	if (sharesEdge(c, a, t)) return CA;
	727	return NONE;
	728	}
	729
	730	inline EdgeMatchType exoSharedEdge(const Triangle& t) const
	731	{
	732	return t.endoSharedEdge(*this);
	733	}
	734
	735	inline void shiftClockwise()
	736	{
	737	uint32 t = a;
	738	a = c;
	739	c = b;
	740	b = t;
	741	}
	742
	743	inline void shiftCounterClockwise()
	744	{
	745	uint32 t = a;
	746	a = b;
	747	b = c;
	748	c = t;
	749	}
	750	};
	751	//-----------------------------------------------------------------------
	752	//-----------------------------------------------------------------------
	753	void IndexData::optimiseVertexCacheTriList(void)
	754	{
	755	if (indexBuffer->isLocked()) return;
	756
	757	void *buffer = indexBuffer->lock(HardwareBuffer::HBL_NORMAL);
	758
	759	Triangle* triangles;
	760	uint32 *dest;
	761
	762	size_t nIndexes = indexCount;
	763	size_t nTriangles = nIndexes / 3;
	764	size_t i, j;
	765	uint16 *source;
	766
	767	if (indexBuffer->getType() == HardwareIndexBuffer::IT_16BIT)
	768	{
	769	triangles = new Triangle[nTriangles];
	770	source = (uint16 *)buffer;
	771	dest = (uint32 *)triangles;
	772	for (i = 0; i < nIndexes; ++i) dest[i] = source[i];
	773	}
	774	else
	775	triangles = (Triangle*)buffer;
	776
	777	// sort triangles based on shared edges
	778	uint32 *destlist = new uint32[nTriangles];
	779	unsigned char *visited = new unsigned char[nTriangles];
	780
	781	for (i = 0; i < nTriangles; ++i) visited[i] = 0;
	782
	783	uint32 start = 0, ti = 0, destcount = 0;
	784
	785	bool found = false;
	786	for (i = 0; i < nTriangles; ++i)
	787	{
	788	if (found)
	789	found = false;
	790	else
	791	{
	792	while (visited[start++]);
	793	ti = start - 1;
	794	}
	795
	796	destlist[destcount++] = ti;
	797	visited[ti] = 1;
	798
	799	for (j = start; j < nTriangles; ++j)
	800	{
	801	if (visited[j]) continue;
	802
	803	if (triangles[ti].sharesEdge(triangles[j]))
	804	{
	805	found = true;
	806	ti = static_cast<uint32>(j);
	807	break;
	808	}
	809	}
	810	}
	811
	812	if (indexBuffer->getType() == HardwareIndexBuffer::IT_16BIT)
	813	{
	814	// reorder the indexbuffer
	815	j = 0;
	816	for (i = 0; i < nTriangles; ++i)
	817	{
	818	Triangle *t = &triangles[destlist[i]];
	819	source[j++] = t->a;
	820	source[j++] = t->b;
	821	source[j++] = t->c;
	822	}
	823	delete[] triangles;
	824	}
	825	else
	826	{
	827	uint32 *reflist = new uint32[nTriangles];
	828
	829	// fill the referencebuffer
	830	for (i = 0; i < nTriangles; ++i)
	831	reflist[destlist[i]] = static_cast<uint32>(i);
	832
	833	// reorder the indexbuffer
	834	for (i = 0; i < nTriangles; ++i)
	835	{
	836	j = destlist[i];
	837	if (i == j) continue; // do not move triangle
	838
	839	// swap triangles
	840
	841	Triangle t = triangles[i];
	842	triangles[i] = triangles[j];
	843	triangles[j] = t;
	844
	845	// change reference
	846	destlist[reflist[i]] = static_cast<uint32>(j);
	847	// destlist[i] = i; // not needed, it will not be used
	848	}
	849
	850	delete[] reflist;
	851	}
	852
	853	delete[] destlist;
	854	delete[] visited;
	855
	856	indexBuffer->unlock();
	857	}
	858	//-----------------------------------------------------------------------
	859	//-----------------------------------------------------------------------
	860	void VertexCacheProfiler::profile(const HardwareIndexBufferSharedPtr indexBuffer) {
	861	if (indexBuffer->isLocked()) return;
	862
	863	uint16 shortbuffer = (uint16 )indexBuffer->lock(HardwareBuffer::HBL_READ_ONLY);
	864
	865	if (indexBuffer->getType() == HardwareIndexBuffer::IT_16BIT)
	866	for (unsigned int i = 0; i < indexBuffer->getNumIndexes(); ++i)
	867	inCache(shortbuffer[i]);
	868	else
	869	{
	870	uint32 buffer = (uint32 )shortbuffer;
	871	for (unsigned int i = 0; i < indexBuffer->getNumIndexes(); ++i)
	872	inCache(buffer[i]);
	873	}
	874
	875	indexBuffer->unlock();
	876	}
	877
	878	//-----------------------------------------------------------------------
	879	bool VertexCacheProfiler::inCache(unsigned int index)
	880	{
	881	for (unsigned int i = 0; i < buffersize; ++i)
	882	{
	883	if (index == cache[i])
	884	{
	885	hit++;
	886	return true;
	887	}
	888	}
	889
	890	miss++;
	891	cache[tail++] = index;
	892	tail %= size;
	893
	894	if (buffersize < size) buffersize++;
	895
	896	return false;
	897	}
	898
	899
	900	}

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

Context Navigation

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

Download in other formats: