Context Navigation

OgreBillboardChain.cpp @ 692

Revision 692, 22.4 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
	26	// Thanks to Vincent Cantin (karmaGfa) for the original implementation of this
	27	// class, although it has now been mostly rewritten
	28
	29	#include "OgreStableHeaders.h"
	30	#include "OgreBillboardChain.h"
	31
	32	#include "OgreSimpleRenderable.h"
	33	#include "OgreHardwareBufferManager.h"
	34	#include "OgreNode.h"
	35	#include "OgreCamera.h"
	36	#include "OgreRoot.h"
	37	#include "OgreMaterialManager.h"
	38	#include "OgreLogManager.h"
	39	#include "OgreStringConverter.h"
	40
	41	namespace Ogre {
	42	const size_t BillboardChain::SEGMENT_EMPTY = 0xffffffff;
	43	//-----------------------------------------------------------------------
	44	BillboardChain::Element::Element()
	45	{
	46	}
	47	//-----------------------------------------------------------------------
	48	BillboardChain::Element::Element(Vector3 _position,
	49	Real _width,
	50	Real _texCoord,
	51	ColourValue _colour) :
	52	position(_position),
	53	width(_width),
	54	texCoord(_texCoord),
	55	colour(_colour)
	56	{
	57	}
	58	//-----------------------------------------------------------------------
	59	BillboardChain::BillboardChain(const String& name, size_t maxElements,
	60	size_t numberOfChains, bool useTextureCoords, bool useColours, bool dynamic)
	61	:MovableObject(name),
	62	mMaxElementsPerChain(maxElements),
	63	mChainCount(numberOfChains),
	64	mUseTexCoords(useTextureCoords),
	65	mUseVertexColour(useColours),
	66	mDynamic(dynamic),
	67	mVertexDeclDirty(true),
	68	mBuffersNeedRecreating(true),
	69	mBoundsDirty(true),
	70	mIndexContentDirty(true),
	71	mRadius(0.0f),
	72	mTexCoordDir(TCD_U)
	73	{
	74	mVertexData = new VertexData();
	75	mIndexData = new IndexData();
	76
	77	mOtherTexCoordRange[0] = 0.0f;
	78	mOtherTexCoordRange[1] = 1.0f;
	79
	80	setupChainContainers();
	81
	82	mVertexData->vertexStart = 0;
	83	// index data set up later
	84	// set basic white material
	85	this->setMaterialName("BaseWhiteNoLighting");
	86
	87	}
	88	//-----------------------------------------------------------------------
	89	BillboardChain::~BillboardChain()
	90	{
	91	delete mVertexData;
	92	delete mIndexData;
	93	}
	94	//-----------------------------------------------------------------------
	95	void BillboardChain::setupChainContainers(void)
	96	{
	97	// Allocate enough space for everything
	98	mChainElementList.resize(mChainCount * mMaxElementsPerChain);
	99	mVertexData->vertexCount = mChainElementList.size() * 2;
	100
	101	// Configure chains
	102	mChainSegmentList.resize(mChainCount);
	103	for (size_t i = 0; i < mChainCount; ++i)
	104	{
	105	ChainSegment& seg = mChainSegmentList[i];
	106	seg.start = i * mMaxElementsPerChain;
	107	seg.tail = seg.head = SEGMENT_EMPTY;
	108
	109	}
	110
	111
	112	}
	113	//-----------------------------------------------------------------------
	114	void BillboardChain::setupVertexDeclaration(void)
	115	{
	116	if (mVertexDeclDirty)
	117	{
	118	VertexDeclaration* decl = mVertexData->vertexDeclaration;
	119	decl->removeAllElements();
	120
	121	size_t offset = 0;
	122	// Add a description for the buffer of the positions of the vertices
	123	decl->addElement(0, offset, VET_FLOAT3, VES_POSITION);
	124	offset += VertexElement::getTypeSize(VET_FLOAT3);
	125
	126	if (mUseVertexColour)
	127	{
	128	decl->addElement(0, offset, VET_COLOUR, VES_DIFFUSE);
	129	offset += VertexElement::getTypeSize(VET_COLOUR);
	130	}
	131
	132	if (mUseTexCoords)
	133	{
	134	decl->addElement(0, offset, VET_FLOAT2, VES_TEXTURE_COORDINATES);
	135	offset += VertexElement::getTypeSize(VET_FLOAT2);
	136	}
	137
	138	if (!mUseTexCoords && !mUseVertexColour)
	139	{
	140	LogManager::getSingleton().logMessage(
	141	"Error - BillboardChain '" + mName + "' is using neither "
	142	"texture coordinates or vertex colours; it will not be "
	143	"visible on some rendering APIs so you should change this "
	144	"so you use one or the other.");
	145	}
	146	mVertexDeclDirty = false;
	147	}
	148	}
	149	//-----------------------------------------------------------------------
	150	void BillboardChain::setupBuffers(void)
	151	{
	152	setupVertexDeclaration();
	153	if (mBuffersNeedRecreating)
	154	{
	155	// Create the vertex buffer (always dynamic due to the camera adjust)
	156	HardwareVertexBufferSharedPtr pBuffer =
	157	HardwareBufferManager::getSingleton().createVertexBuffer(
	158	mVertexData->vertexDeclaration->getVertexSize(0),
	159	mVertexData->vertexCount,
	160	HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE);
	161
	162	// (re)Bind the buffer
	163	// Any existing buffer will lose its reference count and be destroyed
	164	mVertexData->vertexBufferBinding->setBinding(0, pBuffer);
	165
	166	mIndexData->indexBuffer =
	167	HardwareBufferManager::getSingleton().createIndexBuffer(
	168	HardwareIndexBuffer::IT_16BIT,
	169	mChainCount * mMaxElementsPerChain * 6, // max we can use
	170	mDynamic? HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY : HardwareBuffer::HBU_STATIC_WRITE_ONLY);
	171	// NB we don't set the indexCount on IndexData here since we will
	172	// probably use less than the maximum number of indices
	173
	174	mBuffersNeedRecreating = false;
	175	}
	176	}
	177	//-----------------------------------------------------------------------
	178	void BillboardChain::setMaxChainElements(size_t maxElements)
	179	{
	180	mMaxElementsPerChain = maxElements;
	181	setupChainContainers();
	182	}
	183	//-----------------------------------------------------------------------
	184	void BillboardChain::setNumberOfChains(size_t numChains)
	185	{
	186	mChainCount = numChains;
	187	setupChainContainers();
	188	}
	189	//-----------------------------------------------------------------------
	190	void BillboardChain::setUseTextureCoords(bool use)
	191	{
	192	mUseTexCoords = use;
	193	mVertexDeclDirty = mBuffersNeedRecreating = true;
	194	}
	195	//-----------------------------------------------------------------------
	196	void BillboardChain::setTextureCoordDirection(BillboardChain::TexCoordDirection dir)
	197	{
	198	mTexCoordDir = dir;
	199	}
	200	//-----------------------------------------------------------------------
	201	void BillboardChain::setOtherTextureCoordRange(Real start, Real end)
	202	{
	203	mOtherTexCoordRange[0] = start;
	204	mOtherTexCoordRange[1] = end;
	205	}
	206	//-----------------------------------------------------------------------
	207	void BillboardChain::setUseVertexColours(bool use)
	208	{
	209	mUseVertexColour = use;
	210	mVertexDeclDirty = mBuffersNeedRecreating = true;
	211	}
	212	//-----------------------------------------------------------------------
	213	void BillboardChain::setDynamic(bool dyn)
	214	{
	215	mDynamic = dyn;
	216	mBuffersNeedRecreating = mIndexContentDirty = true;
	217	}
	218	//-----------------------------------------------------------------------
	219	void BillboardChain::addChainElement(size_t chainIndex,
	220	const BillboardChain::Element& dtls)
	221	{
	222
	223	if (chainIndex >= mChainCount)
	224	{
	225	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	226	"chainIndex out of bounds",
	227	"BillboardChain::addChainElement");
	228	}
	229	ChainSegment& seg = mChainSegmentList[chainIndex];
	230	if (seg.head == SEGMENT_EMPTY)
	231	{
	232	// Tail starts at end, head grows backwards
	233	seg.tail = mMaxElementsPerChain - 1;
	234	seg.head = seg.tail;
	235	mIndexContentDirty = true;
	236	}
	237	else
	238	{
	239	if (seg.head == 0)
	240	{
	241	// Wrap backwards
	242	seg.head = mMaxElementsPerChain - 1;
	243	}
	244	else
	245	{
	246	// Just step backward
	247	--seg.head;
	248	}
	249	// Run out of elements?
	250	if (seg.head == seg.tail)
	251	{
	252	// Move tail backwards too, losing the end of the segment and re-using
	253	// it in the head
	254	if (seg.tail == 0)
	255	seg.tail = mMaxElementsPerChain - 1;
	256	else
	257	--seg.tail;
	258	}
	259	}
	260
	261	// Set the details
	262	mChainElementList[seg.start + seg.head] = dtls;
	263
	264	mIndexContentDirty = true;
	265	mBoundsDirty = true;
	266	// tell parent node to update bounds
	267	if (mParentNode)
	268	mParentNode->needUpdate();
	269
	270	}
	271	//-----------------------------------------------------------------------
	272	void BillboardChain::removeChainElement(size_t chainIndex)
	273	{
	274	if (chainIndex >= mChainCount)
	275	{
	276	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	277	"chainIndex out of bounds",
	278	"BillboardChain::removeChainElement");
	279	}
	280	ChainSegment& seg = mChainSegmentList[chainIndex];
	281	if (seg.head == SEGMENT_EMPTY)
	282	return; // do nothing, nothing to remove
	283
	284
	285	if (seg.tail == seg.head)
	286	{
	287	// last item
	288	seg.head = seg.tail = SEGMENT_EMPTY;
	289	}
	290	else if (seg.tail == 0)
	291	{
	292	seg.tail = mMaxElementsPerChain - 1;
	293	}
	294	else
	295	{
	296	--seg.tail;
	297	}
	298
	299	// we removed an entry so indexes need updating
	300	mIndexContentDirty = true;
	301	mBoundsDirty = true;
	302	// tell parent node to update bounds
	303	if (mParentNode)
	304	mParentNode->needUpdate();
	305
	306	}
	307	//-----------------------------------------------------------------------
	308	void BillboardChain::updateChainElement(size_t chainIndex, size_t elementIndex,
	309	const BillboardChain::Element& dtls)
	310	{
	311	if (chainIndex >= mChainCount)
	312	{
	313	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	314	"chainIndex out of bounds",
	315	"BillboardChain::updateChainElement");
	316	}
	317	ChainSegment& seg = mChainSegmentList[chainIndex];
	318	if (seg.head == SEGMENT_EMPTY)
	319	{
	320	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	321	"Chain segment is empty",
	322	"BillboardChain::updateChainElement");
	323	}
	324
	325	size_t idx = seg.head + elementIndex;
	326	// adjust for the edge and start
	327	idx = (idx % mMaxElementsPerChain) + seg.start;
	328
	329	mChainElementList[idx] = dtls;
	330
	331	mBoundsDirty = true;
	332	// tell parent node to update bounds
	333	if (mParentNode)
	334	mParentNode->needUpdate();
	335
	336
	337	}
	338	//-----------------------------------------------------------------------
	339	const BillboardChain::Element&
	340	BillboardChain::getChainElement(size_t chainIndex, size_t elementIndex) const
	341	{
	342
	343	if (chainIndex >= mChainCount)
	344	{
	345	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	346	"chainIndex out of bounds",
	347	"BillboardChain::updateChainElement");
	348	}
	349	const ChainSegment& seg = mChainSegmentList[chainIndex];
	350
	351	size_t idx = seg.head + elementIndex;
	352	// adjust for the edge and start
	353	idx = (idx % mMaxElementsPerChain) + seg.start;
	354
	355	return mChainElementList[idx];
	356	}
	357	//-----------------------------------------------------------------------
	358	void BillboardChain::updateBoundingBox(void) const
	359	{
	360	if (mBoundsDirty)
	361	{
	362	mAABB.setNull();
	363	Vector3 widthVector;
	364	for (ChainSegmentList::const_iterator segi = mChainSegmentList.begin();
	365	segi != mChainSegmentList.end(); ++segi)
	366	{
	367	const ChainSegment& seg = *segi;
	368
	369	if (seg.head != SEGMENT_EMPTY)
	370	{
	371
	372	for(size_t e = seg.head; ; ++e) // until break
	373	{
	374	// Wrap forwards
	375	if (e == mMaxElementsPerChain)
	376	e = 0;
	377
	378	const Element& elem = mChainElementList[seg.start + e];
	379
	380	widthVector.x = widthVector.y = widthVector.z = elem.width;
	381	mAABB.merge(elem.position - widthVector);
	382	mAABB.merge(elem.position + widthVector);
	383
	384	if (e == seg.tail)
	385	break;
	386
	387	}
	388	}
	389
	390	}
	391
	392	// Set the current radius
	393	if (mAABB.isNull())
	394	{
	395	mRadius = 0.0f;
	396	}
	397	else
	398	{
	399	mRadius = Math::Sqrt(
	400	std::max(mAABB.getMinimum().squaredLength(),
	401	mAABB.getMaximum().squaredLength()));
	402	}
	403
	404	mBoundsDirty = false;
	405	}
	406	}
	407	//-----------------------------------------------------------------------
	408	void BillboardChain::updateVertexBuffer(Camera* cam)
	409	{
	410	setupBuffers();
	411	HardwareVertexBufferSharedPtr pBuffer =
	412	mVertexData->vertexBufferBinding->getBuffer(0);
	413	void* pBufferStart = pBuffer->lock(HardwareBuffer::HBL_DISCARD);
	414
	415	const Vector3& camPos = cam->getDerivedPosition();
	416	Vector3 eyePos = mParentNode->_getDerivedOrientation().Inverse() *
	417	(camPos - mParentNode->_getDerivedPosition()) / mParentNode->_getDerivedScale();
	418
	419	Vector3 chainTangent;
	420	for (ChainSegmentList::iterator segi = mChainSegmentList.begin();
	421	segi != mChainSegmentList.end(); ++segi)
	422	{
	423	ChainSegment& seg = *segi;
	424
	425	// Skip 0 or 1 element segment counts
	426	if (seg.head != SEGMENT_EMPTY && seg.head != seg.tail)
	427	{
	428	size_t laste = seg.head;
	429	for (size_t e = seg.head; ; ++e) // until break
	430	{
	431	// Wrap forwards
	432	if (e == mMaxElementsPerChain)
	433	e = 0;
	434
	435	Element& elem = mChainElementList[e + seg.start];
	436	uint16 baseIdx = (e + seg.start) * 2;
	437
	438	// Determine base pointer to vertex #1
	439	void* pBase = static_cast<void*>(
	440	static_cast<char*>(pBufferStart) +
	441	pBuffer->getVertexSize() * baseIdx);
	442
	443	// Get index of next item
	444	size_t nexte = e + 1;
	445	if (nexte == mMaxElementsPerChain)
	446	nexte = 0;
	447
	448	if (e == seg.head)
	449	{
	450	// No laste, use next item
	451	chainTangent = mChainElementList[nexte + seg.start].position - elem.position;
	452	}
	453	else if (e == seg.tail)
	454	{
	455	// No nexte, use only last item
	456	chainTangent = elem.position - mChainElementList[laste + seg.start].position;
	457	}
	458	else
	459	{
	460	// A mid position, use tangent across both prev and next
	461	chainTangent = mChainElementList[nexte + seg.start].position - mChainElementList[laste + seg.start].position;
	462
	463	}
	464
	465	Vector3 vP1ToEye = eyePos - elem.position;
	466	Vector3 vPerpendicular = chainTangent.crossProduct(vP1ToEye);
	467	vPerpendicular.normalise();
	468	vPerpendicular = (elem.width 0.5);
	469
	470	Vector3 pos0 = elem.position - vPerpendicular;
	471	Vector3 pos1 = elem.position + vPerpendicular;
	472
	473	float* pFloat = static_cast<float*>(pBase);
	474	// pos1
	475	*pFloat++ = pos0.x;
	476	*pFloat++ = pos0.y;
	477	*pFloat++ = pos0.z;
	478
	479	pBase = static_cast<void*>(pFloat);
	480
	481	if (mUseVertexColour)
	482	{
	483	RGBA* pCol = static_cast<RGBA*>(pBase);
	484	Root::getSingleton().convertColourValue(elem.colour, pCol);
	485	pCol++;
	486	pBase = static_cast<void*>(pCol);
	487	}
	488
	489	if (mUseTexCoords)
	490	{
	491	pFloat = static_cast<float*>(pBase);
	492	if (mTexCoordDir == TCD_U)
	493	{
	494	*pFloat++ = elem.texCoord;
	495	*pFloat++ = mOtherTexCoordRange[0];
	496	}
	497	else
	498	{
	499	*pFloat++ = mOtherTexCoordRange[0];
	500	*pFloat++ = elem.texCoord;
	501	}
	502	pBase = static_cast<void*>(pFloat);
	503	}
	504
	505	// pos2
	506	pFloat = static_cast<float*>(pBase);
	507	*pFloat++ = pos1.x;
	508	*pFloat++ = pos1.y;
	509	*pFloat++ = pos1.z;
	510	pBase = static_cast<void*>(pFloat);
	511
	512	if (mUseVertexColour)
	513	{
	514	RGBA* pCol = static_cast<RGBA*>(pBase);
	515	Root::getSingleton().convertColourValue(elem.colour, pCol);
	516	pCol++;
	517	pBase = static_cast<void*>(pCol);
	518	}
	519
	520	if (mUseTexCoords)
	521	{
	522	pFloat = static_cast<float*>(pBase);
	523	if (mTexCoordDir == TCD_U)
	524	{
	525	*pFloat++ = elem.texCoord;
	526	*pFloat++ = mOtherTexCoordRange[1];
	527	}
	528	else
	529	{
	530	*pFloat++ = mOtherTexCoordRange[1];
	531	*pFloat++ = elem.texCoord;
	532	}
	533	pBase = static_cast<void*>(pFloat);
	534	}
	535
	536	if (e == seg.tail)
	537	break; // last one
	538
	539	laste = e;
	540
	541	} // element
	542	} // segment valid?
	543
	544	} // each segment
	545
	546
	547
	548	pBuffer->unlock();
	549
	550
	551	}
	552	//-----------------------------------------------------------------------
	553	void BillboardChain::updateIndexBuffer(void)
	554	{
	555
	556	setupBuffers();
	557	if (mIndexContentDirty)
	558	{
	559
	560	uint16* pShort = static_cast<uint16*>(
	561	mIndexData->indexBuffer->lock(HardwareBuffer::HBL_DISCARD));
	562	mIndexData->indexCount = 0;
	563	// indexes
	564	for (ChainSegmentList::iterator segi = mChainSegmentList.begin();
	565	segi != mChainSegmentList.end(); ++segi)
	566	{
	567	ChainSegment& seg = *segi;
	568
	569	// Skip 0 or 1 element segment counts
	570	if (seg.head != SEGMENT_EMPTY && seg.head != seg.tail)
	571	{
	572	// Start from head + 1 since it's only useful in pairs
	573	size_t laste = seg.head;
	574	while(1) // until break
	575	{
	576	size_t e = laste + 1;
	577	// Wrap forwards
	578	if (e == mMaxElementsPerChain)
	579	e = 0;
	580	// indexes of this element are (e * 2) and (e * 2) + 1
	581	// indexes of the last element are the same, -2
	582	uint16 baseIdx = (e + seg.start) * 2;
	583	uint16 lastBaseIdx = (laste + seg.start) * 2;
	584	*pShort++ = lastBaseIdx;
	585	*pShort++ = lastBaseIdx + 1;
	586	*pShort++ = baseIdx;
	587	*pShort++ = lastBaseIdx + 1;
	588	*pShort++ = baseIdx + 1;
	589	*pShort++ = baseIdx;
	590
	591	mIndexData->indexCount += 6;
	592
	593
	594	if (e == seg.tail)
	595	break; // last one
	596
	597	laste = e;
	598
	599	}
	600	}
	601
	602	}
	603	mIndexData->indexBuffer->unlock();
	604
	605	mIndexContentDirty = false;
	606	}
	607
	608	}
	609	//-----------------------------------------------------------------------
	610	void BillboardChain::_notifyCurrentCamera(Camera* cam)
	611	{
	612	updateVertexBuffer(cam);
	613	}
	614	//-----------------------------------------------------------------------
	615	Real BillboardChain::getSquaredViewDepth(const Camera* cam) const
	616	{
	617	Vector3 min, max, mid, dist;
	618	min = mAABB.getMinimum();
	619	max = mAABB.getMaximum();
	620	mid = ((max - min) * 0.5) + min;
	621	dist = cam->getDerivedPosition() - mid;
	622
	623	return dist.squaredLength();
	624	}
	625	//-----------------------------------------------------------------------
	626	Real BillboardChain::getBoundingRadius(void) const
	627	{
	628	return mRadius;
	629	}
	630	//-----------------------------------------------------------------------
	631	const AxisAlignedBox& BillboardChain::getBoundingBox(void) const
	632	{
	633	updateBoundingBox();
	634	return mAABB;
	635	}
	636	//-----------------------------------------------------------------------
	637	const MaterialPtr& BillboardChain::getMaterial(void) const
	638	{
	639	return mMaterial;
	640	}
	641	//-----------------------------------------------------------------------
	642	void BillboardChain::setMaterialName(const String& name)
	643	{
	644	mMaterialName = name;
	645	mMaterial = MaterialManager::getSingleton().getByName(mMaterialName);
	646
	647	if (mMaterial.isNull())
	648	{
	649	LogManager::getSingleton().logMessage("Can't assign material " + name +
	650	" to BillboardChain " + mName + " because this "
	651	"Material does not exist. Have you forgotten to define it in a "
	652	".material script?");
	653	mMaterial = MaterialManager::getSingleton().getByName("BaseWhiteNoLighting");
	654	if (mMaterial.isNull())
	655	{
	656	OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Can't assign default material "
	657	"to BillboardChain of " + mName + ". Did "
	658	"you forget to call MaterialManager::initialise()?",
	659	"BillboardChain.setMaterialName");
	660	}
	661	}
	662	// Ensure new material loaded (will not load again if already loaded)
	663	mMaterial->load();
	664	}
	665	//-----------------------------------------------------------------------
	666	const String& BillboardChain::getMovableType(void) const
	667	{
	668	return BillboardChainFactory::FACTORY_TYPE_NAME;
	669	}
	670	//-----------------------------------------------------------------------
	671	void BillboardChain::_updateRenderQueue(RenderQueue* queue)
	672	{
	673	updateIndexBuffer();
	674
	675	if (mIndexData->indexCount > 0)
	676	{
	677	queue->addRenderable(this);
	678	}
	679
	680	}
	681	//-----------------------------------------------------------------------
	682	void BillboardChain::getRenderOperation(RenderOperation& op)
	683	{
	684	op.indexData = mIndexData;
	685	op.operationType = RenderOperation::OT_TRIANGLE_LIST;
	686	op.srcRenderable = this;
	687	op.useIndexes = true;
	688	op.vertexData = mVertexData;
	689	}
	690	//-----------------------------------------------------------------------
	691	void BillboardChain::getWorldTransforms(Matrix4* xform) const
	692	{
	693	*xform = _getParentNodeFullTransform();
	694	}
	695	//-----------------------------------------------------------------------
	696	const Quaternion& BillboardChain::getWorldOrientation(void) const
	697	{
	698	return getParentNode()->_getDerivedOrientation();
	699	}
	700	//-----------------------------------------------------------------------
	701	const Vector3& BillboardChain::getWorldPosition(void) const
	702	{
	703	return getParentNode()->_getDerivedPosition();
	704	}
	705	//-----------------------------------------------------------------------
	706	const LightList& BillboardChain::getLights(void) const
	707	{
	708	return getParentSceneNode()->findLights(getBoundingRadius());
	709	}
	710	//-----------------------------------------------------------------------
	711	//-----------------------------------------------------------------------
	712	String BillboardChainFactory::FACTORY_TYPE_NAME = "BillboardChain";
	713	//-----------------------------------------------------------------------
	714	const String& BillboardChainFactory::getType(void) const
	715	{
	716	return FACTORY_TYPE_NAME;
	717	}
	718	//-----------------------------------------------------------------------
	719	MovableObject* BillboardChainFactory::createInstanceImpl( const String& name,
	720	const NameValuePairList* params)
	721	{
	722	size_t maxElements = 20;
	723	size_t numberOfChains = 1;
	724	bool useTex = true;
	725	bool useCol = true;
	726	bool dynamic = true;
	727	// optional params
	728	if (params != 0)
	729	{
	730	NameValuePairList::const_iterator ni = params->find("maxElements");
	731	if (ni != params->end())
	732	{
	733	maxElements = StringConverter::parseUnsignedLong(ni->second);
	734	}
	735	ni = params->find("numberOfChains");
	736	if (ni != params->end())
	737	{
	738	numberOfChains = StringConverter::parseUnsignedLong(ni->second);
	739	}
	740	ni = params->find("useTextureCoords");
	741	if (ni != params->end())
	742	{
	743	useTex = StringConverter::parseBool(ni->second);
	744	}
	745	ni = params->find("useVertexColours");
	746	if (ni != params->end())
	747	{
	748	useCol = StringConverter::parseBool(ni->second);
	749	}
	750	ni = params->find("dynamic");
	751	if (ni != params->end())
	752	{
	753	dynamic = StringConverter::parseBool(ni->second);
	754	}
	755
	756	}
	757
	758	return new BillboardChain(name, maxElements, numberOfChains, useTex, useCol, dynamic);
	759
	760	}
	761	//-----------------------------------------------------------------------
	762	void BillboardChainFactory::destroyInstance( MovableObject* obj)
	763	{
	764	delete obj;
	765	}
	766
	767	}
	768

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

Context Navigation

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

Download in other formats: