Context Navigation

OgreBspSceneManager.cpp @ 692

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

Line
1	/*
2	-----------------------------------------------------------------------------
3	This source file is part of OGRE
4	(Object-oriented Graphics Rendering Engine)
5	For the latest info, see http://ogre.sourceforge.net/
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 "OgreBspSceneManager.h"
26	#include "OgreBspResourceManager.h"
27	#include "OgreBspNode.h"
28	#include "OgreException.h"
29	#include "OgreRenderSystem.h"
30	#include "OgreCamera.h"
31	#include "OgreMaterial.h"
32	#include "OgrePatchSurface.h"
33	#include "OgreMesh.h"
34	#include "OgreSubMesh.h"
35	#include "OgreMath.h"
36	#include "OgreControllerManager.h"
37	#include "OgreLogManager.h"
38	#include "OgreBspSceneNode.h"
39	#include "OgreStringConverter.h"
40	#include "OgreLogManager.h"
41	#include "OgreTechnique.h"
42	#include "OgrePass.h"
43	#include "OgreMaterialManager.h"
44
45
46	#include <fstream>
47
48	namespace Ogre {
49
50	//-----------------------------------------------------------------------
51	BspSceneManager::BspSceneManager(const String& name)
52	: SceneManager(name)
53	{
54	// Set features for debugging render
55	mShowNodeAABs = false;
56
57	// No sky by default
58	mSkyPlaneEnabled = false;
59	mSkyBoxEnabled = false;
60	mSkyDomeEnabled = false;
61
62	mLevel.setNull();
63
64	}
65	//-----------------------------------------------------------------------
66	const String& BspSceneManager::getTypeName(void) const
67	{
68	return BspSceneManagerFactory::FACTORY_TYPE_NAME;
69	}
70	//-----------------------------------------------------------------------
71	BspSceneManager::~BspSceneManager()
72	{
73	freeMemory();
74	mLevel.setNull();
75	}
76	//-----------------------------------------------------------------------
77	size_t BspSceneManager::estimateWorldGeometry(const String& filename)
78	{
79	return BspLevel::calculateLoadingStages(filename);
80
81	}
82	//-----------------------------------------------------------------------
83	size_t BspSceneManager::estimateWorldGeometry(DataStreamPtr& stream,
84	const String& typeName)
85	{
86	return BspLevel::calculateLoadingStages(stream);
87
88	}
89	//-----------------------------------------------------------------------
90	void BspSceneManager::setWorldGeometry(const String& filename)
91	{
92	mLevel.setNull();
93	// Check extension is .bsp
94	char extension[6];
95	size_t pos = filename.find_last_of(".");
96	if( pos == String::npos )
97	OGRE_EXCEPT(
98	Exception::ERR_INVALIDPARAMS,
99	"Unable to load world geometry. Invalid extension (must be .bsp).",
100	"BspSceneManager::setWorldGeometry");
101
102	strcpy(extension, filename.substr(pos + 1, filename.length() - pos).c_str());
103
104	if (stricmp(extension, "bsp"))
105	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
106	"Unable to load world geometry. Invalid extension (must be .bsp).",
107	"BspSceneManager::setWorldGeometry");
108
109	// Load using resource manager
110	mLevel = BspResourceManager::getSingleton().load(filename,
111	ResourceGroupManager::getSingleton().getWorldResourceGroupName());
112
113	if (mLevel->isSkyEnabled())
114	{
115	// Quake3 is always aligned with Z upwards
116	Quaternion q;
117	q.FromAngleAxis(Radian(Math::HALF_PI), Vector3::UNIT_X);
118	// Also draw last, and make close to camera (far clip plane is shorter)
119	setSkyDome(true, mLevel->getSkyMaterialName(),
120	mLevel->getSkyCurvature(), 12, 2000, false, q);
121	}
122	else
123	{
124	setSkyDome(false, StringUtil::BLANK);
125	}
126
127	// Init static render operation
128	mRenderOp.vertexData = mLevel->mVertexData;
129	// index data is per-frame
130	mRenderOp.indexData = new IndexData();
131	mRenderOp.indexData->indexStart = 0;
132	mRenderOp.indexData->indexCount = 0;
133	// Create enough index space to render whole level
134	mRenderOp.indexData->indexBuffer = HardwareBufferManager::getSingleton()
135	.createIndexBuffer(
136	HardwareIndexBuffer::IT_32BIT, // always 32-bit
137	mLevel->mNumIndexes,
138	HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE, false);
139
140	mRenderOp.operationType = RenderOperation::OT_TRIANGLE_LIST;
141	mRenderOp.useIndexes = true;
142
143
144	}
145	//-----------------------------------------------------------------------
146	void BspSceneManager::setWorldGeometry(DataStreamPtr& stream,
147	const String& typeName)
148	{
149	mLevel.setNull();
150
151	// Load using resource manager
152	mLevel = BspResourceManager::getSingleton().load(stream,
153	ResourceGroupManager::getSingleton().getWorldResourceGroupName());
154
155	if (mLevel->isSkyEnabled())
156	{
157	// Quake3 is always aligned with Z upwards
158	Quaternion q;
159	q.FromAngleAxis(Radian(Math::HALF_PI), Vector3::UNIT_X);
160	// Also draw last, and make close to camera (far clip plane is shorter)
161	setSkyDome(true, mLevel->getSkyMaterialName(),
162	mLevel->getSkyCurvature(), 12, 2000, false, q);
163	}
164	else
165	{
166	setSkyDome(false, StringUtil::BLANK);
167	}
168
169	// Init static render operation
170	mRenderOp.vertexData = mLevel->mVertexData;
171	// index data is per-frame
172	mRenderOp.indexData = new IndexData();
173	mRenderOp.indexData->indexStart = 0;
174	mRenderOp.indexData->indexCount = 0;
175	// Create enough index space to render whole level
176	mRenderOp.indexData->indexBuffer = HardwareBufferManager::getSingleton()
177	.createIndexBuffer(
178	HardwareIndexBuffer::IT_32BIT, // always 32-bit
179	mLevel->mNumIndexes,
180	HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE, false);
181
182	mRenderOp.operationType = RenderOperation::OT_TRIANGLE_LIST;
183	mRenderOp.useIndexes = true;
184
185
186	}
187	//-----------------------------------------------------------------------
188	void BspSceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters)
189	{
190	// Clear unique list of movables for this frame
191	mMovablesForRendering.clear();
192	// Walk the tree, tag static geometry, return camera's node (for info only)
193	// Movables are now added to the render queue in processVisibleLeaf
194	BspNode* cameraNode = walkTree(cam, onlyShadowCasters);
195
196
197	}
198	//-----------------------------------------------------------------------
199	void BspSceneManager::renderStaticGeometry(void)
200	{
201	// Check we should be rendering
202	if (!isRenderQueueToBeProcessed(mWorldGeometryRenderQueue))
203	return;
204
205	// Cache vertex/face data first
206	std::vector<StaticFaceGroup*>::const_iterator faceGrpi;
207	static RenderOperation patchOp;
208
209	// no world transform required
210	mDestRenderSystem->_setWorldMatrix(Matrix4::IDENTITY);
211	// Set view / proj
212	mDestRenderSystem->_setViewMatrix(mCameraInProgress->getViewMatrix(true));
213	mDestRenderSystem->_setProjectionMatrix(mCameraInProgress->getProjectionMatrixRS());
214
215	// For each material in turn, cache rendering data & render
216	MaterialFaceGroupMap::const_iterator mati;
217
218	for (mati = mMatFaceGroupMap.begin(); mati != mMatFaceGroupMap.end(); ++mati)
219	{
220	// Get Material
221	Material* thisMaterial = mati->first;
222
223	// Empty existing cache
224	mRenderOp.indexData->indexCount = 0;
225	// lock index buffer ready to receive data
226	unsigned int* pIdx = static_cast<unsigned int*>(
227	mRenderOp.indexData->indexBuffer->lock(HardwareBuffer::HBL_DISCARD));
228
229	for (faceGrpi = mati->second.begin(); faceGrpi != mati->second.end(); ++faceGrpi)
230	{
231	// Cache each
232	unsigned int numelems = cacheGeometry(pIdx, *faceGrpi);
233	mRenderOp.indexData->indexCount += numelems;
234	pIdx += numelems;
235	}
236	// Unlock the buffer
237	mRenderOp.indexData->indexBuffer->unlock();
238
239	// Skip if no faces to process (we're not doing flare types yet)
240	if (mRenderOp.indexData->indexCount == 0)
241	continue;
242
243	Technique::PassIterator pit = thisMaterial->getTechnique(0)->getPassIterator();
244
245	while (pit.hasMoreElements())
246	{
247	_setPass(pit.getNext());
248
249	mDestRenderSystem->_render(mRenderOp);
250
251
252	}
253
254
255	} // for each material
256
257	/*
258	if (mShowNodeAABs)
259	{
260	mDestRenderSystem->_render(mAABGeometry);
261	}
262	*/
263	}
264	//-----------------------------------------------------------------------
265	void BspSceneManager::_renderVisibleObjects(void)
266	{
267	// Render static level geometry first
268	renderStaticGeometry();
269
270	// Call superclass to render the rest
271	SceneManager::_renderVisibleObjects();
272
273	}
274
275	//-----------------------------------------------------------------------
276	// REMOVE THIS CRAP
277	//-----------------------------------------------------------------------
278	// Temp debug lines
279	bool firstTime = true;
280	std::ofstream of;
281	//-----------------------------------------------------------------------
282	//-----------------------------------------------------------------------
283	//-----------------------------------------------------------------------
284	BspNode* BspSceneManager::walkTree(Camera* camera, bool onlyShadowCasters)
285	{
286	if (mLevel.isNull()) return 0;
287
288	// Locate the leaf node where the camera is located
289	BspNode* cameraNode = mLevel->findLeaf(camera->getDerivedPosition());
290
291	mMatFaceGroupMap.clear();
292	mFaceGroupSet.clear();
293
294	// Scan through all the other leaf nodes looking for visibles
295	int i = mLevel->mNumNodes - mLevel->mLeafStart;
296	BspNode* nd = mLevel->mRootNode + mLevel->mLeafStart;
297
298	/*
299	if (firstTime)
300	{
301	camera->getViewMatrix(); // Force update view before report
302	of.open("BspSceneManager.log");
303	of << *camera << std::endl;
304	of << "Camera Node: " << *cameraNode << std::endl;
305	of << "Vertex Data: " << std::endl;
306	for (int testi = 0; testi < mLevel->mNumVertices; ++testi)
307	{
308	of << " " << testi << ": pos(" <<
309	mLevel->mVertices[testi].position[0] << ", " <<
310	mLevel->mVertices[testi].position[1] << ", " << mLevel->mVertices[testi].position[2] << ")" <<
311	" uv(" << mLevel->mVertices[testi].texcoords[0] << ", " << mLevel->mVertices[testi].texcoords[1] << ")" <<
312	" lm(" << mLevel->mVertices[testi].lightmap[0] << ", " << mLevel->mVertices[testi].lightmap[1] << ")" << std::endl;
313	}
314	of << "Element data:" << std::endl;
315	for (testi = 0; testi < mLevel->mNumElements; ++testi)
316	{
317	of << " " << testi << ": " << mLevel->mElements[testi] << std::endl;
318
319	}
320	}
321	*/
322
323	while (i--)
324	{
325	if (mLevel->isLeafVisible(cameraNode, nd))
326	{
327
328	// Visible according to PVS, check bounding box against frustum
329	FrustumPlane plane;
330	if (camera->isVisible(nd->getBoundingBox(), &plane))
331	{
332	//if (firstTime)
333	//{
334	// of << "Visible Node: " << *nd << std::endl;
335	//}
336	processVisibleLeaf(nd, camera, onlyShadowCasters);
337	if (mShowNodeAABs)
338	addBoundingBox(nd->getBoundingBox(), true);
339	}
340	}
341	nd++;
342	}
343
344
345	// TEST
346	//if (firstTime)
347	//{
348	// of.close();
349	// firstTime = false;
350	//}
351	return cameraNode;
352
353	}
354	//-----------------------------------------------------------------------
355	void BspSceneManager::processVisibleLeaf(BspNode* leaf, Camera* cam, bool onlyShadowCasters)
356	{
357	MaterialPtr pMat;
358	// Skip world geometry if we're only supposed to process shadow casters
359	// World is pre-lit
360	if (!onlyShadowCasters)
361	{
362	// Parse the leaf node's faces, add face groups to material map
363	int numGroups = leaf->getNumFaceGroups();
364	int idx = leaf->getFaceGroupStart();
365
366	while (numGroups--)
367	{
368	int realIndex = mLevel->mLeafFaceGroups[idx++];
369	// Check not already included
370	if (mFaceGroupSet.find(realIndex) != mFaceGroupSet.end())
371	continue;
372	StaticFaceGroup* faceGroup = mLevel->mFaceGroups + realIndex;
373	// Get Material pointer by handle
374	pMat = MaterialManager::getSingleton().getByHandle(faceGroup->materialHandle);
375	assert (!pMat.isNull());
376	// Check normal (manual culling)
377	ManualCullingMode cullMode = pMat->getTechnique(0)->getPass(0)->getManualCullingMode();
378	if (cullMode != MANUAL_CULL_NONE)
379	{
380	Real dist = faceGroup->plane.getDistance(cam->getDerivedPosition());
381	if ( (dist < 0 && cullMode == MANUAL_CULL_BACK) \|\|
382	(dist > 0 && cullMode == MANUAL_CULL_FRONT) )
383	continue; // skip
384	}
385	mFaceGroupSet.insert(realIndex);
386	// Try to insert, will find existing if already there
387	std::pair<MaterialFaceGroupMap::iterator, bool> matgrpi;
388	matgrpi = mMatFaceGroupMap.insert(
389	MaterialFaceGroupMap::value_type(pMat.getPointer(), std::vector<StaticFaceGroup*>())
390	);
391	// Whatever happened, matgrpi.first is map iterator
392	// Need to get second part of that to get vector
393	matgrpi.first->second.push_back(faceGroup);
394
395	//if (firstTime)
396	//{
397	// of << " Emitting faceGroup: index=" << realIndex << ", " << *faceGroup << std::endl;
398	//}
399	}
400	}
401
402	// Add movables to render queue, provided it hasn't been seen already
403	const BspNode::IntersectingObjectSet& objects = leaf->getObjects();
404	BspNode::IntersectingObjectSet::const_iterator oi, oiend;
405	oiend = objects.end();
406	for (oi = objects.begin(); oi != oiend; ++oi)
407	{
408	if (mMovablesForRendering.find(*oi) == mMovablesForRendering.end())
409	{
410	// It hasn't been seen yet
411	MovableObject mov = const_cast<MovableObject>(*oi); // hacky
412	if (mov->isVisible() &&
413	(!onlyShadowCasters \|\| mov->getCastShadows()) &&
414	cam->isVisible(mov->getWorldBoundingBox()))
415	{
416	mov->_notifyCurrentCamera(cam);
417	mov->_updateRenderQueue(getRenderQueue());
418	// Check if the bounding box should be shown.
419	SceneNode* sn = static_cast<SceneNode*>(mov->getParentNode());
420	if (sn->getShowBoundingBox() \|\| mShowBoundingBoxes)
421	{
422	sn->_addBoundingBoxToQueue(getRenderQueue());
423	}
424	mMovablesForRendering.insert(*oi);
425	}
426
427	}
428	}
429
430
431	}
432	//-----------------------------------------------------------------------
433	unsigned int BspSceneManager::cacheGeometry(unsigned int* pIndexes,
434	const StaticFaceGroup* faceGroup)
435	{
436	// Skip sky always
437	if (faceGroup->isSky)
438	return 0;
439
440	size_t idxStart, numIdx, vertexStart;
441
442	if (faceGroup->fType == FGT_FACE_LIST)
443	{
444	idxStart = faceGroup->elementStart;
445	numIdx = faceGroup->numElements;
446	vertexStart = faceGroup->vertexStart;
447	}
448	else if (faceGroup->fType == FGT_PATCH)
449	{
450
451	idxStart = faceGroup->patchSurf->getIndexOffset();
452	numIdx = faceGroup->patchSurf->getCurrentIndexCount();
453	vertexStart = faceGroup->patchSurf->getVertexOffset();
454	}
455	else
456	{
457	// Unsupported face type
458	return 0;
459	}
460
461
462	// Copy index data
463	unsigned int* pSrc = static_cast<unsigned int*>(
464	mLevel->mIndexes->lock(
465	idxStart * sizeof(unsigned int),
466	numIdx * sizeof(unsigned int),
467	HardwareBuffer::HBL_READ_ONLY));
468	// Offset the indexes here
469	// we have to do this now rather than up-front because the
470	// indexes are sometimes reused to address different vertex chunks
471	for (size_t elem = 0; elem < numIdx; ++elem)
472	{
473	pIndexes++ = pSrc++ + vertexStart;
474	}
475	mLevel->mIndexes->unlock();
476
477	// return number of elements
478	return static_cast<unsigned int>(numIdx);
479
480
481	}
482
483	//-----------------------------------------------------------------------
484	void BspSceneManager::freeMemory(void)
485	{
486	// no need to delete index buffer, will be handled by shared pointer
487	delete mRenderOp.indexData;
488	mRenderOp.indexData = 0;
489	}
490	//-----------------------------------------------------------------------
491	void BspSceneManager::showNodeBoxes(bool show)
492	{
493	mShowNodeAABs = show;
494	}
495	//-----------------------------------------------------------------------
496	void BspSceneManager::addBoundingBox(const AxisAlignedBox& aab, bool visible)
497	{
498	/*
499	unsigned long visibleColour;
500	unsigned long nonVisibleColour;
501	Root& r = Root::getSingleton();
502
503	r.convertColourValue(ColourValue::White, &visibleColour);
504	r.convertColourValue(ColourValue::Blue, &nonVisibleColour);
505	if (mShowNodeAABs)
506	{
507	// Add set of lines
508	float* pVertices = (float)mAABGeometry.pVertices + (mAABGeometry.numVertices3);
509	unsigned short* pIndexes = mAABGeometry.pIndexes + mAABGeometry.numIndexes;
510	unsigned long* pColours = (unsigned long*)mAABGeometry.pDiffuseColour + mAABGeometry.numVertices;
511
512	const Vector3* pCorner = aab.getAllCorners();
513
514	int i;
515	for (i = 0; i < 8; ++i)
516	{
517	*pVertices++ = pCorner->x;
518	*pVertices++ = pCorner->y;
519	*pVertices++ = pCorner->z;
520	pCorner++;
521
522	if (visible)
523	{
524	*pColours++ = visibleColour;
525	}
526	else
527	{
528	*pColours++ = nonVisibleColour;
529	}
530
531	}
532
533	*pIndexes++ = 0 + mAABGeometry.numVertices;
534	*pIndexes++ = 1 + mAABGeometry.numVertices;
535	*pIndexes++ = 1 + mAABGeometry.numVertices;
536	*pIndexes++ = 2 + mAABGeometry.numVertices;
537	*pIndexes++ = 2 + mAABGeometry.numVertices;
538	*pIndexes++ = 3 + mAABGeometry.numVertices;
539	*pIndexes++ = 3 + mAABGeometry.numVertices;
540	*pIndexes++ = 1 + mAABGeometry.numVertices;
541	*pIndexes++ = 4 + mAABGeometry.numVertices;
542	*pIndexes++ = 5 + mAABGeometry.numVertices;
543	*pIndexes++ = 5 + mAABGeometry.numVertices;
544	*pIndexes++ = 6 + mAABGeometry.numVertices;
545	*pIndexes++ = 6 + mAABGeometry.numVertices;
546	*pIndexes++ = 7 + mAABGeometry.numVertices;
547	*pIndexes++ = 7 + mAABGeometry.numVertices;
548	*pIndexes++ = 4 + mAABGeometry.numVertices;
549	*pIndexes++ = 1 + mAABGeometry.numVertices;
550	*pIndexes++ = 5 + mAABGeometry.numVertices;
551	*pIndexes++ = 2 + mAABGeometry.numVertices;
552	*pIndexes++ = 4 + mAABGeometry.numVertices;
553	*pIndexes++ = 0 + mAABGeometry.numVertices;
554	*pIndexes++ = 6 + mAABGeometry.numVertices;
555	*pIndexes++ = 3 + mAABGeometry.numVertices;
556	*pIndexes++ = 7 + mAABGeometry.numVertices;
557
558
559	mAABGeometry.numVertices += 8;
560	mAABGeometry.numIndexes += 24;
561
562
563	}
564	*/
565
566	}
567	//-----------------------------------------------------------------------
568	ViewPoint BspSceneManager::getSuggestedViewpoint(bool random)
569	{
570	if (mLevel.isNull() \|\| mLevel->mPlayerStarts.size() == 0)
571	{
572	// No level, use default
573	return SceneManager::getSuggestedViewpoint(random);
574	}
575	else
576	{
577	if (random)
578	{
579	size_t idx = (size_t)( Math::UnitRandom() * mLevel->mPlayerStarts.size() );
580	return mLevel->mPlayerStarts[idx];
581	}
582	else
583	{
584	return mLevel->mPlayerStarts[0];
585	}
586
587
588	}
589
590	}
591	//-----------------------------------------------------------------------
592	SceneNode * BspSceneManager::createSceneNode( void )
593	{
594	BspSceneNode * sn = new BspSceneNode( this );
595	mSceneNodes[ sn->getName() ] = sn;
596	return sn;
597	}
598	//-----------------------------------------------------------------------
599	SceneNode * BspSceneManager::createSceneNode( const String &name )
600	{
601	BspSceneNode * sn = new BspSceneNode( this, name );
602	mSceneNodes[ sn->getName() ] = sn;
603	return sn;
604	}
605	//-----------------------------------------------------------------------
606	void BspSceneManager::_notifyObjectMoved(const MovableObject* mov,
607	const Vector3& pos)
608	{
609	if (!mLevel.isNull())
610	{
611	mLevel->_notifyObjectMoved(mov, pos);
612	}
613	}
614	//-----------------------------------------------------------------------
615	void BspSceneManager::_notifyObjectDetached(const MovableObject* mov)
616	{
617	if (!mLevel.isNull())
618	{
619	mLevel->_notifyObjectDetached(mov);
620	}
621	}
622	//-----------------------------------------------------------------------
623	void BspSceneManager::clearScene(void)
624	{
625	SceneManager::clearScene();
626	freeMemory();
627	// Clear level
628	mLevel.setNull();
629	}
630	//-----------------------------------------------------------------------
631	/*
632	AxisAlignedBoxSceneQuery* BspSceneManager::
633	createAABBQuery(const AxisAlignedBox& box, unsigned long mask)
634	{
635	// TODO
636	return NULL;
637	}
638	//-----------------------------------------------------------------------
639	SphereSceneQuery* BspSceneManager::
640	createSphereQuery(const Sphere& sphere, unsigned long mask)
641	{
642	// TODO
643	return NULL;
644	}
645	*/
646	//-----------------------------------------------------------------------
647	RaySceneQuery* BspSceneManager::
648	createRayQuery(const Ray& ray, unsigned long mask)
649	{
650	BspRaySceneQuery* q = new BspRaySceneQuery(this);
651	q->setRay(ray);
652	q->setQueryMask(mask);
653	return q;
654	}
655	//-----------------------------------------------------------------------
656	IntersectionSceneQuery* BspSceneManager::
657	createIntersectionQuery(unsigned long mask)
658	{
659	BspIntersectionSceneQuery* q = new BspIntersectionSceneQuery(this);
660	q->setQueryMask(mask);
661	return q;
662	}
663	//-----------------------------------------------------------------------
664	//-----------------------------------------------------------------------
665	BspIntersectionSceneQuery::BspIntersectionSceneQuery(SceneManager* creator)
666	: DefaultIntersectionSceneQuery(creator)
667	{
668	// Add bounds fragment type
669	mSupportedWorldFragments.insert(SceneQuery::WFT_PLANE_BOUNDED_REGION);
670
671	}
672	void BspIntersectionSceneQuery::execute(IntersectionSceneQueryListener* listener)
673	{
674	/*
675	Go through each leaf node in BspLevel and check movables against each other and world
676	Issue: some movable-movable intersections could be reported twice if 2 movables
677	overlap 2 leaves?
678	*/
679	const BspLevelPtr& lvl = ((BspSceneManager*)mParentSceneMgr)->getLevel();
680	if (lvl.isNull()) return;
681
682	BspNode* leaf = lvl->getLeafStart();
683	int numLeaves = lvl->getNumLeaves();
684
685	while (numLeaves--)
686	{
687	const BspNode::IntersectingObjectSet& objects = leaf->getObjects();
688	int numObjects = (int)objects.size();
689
690	BspNode::IntersectingObjectSet::const_iterator a, b, theEnd;
691	theEnd = objects.end();
692	a = objects.begin();
693	for (int oi = 0; oi < numObjects; ++oi, ++a)
694	{
695	const MovableObject* aObj = *a;
696	// Skip this object if collision not enabled
697	if (!(aObj->getQueryFlags() & mQueryMask) \|\|
698	!(aObj->getTypeFlags() & mQueryTypeMask) \|\|
699	!aObj->isInScene())
700	continue;
701
702	if (oi < (numObjects-1))
703	{
704	// Check object against others in this node
705	b = a;
706	for (++b; b != theEnd; ++b)
707	{
708	const MovableObject* bObj = *b;
709	// Apply mask to b (both must pass)
710	if ((bObj->getQueryFlags() & mQueryMask) &&
711	(bObj->getTypeFlags() & mQueryTypeMask) &&
712	bObj->isInScene())
713	{
714	const AxisAlignedBox& box1 = aObj->getWorldBoundingBox();
715	const AxisAlignedBox& box2 = bObj->getWorldBoundingBox();
716
717	if (box1.intersects(box2))
718	{
719	if (!listener->queryResult(const_cast<MovableObject*>(aObj),
720	const_cast<MovableObject*>(bObj)))
721	return;
722	}
723	}
724	}
725	}
726	// Check object against brushes
727	if (mQueryTypeMask & SceneManager::WORLD_GEOMETRY_TYPE_MASK)
728	{
729	const BspNode::NodeBrushList& brushes = leaf->getSolidBrushes();
730	BspNode::NodeBrushList::const_iterator bi, biend;
731	biend = brushes.end();
732	Real radius = aObj->getBoundingRadius();
733	const Vector3& pos = aObj->getParentNode()->_getDerivedPosition();
734
735	for (bi = brushes.begin(); bi != biend; ++bi)
736	{
737	std::list<Plane>::const_iterator planeit, planeitend;
738	planeitend = (*bi)->planes.end();
739	bool brushIntersect = true; // Assume intersecting for now
740
741	for (planeit = (*bi)->planes.begin(); planeit != planeitend; ++planeit)
742	{
743	Real dist = planeit->getDistance(pos);
744	if (dist > radius)
745	{
746	// Definitely excluded
747	brushIntersect = false;
748	break;
749	}
750	}
751	if (brushIntersect)
752	{
753	// report this brush as it's WorldFragment
754	assert((*bi)->fragment.fragmentType == SceneQuery::WFT_PLANE_BOUNDED_REGION);
755	if (!listener->queryResult(const_cast<MovableObject*>(aObj),
756	const_cast<WorldFragment>(&((bi)->fragment))))
757	return;
758	}
759
760	}
761	}
762
763
764	}
765
766	++leaf;
767	}
768
769
770
771	}
772	//-----------------------------------------------------------------------
773	//-----------------------------------------------------------------------
774	BspRaySceneQuery::BspRaySceneQuery(SceneManager* creator)
775	:DefaultRaySceneQuery(creator)
776	{
777	// Add supported fragment types
778	mSupportedWorldFragments.insert(SceneQuery::WFT_SINGLE_INTERSECTION);
779	mSupportedWorldFragments.insert(SceneQuery::WFT_PLANE_BOUNDED_REGION);
780	}
781	//-----------------------------------------------------------------------
782	void BspRaySceneQuery::execute(RaySceneQueryListener* listener)
783	{
784	clearTemporaries();
785	BspLevelPtr lvl = static_cast<BspSceneManager*>(mParentSceneMgr)->getLevel();
786	if (!lvl.isNull())
787	{
788	processNode(
789	lvl->getRootNode(),
790	mRay, listener);
791	}
792	}
793	//-----------------------------------------------------------------------
794	BspRaySceneQuery::~BspRaySceneQuery()
795	{
796	clearTemporaries();
797	}
798	//-----------------------------------------------------------------------
799	void BspRaySceneQuery::clearTemporaries(void)
800	{
801	mObjsThisQuery.clear();
802	std::vector<WorldFragment*>::iterator i;
803	for (i = mSingleIntersections.begin(); i != mSingleIntersections.end(); ++i)
804	{
805	delete *i;
806	}
807	mSingleIntersections.clear();
808	}
809	//-----------------------------------------------------------------------
810	bool BspRaySceneQuery::processNode(const BspNode* node, const Ray& tracingRay,
811	RaySceneQueryListener* listener, Real maxDistance, Real traceDistance)
812	{
813	if (node->isLeaf())
814	{
815	return processLeaf(node, tracingRay, listener, maxDistance, traceDistance);
816	}
817
818	bool res = true;
819	std::pair<bool, Real> result = tracingRay.intersects(node->getSplitPlane());
820	if (result.first && result.second < maxDistance)
821	{
822	// Crosses the split plane, need to perform 2 queries
823	// Calculate split point ray
824	Vector3 splitPoint = tracingRay.getOrigin()
825	+ tracingRay.getDirection() * result.second;
826	Ray splitRay(splitPoint, tracingRay.getDirection());
827
828	if (node->getSide(tracingRay.getOrigin()) == Plane::NEGATIVE_SIDE)
829	{
830	// Intersects from -ve side, so do back then front
831	res = processNode(
832	node->getBack(), tracingRay, listener, result.second, traceDistance);
833	if (!res) return res;
834
835	res = processNode(
836	node->getFront(), splitRay, listener,
837	maxDistance - result.second,
838	traceDistance + result.second);
839	}
840	else
841	{
842	// Intersects from +ve side, so do front then back
843	res = processNode(node->getFront(), tracingRay, listener,
844	result.second, traceDistance);
845	if (!res) return res;
846	res = processNode(node->getBack(), splitRay, listener,
847	maxDistance - result.second,
848	traceDistance + result.second);
849	}
850	}
851	else
852	{
853	// Does not cross the splitting plane, just cascade down one side
854	res = processNode(node->getNextNode(tracingRay.getOrigin()),
855	tracingRay, listener, maxDistance, traceDistance);
856	}
857
858	return res;
859	}
860	//-----------------------------------------------------------------------
861	bool BspRaySceneQuery::processLeaf(const BspNode* leaf, const Ray& tracingRay,
862	RaySceneQueryListener* listener, Real maxDistance, Real traceDistance)
863	{
864	const BspNode::IntersectingObjectSet& objects = leaf->getObjects();
865
866	BspNode::IntersectingObjectSet::const_iterator i, iend;
867	iend = objects.end();
868	//Check ray against objects
869	for(i = objects.begin(); i != iend; ++i)
870	{
871	// cast away constness, constness of node is nothing to do with objects
872	MovableObject* obj = const_cast<MovableObject>(i);
873	// Skip this object if not enabled
874	if(!(obj->getQueryFlags() & mQueryMask) \|\|
875	!((obj->getTypeFlags() & mQueryTypeMask)))
876	continue;
877
878	// check we haven't reported this one already
879	// (objects can be intersecting more than one node)
880	if (mObjsThisQuery.find(obj) != mObjsThisQuery.end())
881	continue;
882
883	//Test object as bounding box
884	std::pair<bool, Real> result =
885	tracingRay.intersects(obj->getWorldBoundingBox());
886	// if the result came back positive and intersection point is inside
887	// the node, fire the event handler
888	if(result.first && result.second <= maxDistance)
889	{
890	if (!listener->queryResult(obj, result.second + traceDistance))
891	return false;
892	}
893	}
894
895
896	// Check ray against brushes
897	if (mQueryTypeMask & SceneManager::WORLD_GEOMETRY_TYPE_MASK)
898	{
899	const BspNode::NodeBrushList& brushList = leaf->getSolidBrushes();
900	BspNode::NodeBrushList::const_iterator bi, biend;
901	biend = brushList.end();
902	bool intersectedBrush = false;
903	for (bi = brushList.begin(); bi != biend; ++bi)
904	{
905	BspNode::Brush* brush = *bi;
906
907
908	std::pair<bool, Real> result = Math::intersects(tracingRay, brush->planes, true);
909	// if the result came back positive and intersection point is inside
910	// the node, check if this brush is closer
911	if(result.first && result.second <= maxDistance)
912	{
913	intersectedBrush = true;
914	if(mWorldFragmentType == SceneQuery::WFT_SINGLE_INTERSECTION)
915	{
916	// We're interested in a single intersection
917	// Have to create these
918	SceneQuery::WorldFragment* wf = new SceneQuery::WorldFragment();
919	wf->fragmentType = SceneQuery::WFT_SINGLE_INTERSECTION;
920	wf->singleIntersection = tracingRay.getPoint(result.second);
921	// save this so we can clean up later
922	mSingleIntersections.push_back(wf);
923	if (!listener->queryResult(wf, result.second + traceDistance))
924	return false;
925	}
926	else if (mWorldFragmentType == SceneQuery::WFT_PLANE_BOUNDED_REGION)
927	{
928	// We want the whole bounded volume
929	assert((*bi)->fragment.fragmentType == SceneQuery::WFT_PLANE_BOUNDED_REGION);
930	if (!listener->queryResult(const_cast<WorldFragment*>(&(brush->fragment)),
931	result.second + traceDistance))
932	return false;
933
934	}
935	}
936	}
937	if (intersectedBrush)
938	{
939	return false; // stop here
940	}
941	}
942
943	return true;
944
945	}
946	//-----------------------------------------------------------------------
947	//-----------------------------------------------------------------------
948	const String BspSceneManagerFactory::FACTORY_TYPE_NAME = "BspSceneManager";
949	//-----------------------------------------------------------------------
950	void BspSceneManagerFactory::initMetaData(void) const
951	{
952	mMetaData.typeName = FACTORY_TYPE_NAME;
953	mMetaData.description = "Scene manager for loading Quake3 .bsp files.";
954	mMetaData.sceneTypeMask = ST_INTERIOR;
955	mMetaData.worldGeometrySupported = true;
956	}
957	//-----------------------------------------------------------------------
958	SceneManager* BspSceneManagerFactory::createInstance(
959	const String& instanceName)
960	{
961	return new BspSceneManager(instanceName);
962	}
963	//-----------------------------------------------------------------------
964	void BspSceneManagerFactory::destroyInstance(SceneManager* instance)
965	{
966	delete instance;
967	}
968
969	}
970

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

Context Navigation

source: OGRE/trunk/ogrenew/PlugIns/BSPSceneManager/src/OgreBspSceneManager.cpp @ 692

Download in other formats: