Context Navigation

source: GTP/trunk/App/Demos/Vis/HillyTerrain/OGRE/TestCullingTerrainApplication.cpp @ 1271

Revision 1271, 25.0 KB checked in by mattausch, 18 years ago (diff)
removed the visibility env, now explicitly giving the view cells as argument

Line
1	#include <OgreNoMemoryMacros.h>
2	#include <CEGUI/CEGUI.h>
3	#include <../CEGUIRenderer/include/OgreCEGUIRenderer.h>
4	#include <../CEGUIRenderer/include/OgreCEGUIResourceProvider.h>
5	#include <../CEGUIRenderer/include/OgreCEGUITexture.h>
6	#include <OgreMemoryMacros.h>
7	#include <OgreIteratorWrappers.h>
8	#include <Ogre.h>
9	#include "TestCullingTerrainApplication.h"
10	#include "TerrainFrameListener.h"
11
12	#if COLLADA
13	#include "OgreColladaPrerequisites.h"
14	#include "OgreColladaDocument.h"
15	#include "OgreColladaScene.h"
16	#endif
17
18	#include "IVReader.h"
19
20	#define WIN32_LEAN_AND_MEAN
21	#include <windows.h>
22
23	const static bool USE_STATIC_GEOMETRY = false;
24	bool TestCullingTerrainApplication::msShowHillyTerrain = false;
25
26
27	//using namespace GtpVisibility;
28
29	/*************************************************************/
30	/* EntityState implementation */
31	/*************************************************************/
32
33
34	Vector3 EntityState::msMinPos = Vector3::ZERO;
35	Vector3 EntityState::msMaxPos = Vector3::ZERO;
36
37	EntityState::EntityState(Entity *ent, State entityState, Real speed):
38	mEntity(ent), mState(entityState), mAnimationSpeed(speed)
39	{
40	switch(entityState)
41	{
42	case MOVING:
43	mAnimationState = mEntity->getAnimationState("Walk");
44	break;
45	case WAITING:
46	mAnimationState = mEntity->getAnimationState("Idle");
47	break;
48	case STOP:
49	mAnimationState = NULL;
50	break;
51	default:
52	break;
53	}
54	// enable animation state
55	if (mAnimationState)
56	{
57	mAnimationState->setLoop(true);
58	mAnimationState->setEnabled(true);
59	}
60
61	mTimeElapsed = Math::RangeRandom(1, 5);
62	}
63	//-----------------------------------------------------------------------
64	EntityState::~EntityState()
65	{
66	mAnimationState = NULL;
67	mEntity = NULL;
68	}
69	//-----------------------------------------------------------------------
70	Entity *EntityState::GetEntity()
71	{
72	return mEntity;
73	}
74	//-----------------------------------------------------------------------
75	EntityState::State EntityState::GetState()
76	{
77	return mState;
78	}
79	//-----------------------------------------------------------------------
80	void EntityState::update(Real timeSinceLastFrame)
81	{
82	mTimeElapsed -= timeSinceLastFrame * mAnimationSpeed;
83
84	if (!mEntity \|\| !mAnimationState)
85	return;
86
87	if (mState == MOVING) // toggle between moving (longer) and waiting (short)
88	{
89	SceneNode *parent = mEntity->getParentSceneNode();
90
91	if (!parent)
92	return;
93
94	if (mTimeElapsed <= 0) // toggle animation state
95	{
96	if (mAnimationState->getAnimationName() == "Idle")
97	{
98	SetAnimationState("Walk", true);
99
100	mTimeElapsed = walk_duration; // walk for mTimeElapsed units
101
102	// choose random rotation
103	Radian rnd = Radian(Math::UnitRandom() * Math::PI * rotate_factor);
104
105	//mEntity->getParentSceneNode()->rotate();
106	parent->yaw(rnd);
107	}
108	else
109	{
110	SetAnimationState("Idle", true);
111	mTimeElapsed = wait_duration; // wait for mTimeElapsed seconds
112	}
113	}
114
115	if (mAnimationState->getAnimationName() == "Walk") // move forward
116	{
117	// store old position, just in case we get out of bounds
118	Vector3 oldPos = parent->getPosition();
119	parent->translate(parent->getLocalAxes(), Vector3(move_factor * mAnimationSpeed, 0, 0));
120
121	// HACK: if out of bounds => reset to old position and set animationstate to idle
122	if (OutOfBounds(parent))
123	{
124	parent->setPosition(oldPos);
125	SetAnimationState("Idle", true);
126
127	mTimeElapsed = wait_duration;
128	}
129	}
130	}
131
132	// add time to drive animation
133	mAnimationState->addTime(timeSinceLastFrame * mAnimationSpeed);
134	}
135	//-----------------------------------------------------------------------
136	void EntityState::SetAnimationState(String stateStr, bool loop)
137	{
138	if (!mEntity)
139	return;
140
141	mAnimationState = mEntity->getAnimationState(stateStr);
142	mAnimationState->setLoop(loop);
143	mAnimationState->setEnabled(true);
144	}
145	//-----------------------------------------------------------------------
146	bool EntityState::OutOfBounds(SceneNode *node)
147	{
148	Vector3 pos = node->getPosition();
149
150	if ((pos > msMinPos) && (pos < msMaxPos))
151	return false;
152
153	return true;
154	}
155
156
157
158	/********************************************************************/
159	/* TestCullingTerrainApplication implementation */
160	/********************************************************************/
161
162
163	TestCullingTerrainApplication::TestCullingTerrainApplication():
164	mTerrainContentGenerator(NULL),
165	mRayQueryExecutor(NULL),
166	mIVReader(NULL),
167	mFilename("terrain"),
168	mViewCellsFilename(""),
169	mAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING)
170	{
171	}
172	//-------------------------------------------------------------------------
173	void TestCullingTerrainApplication::loadConfig(const String& filename)
174	{
175	// TODO matt
176	// Set up the options
177	ConfigFile config;
178	String val;
179
180	config.load(filename);
181
182	std::stringstream d; d << "reading the config file from: " << filename;
183	LogManager::getSingleton().logMessage(d.str());
184
185	val = config.getSetting("Scene");
186
187	if (!val.empty())
188	{
189	mFilename = val.c_str();
190	d << "\nloading scene from file: " << mFilename;
191	LogManager::getSingleton().logMessage(d.str());
192	}
193
194
195	val = config.getSetting("ViewCells");
196
197	if (!val.empty())
198	{
199	mViewCellsFilename = val.c_str();
200	std::stringstream d; d << "view cells file name: " << mViewCellsFilename;
201	LogManager::getSingleton().logMessage(d.str());
202	}
203
204	Vector3 v = Vector3::UNIT_SCALE;
205
206	val = config.getSetting("ViewX");
207
208	if (!val.empty())
209	v.x = atof( val.c_str() );
210
211	val = config.getSetting("ViewY");
212
213	if (!val.empty())
214	v.y = atof(val.c_str());
215
216	val = config.getSetting("ViewZ");
217
218	if (!val.empty())
219	v.z = atof( val.c_str());
220
221
222	val = config.getSetting("OnlineCullingAlgorithm");
223
224	if (!val.empty())
225	{
226	if (val == "CHC")
227	{
228	mAlgorithm =
229	GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING;
230	}
231	else if (val == "SWC")
232	{
233	mAlgorithm =
234	GtpVisibility::VisibilityEnvironment::STOP_AND_WAIT_CULLING;
235	}
236	else if (val == "VFC")
237	{
238	mAlgorithm =
239	GtpVisibility::VisibilityEnvironment::FRUSTUM_CULLING;
240	}
241	}
242
243	/////////////////////////
244	// setup scene
245
246	//-- load the scene from specified file
247	if (!LoadScene(mFilename))
248	{
249	LogManager::getSingleton().logMessage("error loading scene");
250	}
251
252	// set camera position accordingly
253	mCamNode->setPosition(v);
254	}
255	//-----------------------------------------------------------------------
256	TestCullingTerrainApplication::~TestCullingTerrainApplication()
257	{
258	OGRE_DELETE(mTerrainContentGenerator);
259	OGRE_DELETE(mRayQueryExecutor);
260	OGRE_DELETE(mIVReader);
261
262	deleteEntityStates();
263	}
264	//-----------------------------------------------------------------------
265	void TestCullingTerrainApplication::deleteEntityStates()
266	{
267	for (int i = 0; i < (int)mEntityStates.size(); ++i)
268	{
269	OGRE_DELETE(mEntityStates[i]);
270	}
271
272	mEntityStates.clear();
273	}
274	//-----------------------------------------------------------------------
275	void TestCullingTerrainApplication::createCamera()
276	{
277	// create the camera
278	mCamera = mSceneMgr->createCamera("PlayerCam");
279
280	/** set a nice viewpoint
281	* we use a camera node here and apply all transformations on it instead
282	* of applying all transformations directly to the camera
283	* because then the camera is displayed correctly in the visualization
284	*/
285	mCamNode = mSceneMgr->getRootSceneNode()->
286	createChildSceneNode("CamNode1", Vector3(707, 5000, 528));
287
288	mCamNode->setOrientation(Quaternion(-0.3486, 0.0122, 0.9365, 0.0329));
289	mCamNode->attachObject(mCamera);
290
291	//-- create visualization camera
292	mVizCamera = mSceneMgr->createCamera("VizCam");
293	mVizCamera->setPosition(mCamNode->getPosition());
294
295	mVizCamera->setNearClipDistance(1);
296	mCamera->setNearClipDistance(1);
297
298	// infinite far plane?
299	if (mRoot->getRenderSystem()->getCapabilities()->hasCapability(RSC_INFINITE_FAR_PLANE))
300	{
301	mVizCamera->setFarClipDistance(0);
302	mCamera->setFarClipDistance(0);
303	}
304	else
305	{
306	mVizCamera->setFarClipDistance(20000);
307	mCamera->setFarClipDistance(20000);
308	}
309	}
310
311	//-----------------------------------------------------------------------
312	bool TestCullingTerrainApplication::setup()
313	{
314	bool carryOn = ExampleApplication::setup();
315
316	if (carryOn)
317	createRenderTargetListener();
318
319	return carryOn;
320	}
321	//-----------------------------------------------------------------------
322	void TestCullingTerrainApplication::createRenderTargetListener()
323	{
324	mWindow->addListener(new VisualizationRenderTargetListener(mSceneMgr));
325	}
326	//-----------------------------------------------------------------------
327	bool TestCullingTerrainApplication::LoadSceneCollada(const String &filename,
328	SceneNode *root,
329	const int index)
330	{
331	#if COLLADA
332	// Collada
333	ColladaDocument *daeDoc = new ColladaDocument(mSceneMgr);
334
335	String daeName = filename;
336	//if (daeName.empty())
337	// daeName = "City_1500.dae";
338
339	// default directory
340	//daeName.insert(0, "../../media/models/collada/City");
341	LogManager::getSingleton().logMessage("ColladaDocument - import started");
342
343	// full import
344	if (daeDoc->doImport(daeName))
345	{
346	LogManager::getSingleton().logMessage("yuppi");
347	/**
348	* build up scene
349	* if you only want a specific part of the scene graph, you must fetch a scene node
350	* by its unique node name and give it as parameter
351	* e.g.
352	* ColladaSceneNode *box = mScene->getNode("Box2");
353	* if (box != NULL) box->createOgreInstance(NULL);
354	*/
355	daeDoc->getScene()->createOgreInstance(NULL);
356
357	// everything is loaded, we do not need the collada document anymore
358	delete daeDoc;
359
360	return true;
361	}
362	else
363	{
364	LogManager::getSingleton().logMessage("ColladaDocument - import failed");
365	return false;
366	}
367	#endif
368	return true;
369	}
370	//-----------------------------------------------------------------------
371	bool TestCullingTerrainApplication::LoadSceneIV(const String &filename,
372	SceneNode *root,
373	const int index)
374	{
375
376
377
378	mIVReader = new IVReader();
379
380	Timer *timer = PlatformManager::getSingleton().createTimer();
381	timer->reset();
382	if (1)
383	{
384	std::string logFilename = "IVLog" + Ogre::StringConverter().toString(index) + ".log";
385
386	Log *log = LogManager::getSingleton().createLog(logFilename);
387	mIVReader->setLog(log);
388	}
389
390	//viennaNode->translate(Vector3(-300, -300, 0));
391
392	if (mIVReader->loadFile(filename.c_str()))
393	{
394	SceneNode *node = root->createChildSceneNode("IVSceneNode" + index);
395
396	mIVReader->buildTree(mSceneMgr, node);
397
398	mIVReader->collapse();
399	OGRE_DELETE(mIVReader);
400
401
402	std::stringstream d;
403	d << "loaded " << filename << " in " << timer->getMilliseconds() * 1e-3 << " secs";
404	LogManager::getSingleton().logMessage(d.str());
405
406	PlatformManager::getSingleton().destroyTimer(timer);
407
408	//-- bake into static geometry
409	if (USE_STATIC_GEOMETRY)
410	{
411	BakeSceneIntoStaticGeometry("staticVienna", "Vienna");
412	}
413
414	return true;
415	}
416
417	return false;
418	}
419	//--------------------------------------------------------
420	void TestCullingTerrainApplication::BakeSceneIntoStaticGeometry(const String &staticGeomName,
421	const String &nodeName)
422	{
423	#if OGRE_103
424	// note: different static geom for roofs, roads, ..., becazse they have same material
425	StaticGeometry *staticGeom = mSceneMgr->createStaticGeometry(staticGeomName);
426
427	// note: looping over entities here. why does scene node not work?
428	SceneManager::EntityIterator it = mSceneMgr->getEntityIterator();
429	while (it.hasMoreElements())
430	{
431	Entity *ent = it.getNext();
432	ent->setVisible(false);
433	staticGeom->addEntity(ent, ent->getParentSceneNode()->getPosition());
434	}
435
436	staticGeom->setRegionDimensions(Vector3(100,100,100));
437	staticGeom->build();
438
439	// cleanup node
440	//wallsNode->detachAllObjects();
441
442	//roofsNode->detachAllObjects();
443	//roadsNode->detachAllObjects();
444	//planeNode->detachAllObjects();
445
446	//viennaNode->removeChild("Walls");
447	mSceneMgr->destroySceneNode(nodeName);
448	#endif
449	}
450	//--------------------------------------------------------
451	void TestCullingTerrainApplication::createScene()
452	{
453	//-- load scene
454	loadConfig("terrainCulling.cfg");
455
456	/////////////////////////////////////
457
458	// Set ambient light
459	mAmbientLight = ColourValue(0.5, 0.5, 0.5);
460	mSceneMgr->setAmbientLight(mAmbientLight);
461
462	//-- create light
463	mSunLight = mSceneMgr->createLight("SunLight");
464	mSunLight->setType(Light::LT_DIRECTIONAL);
465	//mSunLight->setType(Light::LT_SPOTLIGHT);
466	//mSunLight->setSpotlightRange(Degree(30), Degree(50));
467
468	mSunLight->setPosition(707, 2000, 500);
469	mSunLight->setCastShadows(true);
470
471	// set light angle not too small over the surface,
472	// otherwise shadows textures will be broken
473	Vector3 dir(0.5, 1, 0.5);
474	dir.normalise();
475	mSunLight->setDirection(dir);
476	//mSunLight->setDirection(Vector3::NEGATIVE_UNIT_Y);
477	mSunLight->setDiffuseColour(1, 1, 1);
478	mSunLight->setSpecularColour(1, 1, 1);
479
480	// -- Fog
481	// NB it's VERY important to set this before calling setWorldGeometry
482	// because the vertex program picked will be different
483	ColourValue fadeColour(0.93, 0.86, 0.76);
484	mWindow->getViewport(0)->setBackgroundColour(fadeColour);
485	//mSceneMgr->setFog(FOG_LINEAR, fadeColour, .001, 500, 1000);
486
487	// Create a skybox
488	mSceneMgr->setSkyBox(true, "Examples/CloudyNoonSkyBox", 5000, true);
489
490	// terrain creation
491	if (msShowHillyTerrain)
492	{
493	std::string terrain_cfg("terrain.cfg");
494	#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
495	terrain_cfg = mResourcePath + terrain_cfg;
496	#endif
497	mSceneMgr->setWorldGeometry(terrain_cfg);
498	}
499
500
501	setupGui(); //-- CEGUI setup
502
503	// occluder plane to test visibility
504	if (0)
505	{
506	Plane plane;
507	plane.normal = Vector3::UNIT_Y;
508	plane.d = -60;
509
510	MeshManager::getSingleton().createPlane("Myplane",
511	ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane,
512	5000,5000,100,100,true,1,5,5,Vector3::UNIT_Z);
513
514	Entity* pPlaneEnt = mSceneMgr->createEntity( "plane", "Myplane" );
515	pPlaneEnt->setMaterialName("Examples/Rockwall");
516	pPlaneEnt->setCastShadows(true);
517	mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(pPlaneEnt);
518	}
519
520	// Warning: In GL since we can't go higher than the window res
521	mSceneMgr->setShadowTextureSettings(1024, 2);
522
523	mSceneMgr->setShadowColour(ColourValue(0.5, 0.5, 0.5));
524
525
526	//-- terrain content setup
527
528	// HACK: necessary to call once here for terrain initialisation
529	mSceneMgr->_renderScene(mCamera, mWindow->getViewport(0), true);
530
531	// ray query executor: needed to clamp to terrain
532	mRayQueryExecutor = new RayQueryExecutor(mSceneMgr);
533
534	mTerrainMinPos = EntityState::msMinPos = Vector3(0, 0, 0);
535	mTerrainMaxPos = EntityState::msMaxPos = Vector3(5000, 5000, 5000);
536
537	mTerrainContentGenerator = new TerrainContentGenerator(mSceneMgr);
538
539	if (!msShowHillyTerrain)
540	return;
541
542	// if no objects in file, we generate new objects
543	if (!mTerrainContentGenerator->LoadObjects("objects.out"))
544	{
545	// the objects are generated randomly distributed over the terrain
546	if (1) generateScene(1500, 0); // create robots
547	if (0) generateScene(100, 1); // create trees
548	if (0) generateScene(100, 2); // create ninjas
549	}
550	}
551	//-----------------------------------------------------------------------
552	void TestCullingTerrainApplication::generateScene(int num, int objectType)
553	{
554	float val = TerrainFrameListener::msObjectScales[objectType];
555	Vector3 scale(val, val, val);
556	const float maxHeight = 75;
557
558	// In order to provide much occlusion,
559	// height is restricted to maxHeight => no objects are created on peaks
560	mTerrainContentGenerator->SetMinPos(Vector3(mTerrainMinPos));
561	mTerrainContentGenerator->SetMaxPos(Vector3(mTerrainMaxPos.x, maxHeight, mTerrainMaxPos.z));
562
563	//std::stringstream d; d << "objscale: " << scale[0];
564	//Ogre::LogManager::getSingleton().logMessage(d.str());
565
566	mTerrainContentGenerator->SetScale(scale);
567	mTerrainContentGenerator->SetOffset(TerrainFrameListener::msObjectTerrainOffsets[objectType]);
568	mTerrainContentGenerator->GenerateScene(num, TerrainFrameListener::msObjectCaptions[objectType]);
569
570	if (objectType != 0) // from our objects, only robot has animation phases
571	return;
572
573	EntityList *entList = mTerrainContentGenerator->GetGeneratedEntities();
574
575	//-- add animation state for new robots (located at the end of the list)
576	for (int i = (int)entList->size() - num; i < (int)entList->size(); ++i)
577	{
578	mEntityStates.push_back(new EntityState((*entList)[i],
579	EntityState::WAITING, Math::RangeRandom(0.5, 1.5)));
580	}
581
582	// release limitations on height => it is possible for the user to put single
583	// objects on peaks of the terrain (will be only few, not relevant for occlusion)
584	mTerrainContentGenerator->SetMaxPos(mTerrainMaxPos);
585	}
586	//-----------------------------------------------------------------------
587	void TestCullingTerrainApplication::updateAnimations(Real timeSinceLastFrame)
588	{
589	for (int i = 0; i < (int)mEntityStates.size(); ++i)
590	{
591	SceneNode *sn = mEntityStates[i]->GetEntity()->getParentSceneNode();
592
593	mEntityStates[i]->update(timeSinceLastFrame);
594
595	if (mEntityStates[i]->GetState() == EntityState::MOVING)
596	{
597	Clamp2Terrain(sn, 0); //sn->setNodeVisible(false);
598	}
599	}
600	}
601	//-----------------------------------------------------------------------
602	EntityStates &TestCullingTerrainApplication::getEntityStates()
603	{
604	return mEntityStates;
605	}
606	//-----------------------------------------------------------------------
607	void TestCullingTerrainApplication::setupGui()
608	{
609	#if OGRE103
610	mGUIRenderer = new CEGUI::OgreCEGUIRenderer(mWindow, Ogre::RENDER_QUEUE_OVERLAY,
611	false, 3000, ST_EXTERIOR_CLOSE);
612	#else
613	mGUIRenderer = new CEGUI::OgreCEGUIRenderer(mWindow, Ogre::RENDER_QUEUE_OVERLAY,
614	false, 3000, mSceneMgr);
615	#endif
616	mGUISystem = new CEGUI::System(mGUIRenderer);
617
618	// Mouse
619	CEGUI::SchemeManager::getSingleton().loadScheme((CEGUI::utf8*)"TaharezLook.scheme");
620	CEGUI::MouseCursor::getSingleton().setImage("TaharezLook", "MouseArrow");
621	mGUISystem->setDefaultMouseCursor((CEGUI::utf8*)"TaharezLook",
622	(CEGUI::utf8*)"MouseArrow");
623
624	CEGUI::MouseCursor::getSingleton().hide();
625	}
626	//-----------------------------------------------------------------------
627	void TestCullingTerrainApplication::createFrameListener()
628	{
629	mTerrainFrameListener =
630	new TerrainFrameListener(mWindow,
631	mCamera,
632	mSceneMgr,
633	mGUIRenderer,
634	mTerrainContentGenerator,
635	mVizCamera,
636	mCamNode,
637	mSunLight,
638	this);
639
640	mRoot->addFrameListener(mTerrainFrameListener);
641	}
642	//-----------------------------------------------------------------------
643	void TestCullingTerrainApplication::chooseSceneManager()
644	{
645	#ifdef OGRE_103
646	if (msShowHillyTerrain)
647	{
648	// Terrain scene manager
649	mSceneMgr = mRoot->getSceneManager(ST_EXTERIOR_CLOSE);
650	}
651	else
652	{ // octree scene manager
653	mSceneMgr = mRoot->getSceneManager(ST_GENERIC);
654	}
655	#else
656	if (msShowHillyTerrain)
657	{
658	mSceneMgr = mRoot->createSceneManager("OcclusionCullingSceneManager");
659	//mSceneMgr = mRoot->createSceneManager("TerrainSceneManager");
660	//mSceneMgr = mRoot->createSceneManager("KdTreeSceneManager");
661	}
662	else
663	{
664	mSceneMgr = mRoot->createSceneManager("OcclusionCullingSceneManager");
665	//mSceneMgr = mRoot->createSceneManager("OctreeSceneManager");
666	//mSceneMgr = mRoot->createSceneManager("KdTreeSceneManager");
667	}
668
669	#endif
670	}
671	//-----------------------------------------------------------------------
672	bool TestCullingTerrainApplication::Clamp2Terrain(SceneNode *node, int terrainOffs)
673	{
674	// clamp scene node to terrain
675	Vector3 pos = node->getPosition();
676	Vector3 queryResult;
677
678	if (mRayQueryExecutor->executeRayQuery(&queryResult,
679	Vector3(pos.x, MAX_HEIGHT, pos.z), Vector3::NEGATIVE_UNIT_Y))
680	{
681	node->setPosition(pos.x, queryResult.y + terrainOffs, pos.z);
682	return true;
683	}
684
685	return false;
686	}
687
688	//-----------------------------------------------------------------------
689	bool TestCullingTerrainApplication::Clamp2FloorPlane()
690	{
691	// clamp to floor plane
692	RaySceneQuery *raySceneQuery = mSceneMgr->createRayQuery(
693	Ray(mCamNode->getPosition(), Vector3::NEGATIVE_UNIT_Y));
694
695	RaySceneQueryResult& qryResult = raySceneQuery->execute();
696
697	RaySceneQueryResult::iterator rit = qryResult.begin();
698
699	while (rit != qryResult.end() && rit->movable)
700	{
701	if (rit->movable->getName() != "PlayerCam")
702	{
703	mCamNode->setPosition(mCamNode->getPosition().x,
704	rit->movable->getWorldBoundingBox().getCenter().y + 2,
705	mCamNode->getPosition().z);
706
707	/*
708	std::stringstream d;
709	d << "World: " << it->movable->getWorldBoundingBox().getCenter().y <<
710	", Object: " << it->movable->getBoundingBox().getCenter().y <<
711	", Camera: " << mCamera->getDerivedPosition();
712
713	LogManager::getSingleton().logMessage(d.str());*/
714
715	return true;
716	}
717
718	++ rit;
719	}
720
721	OGRE_DELETE(raySceneQuery);
722	return false;
723	}
724
725	//-----------------------------------------------------------------------
726	// splits strings containing multiple file names
727	static int SplitFilenames(const std::string str, std::vector<std::string> &filenames)
728	{
729	int pos = 0;
730
731	while(1)
732	{
733	int npos = (int)str.find(';', pos);
734
735	if (npos < 0 \|\| npos - pos < 1)
736	break;
737	filenames.push_back(std::string(str, pos, npos - pos));
738	pos = npos + 1;
739	}
740
741	filenames.push_back(std::string(str, pos, str.size() - pos));
742	return (int)filenames.size();
743	}
744	//-----------------------------------------------------------------------
745	bool TestCullingTerrainApplication::LoadScene(const String &filename)
746	{
747	using namespace std;
748	// use leaf nodes of the original spatial hierarchy as occludees
749	vector<string> filenames;
750	int files = SplitFilenames(filename, filenames);
751
752	std::stringstream d;
753	d << "number of input files: " << files << "\n";
754	LogManager::getSingleton().logMessage(d.str());
755
756	bool result = false;
757	vector<string>::const_iterator fit, fit_end = filenames.end();
758	int i = 0;
759
760	for (fit = filenames.begin(); fit != fit_end; ++ fit, ++ i)
761	{
762	const string fn = *fit;
763
764	if (strstr(fn.c_str(), ".iv") \|\| strstr(fn.c_str(), ".wrl"))
765	{
766	// load iv files
767	if (!LoadSceneIV(fn, mSceneMgr->getRootSceneNode(), i))
768	{
769	// terrain hack
770	msShowHillyTerrain = true;
771	LogManager::getSingleton().logMessage("error loading scene => load terrain");
772	}
773	}
774	else if (strstr(filename.c_str(), ".dae"))
775	{
776	// load collada files
777	// load iv files
778	LoadSceneCollada(fn, mSceneMgr->getRootSceneNode(), i);
779	}
780	else //if (filename == "terrain")
781	{
782	// terrain hack
783	msShowHillyTerrain = true;
784	LogManager::getSingleton().logMessage("loading terrain");
785	}
786
787	result = true;
788	}
789
790	return result;
791	}
792	//-----------------------------------------------------------------------
793	bool TestCullingTerrainApplication::LoadViewCells(const String &filename)
794	{
795	LogManager::getSingleton().logMessage("loading view cells");
796
797	//-- the actual loading happens here
798	return mSceneMgr->setOption("LoadViewCells", filename.c_str());
799	}
800
801
802	/**********************************************************************/
803	/* VisualizationRenderTargetListener implementation */
804	/**********************************************************************/
805
806
807	//-----------------------------------------------------------------------
808	VisualizationRenderTargetListener::VisualizationRenderTargetListener(SceneManager *sceneMgr)
809	:RenderTargetListener(), mSceneMgr(sceneMgr)
810	{
811	}
812	//-----------------------------------------------------------------------
813	void VisualizationRenderTargetListener::preViewportUpdate(const RenderTargetViewportEvent &evt)
814	{
815	// visualization viewport
816	const bool showViz = evt.source->getZOrder() == VIZ_VIEWPORT_Z_ORDER;
817	const bool nShowViz = !showViz;
818
819	mSavedShadowTechnique = mSceneMgr->getShadowTechnique();
820	mSavedAmbientLight = mSceneMgr->getAmbientLight();
821
822	// -- ambient light must be full for visualization, shadows disabled
823	if (showViz)
824	{
825	mSceneMgr->setAmbientLight(ColourValue(1, 1, 1));
826	mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
827	}
828
829	mSceneMgr->setOption("PrepareVisualization", &showViz);
830	mSceneMgr->setOption("SkyBoxEnabled", &nShowViz);
831
832	RenderTargetListener::preViewportUpdate(evt);
833	}
834	//-----------------------------------------------------------------------
835	void VisualizationRenderTargetListener::postRenderTargetUpdate(const RenderTargetEvent &evt)
836	{
837	// reset values
838	mSceneMgr->setShadowTechnique(mSavedShadowTechnique);
839	mSceneMgr->setAmbientLight(mSavedAmbientLight);
840
841	RenderTargetListener::postRenderTargetUpdate(evt);
842	}
843	//-----------------------------------------------------------------------
844	INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT )
845	{
846	// Create application object
847	TestCullingTerrainApplication app;
848
849	try
850	{
851	app.go();
852	}
853	catch( Ogre::Exception& e )
854	{
855	MessageBox( NULL, e.getFullDescription().c_str(),
856	"An exception has occured!", MB_OK \| MB_ICONERROR \| MB_TASKMODAL);
857	}
858
859	return 0;
860	}

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

Download in other formats: