Context Navigation

source: GTP/trunk/App/Demos/Vis/HillyTerrain/OGRE/TerrainFrameListener.cpp @ 2183

Revision 2183, 57.1 KB checked in by mattausch, 17 years ago (diff)

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 "TerrainFrameListener.h"
8	#include "OgrePlatformQueryManager.h"
9	#include "VisibilityInfo.h"
10	#include "OgreOcclusionQueriesQueryManager.h"
11	#include "TestCullingTerrainApplication.h"
12	#include <string>
13
14	//-- captions for overlays
15	String TerrainFrameListener::msAlgorithmCaptions[] =
16	{
17	"Coherent Hierarchical Culling",
18	"View Frustum Culling",
19	"Stop and Wait Culling",
20	"Standard Rendering"
21	};
22
23	//-- captions for overlays
24	String TerrainFrameListener::msApprevAlgorithmCaptions[] =
25	{
26	"CHC",
27	"VFC",
28	"SWC",
29	"DEF"
30	};
31
32
33	String TerrainFrameListener::msQueryTypeCaptions[] =
34	{
35	"from camera",
36	"from viewpoint"
37	};
38
39	String TerrainFrameListener::msQueryRelativeVisCaptions[] =
40	{
41	"visible pixels",
42	"relative visibility"
43	};
44
45	String TerrainFrameListener::msQueryMethodCaptions[] =
46	{
47	"occlusion queries",
48	"item buffer"
49	};
50
51	Real TerrainFrameListener::msObjectTerrainOffsets[] =
52	{
53	0,
54	-0.1,
55	//7,
56	0
57	};
58
59	Real TerrainFrameListener::msObjectScales[] =
60	{
61	0.07,
62	0.03,
63	//0.1,
64	0.03
65	};
66
67	String TerrainFrameListener::msObjectCaptions[] =
68	{
69	"robot",
70	"athene",
71	"natFX_Tree1_LOD2",
72	//"tree2",
73	//"HongKong_Tower",
74	"ninja"
75	//"ogrehead"
76	};
77
78	// output file for frame info
79	const char* frames_out_filename = "frame.out";
80	// output file for object positions / orientations
81	const char* objects_out_filename = "objects.out";
82
83	std::ofstream video_out("video.lst");
84
85	// if we are recording a demo
86	static const bool DEMO_HACK = false;
87
88	//using namespace GtpVisibility;
89
90	//-----------------------------------------------------------------------
91	TerrainFrameListener::TerrainFrameListener(RenderWindow* win, Camera* cam,
92	SceneManager *sceneManager,
93	CEGUI::Renderer *renderer,
94	TerrainContentGenerator *sceneGenerator,
95	Camera *vizCamera,
96	SceneNode *camNode,
97	Light *sunLight,
98	TestCullingTerrainApplication *app):
99	mCamera(cam),
100	mWindow(win),
101	mNumScreenShots(0),
102	mTimeDelay(0),
103	mSceneDetailIndex(0),
104	mMoveScale(0.0f),
105	mRotScale(0.0f),
106	mTranslateVector(Vector3::ZERO),
107	mAniso(1),
108	mFiltering(TFO_BILINEAR),
109	mGUIRenderer(renderer),
110	mSceneMgr(sceneManager),
111	mCurrentObject(NULL),
112	mTerrainContentGenerator(sceneGenerator),
113	mVisibilityThreshold(0),
114	mAssumedVisibility(0),
115	mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING),
116	mNodeVizMode(NODEVIZ_NONE),
117	mVizCameraHeight(Real(2000.0)),
118	mCamNode(camNode),
119	mAppState(WALKTHROUGH),
120	mCurrentFrame(0),
121	mReplayTimeElapsed(0),
122	mRotateSpeed(72),
123	mMoveSpeed(50),
124	mVizCamera(vizCamera),
125	mStatsOn(true),
126	mShutdownRequested(false),
127	mLMouseDown(false),
128	mRMouseDown(false),
129	mShowOctree(false),
130	mShowViewCells(false),
131	mUseDepthPass(false),
132	mTestGeometryForVisibleLeaves(false),
133	mShowVisualization(false),
134	mCullCamera(false),
135	mRecordFrames(false),
136	mShowShadows(false),
137	mShowHelp(false),
138	mDisplayCameraDetails(false),
139	mVisualizeCulledNodes(false),
140	mSunLight(sunLight),
141	mShiftPressed(false),
142	mShowQueryStats(false),
143	mQueryManager(NULL),
144	mVisibilityManager(NULL),
145	mDelayedQueriesIssued(0.0),
146	mDelayedTraversedNodes(0.0),
147	mCurrentObjectType(0),
148	mApplication(app),
149	mUseAnimation(false),
150	mDeleteObjects(false),
151	mUseItemBuffer(false),
152	mItemBufferMode(GtpVisibility::QueryManager::PATCH_VISIBILITY),
153	mRecordVideo(false),
154	mPureRenderTimeFps(0.0),
155	mNumVideoFrames(0),
156	mPrecomputedFps(0),
157	mRecordDemo(false),
158	mSavePrecomputedFps(false),
159	mUseBufferedInputMouse(false),
160	mVizScale(25),
161	mUseViewCells(false),
162	mViewCellsLoaded(false),
163	mUseVisibilityFilter(false),
164	mFloorDist(2),
165	mFlushQueue(false)
166	{
167	//mInputDevice = PlatformManager::getSingleton().createInputReader();
168	//mInputDevice->initialise(win, true, true);
169
170	mEventProcessor = new EventProcessor();
171
172	mEventProcessor->initialise(win);
173	mEventProcessor->startProcessingEvents();
174	mEventProcessor->addMouseListener(this);
175	mEventProcessor->addMouseMotionListener(this);
176	mEventProcessor->addKeyListener(this);
177
178	mInputDevice = mEventProcessor->getInputReader();
179
180	mInputDevice->setBufferedInput(true, mUseBufferedInputMouse);
181
182	// create ray query executor, used to place objects in terrain
183	mRayQueryExecutor = new RayQueryExecutor(mSceneMgr);
184
185
186	//////////
187	//-- overlays
188
189	mDebugOverlay = OverlayManager::getSingleton().getByName("Core/DebugOverlay");
190	mHelpOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/HelpOverlay");
191	mQueryOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/QueryOverlay");
192	mCullStatsOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/CullStatsOverlay");
193
194	String ext = "Example/Visibility/";
195
196	//-- overlays
197
198	initVisStatsOverlay(); // visibility stats overlay
199	initHelpOverlay(); // help overlay
200	initQueryOverlay(); // visibility query stats overlay
201
202	// show stats overlays
203	if (!DEMO_HACK)
204	{
205	showStats(true);
206	}
207	else
208	{
209	mMyStatsOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/MyStatsOverlay");
210	mMyStatsAlgorithmInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/MyAlgorithmInfo");
211	mMyStatsAlgorithmInfo->setCaption("");
212
213	const int top = 10;
214	mMyStatsAlgorithmInfo->setTop(top);
215
216	char str[100]; sprintf(str,": %d", 0);
217	mMyStatsFpsInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/MyFpsInfo");
218	mMyStatsFpsInfo->setCaption(str);
219
220	mMyStatsOverlay->show();
221	}
222
223	// loading view cells overlay
224	mLoadingOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/LoadingOverlay");
225	mMyLoadingInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/Loading/MyLoadingInfo");
226	mMyLoadingInfo->setCaption("loading view cells ...");
227
228	mLoadingOverlay->hide();
229
230	// note: larger magnification for terrain to show single objects
231	if (TestCullingTerrainApplication::msShowHillyTerrain)
232	mVizScale = 25;
233	else
234	mVizScale = 1;
235
236	// the scale factor for the visualized bounding boxes
237	mSceneMgr->setOption("NodeVizScale", &mVizScale);
238
239	/////////
240	//-- set the current culling algorithm type
241	//setAlgorithm(mApplication->mAlgorithm);
242
243	bool isNormalExecution;
244
245	mSceneMgr->getOption("NormalExecution", &isNormalExecution);
246	if (isNormalExecution)
247	{
248	// no algorithm
249	mCurrentAlgorithm =
250	GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS;
251	}
252	else
253	{
254	mSceneMgr->getOption("Algorithm", &mCurrentAlgorithm);
255	}
256
257	applyCurrentAlgorithm();
258
259	///////////////////////////////
260
261	// set scene manager options
262	setTestGeometryForVisibleLeaves(mTestGeometryForVisibleLeaves);
263
264	//mSceneMgr->setOption("UseDepthPass", &mUseDepthPass);
265	mSceneMgr->getOption("UseDepthPass", &mUseDepthPass);
266
267	if (mUseDepthPass)
268	mUseDepthPassInfo->setCaption(": true");
269	else
270	mUseDepthPassInfo->setCaption(": false");
271
272	mSceneMgr->getOption("FlushQueue", &mFlushQueue);
273
274	if (mFlushQueue)
275	LogManager::getSingleton().logMessage("initial setting: flushing queue");
276	else
277	LogManager::getSingleton().logMessage("initial setting: not flushing queue");
278
279	mSceneMgr->setOption("ShowOctree", &mShowOctree);
280	mSceneMgr->setOption("ShowViewCells", &mShowViewCells);
281	mSceneMgr->setOption("CullCamera", &mCullCamera);
282	mSceneMgr->setOption("PrepareVisualization", &mShowVisualization);
283
284	applyObjectType();
285
286	// initialise timer
287	mTimer = Root::getSingleton().getTimer();
288	mTimeFrameEnded = mTimeFrameStarted = mTimer->getMilliseconds();
289
290	if (0 && (mSceneMgr->getSceneNode("robot Entity1Node")->
291	getAttachedObject(0)->getMovableType() == "Entity"))
292	Ogre::LogManager::getSingleton().logMessage("found entity");
293
294	// init view cell parameters
295	//mSceneMgr->setOption("UseViewCells", &mUseViewCells);
296	mSceneMgr->setOption("UseVisibilityFilter", &mUseVisibilityFilter);
297
298	// reset statistics
299	mWalkthroughStats.Reset();
300
301	}
302	//-----------------------------------------------------------------------
303	void TerrainFrameListener::switchMouseMode()
304	{
305	mUseBufferedInputMouse = !mUseBufferedInputMouse;
306	mInputDevice->setBufferedInput(true, mUseBufferedInputMouse);
307
308	if (!mUseBufferedInputMouse)
309	CEGUI::MouseCursor::getSingleton().hide();
310	else
311	CEGUI::MouseCursor::getSingleton().show();
312	}
313	//-----------------------------------------------------------------------
314	TerrainFrameListener::~TerrainFrameListener()
315	{
316	OGRE_DELETE(mRayQueryExecutor);
317	OGRE_DELETE(mEventProcessor);
318	OGRE_DELETE(mQueryManager);
319	}
320	//-----------------------------------------------------------------------
321	void TerrainFrameListener::mouseMoved(MouseEvent *e)
322	{
323	// Update CEGUI with the mouse motion
324	CEGUI::System::getSingleton().injectMouseMove(e->getRelX() *
325	mGUIRenderer->getWidth(), e->getRelY() * mGUIRenderer->getHeight());
326	}
327	//-----------------------------------------------------------------------
328	void TerrainFrameListener::mousePressed(MouseEvent* e)
329	{
330	// Left mouse button down
331	if (e->getButtonID() & InputEvent::BUTTON0_MASK)
332	{
333	CEGUI::MouseCursor::getSingleton().hide();
334
335	// Setup the ray scene query
336	Ray mouseRay = mCamera->getCameraToViewportRay(e->getX(), e->getY());
337	Real val = Math::RangeRandom(0, 360); // random rotation
338
339	// get results, create a node/entity on the position
340	mCurrentObject =
341	mTerrainContentGenerator->GenerateSceneObject(mouseRay.getOrigin(),
342	Vector3(val, 0, 0),
343	msObjectCaptions[mCurrentObjectType]);
344
345	mLMouseDown = true;
346	}
347	// Right mouse button down
348	/*else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
349	{
350	CEGUI::MouseCursor::getSingleton().hide();
351	mRMouseDown = true;
352	}*/
353	}
354	//-----------------------------------------------------------------------
355	void TerrainFrameListener::mouseDragDropped(MouseEvent* e)
356	{
357	// Left mouse button up
358	if (e->getButtonID() & InputEvent::BUTTON0_MASK)
359	{
360	CEGUI::MouseCursor::getSingleton().show();
361
362	mLMouseDown = false;
363	}
364	// Right mouse button up
365	else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
366	{
367	CEGUI::MouseCursor::getSingleton().show();
368
369	mRMouseDown = false;
370	}
371	}
372	//-----------------------------------------------------------------------
373	void TerrainFrameListener::mouseReleased(MouseEvent* e)
374	{
375	// Left mouse button up
376	if (e->getButtonID() & InputEvent::BUTTON0_MASK)
377	{
378	CEGUI::MouseCursor::getSingleton().show();
379
380	// start animation: only robot has animation phases
381	if (mCurrentObject && (mCurrentObjectType == TestCullingTerrainApplication::ROBOT))
382	{
383	// HACK: not neccesary the last element
384	Entity *ent = mTerrainContentGenerator->GetGeneratedEntities()->back();
385	EntityState *entState = new EntityState(ent, EntityState::MOVING, Math::RangeRandom(0.5, 1.5));
386	mApplication->getEntityStates().push_back(entState);
387	}
388
389	mLMouseDown = false;
390	}
391	// Right mouse button up
392	else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
393	{
394	CEGUI::MouseCursor::getSingleton().show();
395
396	mRMouseDown = false;
397	}
398	}
399	//-----------------------------------------------------------------------
400	void TerrainFrameListener::mouseDragged(MouseEvent *e)
401	{
402	// If we are dragging the left mouse button.
403	if (mLMouseDown)
404	{
405	if (!mCurrentObject)
406	return;
407
408	Vector3 queryResult;
409	Ray mouseRay = mCamera->getCameraToViewportRay(e->getX(), e->getY());
410
411	if (mRayQueryExecutor->executeRayQuery(&queryResult, mouseRay))
412	{
413	// apply offset so object is ON terrain
414	queryResult.y += msObjectTerrainOffsets[mCurrentObjectType];
415	mCurrentObject->setPosition(queryResult);
416	}
417	}
418	}
419	//-----------------------------------------------------------------------
420	bool TerrainFrameListener::frameStarted(const FrameEvent &evt)
421	{
422	if (mWindow->isClosed())
423	{
424	return false;
425	}
426
427	if (mDeleteObjects)
428	{
429	mApplication->deleteEntityStates();
430	mTerrainContentGenerator->RemoveGeneratedObjects();
431	mDeleteObjects = false;
432	}
433
434	if (mUseAnimation)
435	{
436	// update animation phases
437	mApplication->updateAnimations(evt.timeSinceLastFrame);
438	}
439
440	if (mDisplayCameraDetails) // Print camera details
441	{
442	mWindow->setDebugText("P: " + StringConverter::toString(mCamera->getDerivedPosition()) +
443	" " + "O: " + StringConverter::toString(mCamera->getDerivedOrientation()));
444	}
445
446	//-- setup what is needed for immediate mouse/key movement
447	if (mTimeDelay >= 0)
448	{
449	mTimeDelay -= evt.timeSinceLastFrame;
450	}
451
452	// If this is the first frame, pick a speed
453	if (evt.timeSinceLastFrame == 0)
454	{
455	mMoveScale = 1;
456	mRotScale = 0.1;
457	}
458	// Otherwise scale movement units by time passed since last frame
459	else
460	{
461	// Move about 100 units per second,
462	mMoveScale = mMoveSpeed * evt.timeSinceLastFrame;
463	// Take about 10 seconds for full rotation
464	mRotScale = mRotateSpeed * evt.timeSinceLastFrame;
465	}
466
467	mRotX = 0;
468	mRotY = 0;
469	mTranslateVector = Vector3::ZERO;
470
471	if (!processUnbufferedKeyInput(evt))
472	{
473	return false;
474	}
475	if (!mUseBufferedInputMouse)
476	{
477	if (!processUnbufferedMouseInput(evt))
478	{
479	return false;
480	}
481	}
482
483	if (mShowVisualization)
484	{
485	////////////////
486	//-- set parameters for visualization
487
488	// important for visualization => draw octree bounding boxes
489	if (0)
490	mSceneMgr->setOption("ShowOctree", &mShowVisualization);
491
492	///////////////
493	//-- setup visualization camera
494
495	mVizCamera->setPosition(0, 0, 0);
496	mVizCamera->setOrientation(Quaternion::IDENTITY);
497
498	Vector3 camPos = mCamNode->getPosition();
499	mVizCamera->setPosition(camPos.x, mVizCameraHeight, camPos.z);
500
501	// point down -Z axis
502	mVizCamera->pitch(Radian(Degree(270.0)));
503
504	// rotation arounnd X axis
505	mVizCamera->yaw(Math::ATan2(-mCamera->getDerivedDirection().x,
506	-mCamera->getDerivedDirection().z));
507
508	const float moveFactor = 200;
509	// move by a constant so view plane is on bottom of viewport
510	mVizCamera->moveRelative(Vector3(0, moveFactor, 0));
511	}
512	else
513	{
514	// frame start time
515	mTimeFrameStarted = mTimer->getMilliseconds();
516	}
517
518	//////////////
519	//-- set application state
520
521	switch (mAppState)
522	{
523	case REPLAY:
524	/// set the current camera data to loaded frame information
525	setCurrentFrameInfo(evt.timeSinceLastFrame);
526
527	// HACK for demo: save new frame rates for different methods on the
528	// same walkthrough
529	if (mSavePrecomputedFps)
530	{
531	addFrameInfo(mPrecomputedFpsFrameInfo, mCamNode, evt.timeSinceLastFrame);
532	}
533
534	break;
535	case WALKTHROUGH:
536	//-- recording the camera settings per frame
537	if (mRecordFrames)
538	{
539	addFrameInfo(mFrameInfo, mCamNode, evt.timeSinceLastFrame);
540	// print recording message
541	mWindow->setDebugText("Recording frame " +
542	StringConverter::toString((int)mFrameInfo.size() - 1));
543	}
544	// move camera according to input
545	moveCamera();
546
547	// clamp camera so we always walk along the terrain
548	if (TestCullingTerrainApplication::msShowHillyTerrain)
549	{
550	mApplication->Clamp2Terrain(mCamNode, 5);
551	//Ogre::LogManager::getSingleton().logMessage("clamp to terrain");
552	}
553	else
554	{
555	mApplication->Clamp2FloorPlane(mFloorDist);
556	//Ogre::LogManager::getSingleton().logMessage("clamp to floor");
557	}
558
559	break;
560
561	default:
562	Ogre::LogManager::getSingleton().logMessage("should not come here");
563	break;
564	};
565
566	return true;
567	}
568	//-----------------------------------------------------------------------
569	void TerrainFrameListener::applyVisibilityQuery(bool fromPoint,
570	bool relativeVisibility,
571	bool useItemBuffer)
572	{
573	int itemBufferMode = useItemBuffer ? mItemBufferMode : 0;
574
575	int queryModes = 0;
576	queryModes \|= GtpVisibility::QueryManager::PATCH_VISIBILITY;
577	queryModes \|= GtpVisibility::QueryManager::GEOMETRY_VISIBILITY;
578	queryModes \|= GtpVisibility::QueryManager::NODE_VISIBILITY;
579
580	// no visibility manager available => no visibility scene manager, return
581	GtpVisibility::VisibilityManager *visManager = NULL;
582	if (!mSceneMgr->getOption("VisibilityManager", &visManager))
583	{
584	Ogre::LogManager::getSingleton().logMessage("no vismanager found");
585	return;
586	}
587
588	GtpVisibility::HierarchyInterface *hierarchyInterface = NULL;
589	if (!mSceneMgr->getOption("HierarchyInterface", &hierarchyInterface))
590	{
591	Ogre::LogManager::getSingleton().logMessage("no hierarchy interface found");
592	return;
593	}
594
595	mQueryManager = new OcclusionQueriesQueryManager(hierarchyInterface,
596	mWindow->getViewport(0),
597	queryModes,
598	itemBufferMode);
599
600	//mQueryManager = new PlatformQueryManager(sm->GetHierarchyInterface(), mWindow->getViewport(0), false);
601
602	visManager->SetQueryManager(mQueryManager);
603
604	GtpVisibility::NodeInfoContainer visibleNodes;
605	GtpVisibility::MeshInfoContainer visibleGeometry;
606	GtpVisibility::PatchInfoContainer visiblePatches;
607
608	if (fromPoint)
609	{
610	mQueryManager->ComputeFromPointVisibility(mCamNode->getPosition(),
611	&visibleNodes,
612	&visibleGeometry,
613	&visiblePatches,
614	relativeVisibility);
615	}
616	else
617	{
618	mQueryManager->ComputeCameraVisibility(*mCamera,
619	&visibleNodes,
620	&visibleGeometry,
621	&visiblePatches,
622	relativeVisibility);
623	}
624
625	std::stringstream d;
626	d << "Query mode: " << queryModes << ", "
627	<< msQueryTypeCaptions[fromPoint ? 1 : 0].c_str() << " "
628	<< msQueryRelativeVisCaptions[relativeVisibility ? 1 : 0].c_str() << " "
629	<< msQueryMethodCaptions[useItemBuffer ? 1 : 0].c_str();
630	LogManager::getSingleton().logMessage(d.str());
631
632
633	float averageNodeVis = 0, averageGeometryVis = 0, averagePatchVis = 0;
634	int geomSize = 0, nodesSize = 0, patchSize = 0;
635
636	/////////////////
637	//-- apply queries on geometry level
638
639	GtpVisibility::MeshInfoContainer::iterator geomIt, geomIt_end = visibleGeometry.end();
640
641	for (geomIt = visibleGeometry.begin(); geomIt != geomIt_end; ++geomIt)
642	{
643	// add if not 0
644	if ((*geomIt).GetVisiblePixels())
645	{
646	float vis = relativeVisibility ?
647	(geomIt).ComputeRelativeVisibility() : (float)(geomIt).GetVisiblePixels();
648
649	averageGeometryVis += vis;
650	++ geomSize;
651
652	std::stringstream d;
653	d << "Geometry " << geomSize << " id: " << (*geomIt).GetSource()->getSubEntity(0)->getId()
654	<< " visibility: " << (geomIt).GetVisiblePixels() << ", " << (geomIt).GetProjectedPixels();
655	LogManager::getSingleton().logMessage(d.str());
656	}
657	}
658
659
660	////////////////
661	//-- apply queries on node level
662
663	GtpVisibility::NodeInfoContainer::iterator nodesIt, nodesIt_end = visibleNodes.end();
664
665	for (nodesIt = visibleNodes.begin(); nodesIt != nodesIt_end; ++nodesIt)
666	{
667	// add if not 0
668	if ((*nodesIt).GetVisiblePixels())
669	{
670	float vis = relativeVisibility ?
671	(nodesIt).ComputeRelativeVisibility() : (float)(nodesIt).GetVisiblePixels();
672
673	averageNodeVis += vis;
674	++ nodesSize;
675
676	std::stringstream d; d << "Node visibility: " << vis;
677	LogManager::getSingleton().logMessage(d.str());
678	}
679	}
680
681
682	////////////////
683	//-- apply queries on patch level
684
685
686	GtpVisibility::PatchInfoContainer::iterator patchIt, patchIt_end = visiblePatches.end();
687
688	for (patchIt = visiblePatches.begin(); patchIt != patchIt_end; ++ patchIt)
689	{
690	// add if not 0
691	if ((*patchIt).GetVisiblePixels())
692	{
693	float vis = relativeVisibility ?
694	(patchIt).ComputeRelativeVisibility() : (float)(patchIt).GetVisiblePixels();
695
696	averagePatchVis += vis;
697	++ patchSize;
698
699	std::stringstream d; d << "Patch visibility: " << vis;
700	LogManager::getSingleton().logMessage(d.str());
701	}
702	}
703
704	///////////////////////////////////////////////////////////////
705	//-- update visibility queries stats
706
707	if (nodesSize)
708	averageNodeVis /= (float)nodesSize;
709	if (geomSize)
710	averageGeometryVis /= (float)geomSize;
711	if (patchSize)
712	averagePatchVis /= (float)patchSize;
713
714
715	try
716	{
717	char str[100];
718
719	sprintf(str, ": %s, %s, %s",
720	msQueryTypeCaptions[fromPoint ? 1 : 0].c_str(),
721	msQueryRelativeVisCaptions[relativeVisibility ? 1 : 0].c_str(),
722	msQueryMethodCaptions[useItemBuffer ? 1 : 0].c_str());
723
724	mQueryTypeInfo->setCaption(str);
725
726	sprintf(str, ": %d", (int)nodesSize);
727	mQueryVisibleNodesInfo->setCaption(str);
728
729	sprintf(str,": %d", (int)geomSize);
730	mQueryVisibleGeometryInfo->setCaption(str);
731
732	sprintf(str,": %d", (int)patchSize);
733	mQueryVisiblePatchInfo->setCaption(str);
734
735	sprintf(str,": %3.3f", averageNodeVis);
736	mQueryNodeVisibilityInfo->setCaption(str);
737
738	sprintf(str,": %3.3f", averageGeometryVis);
739	mQueryGeometryVisibilityInfo->setCaption(str);
740
741	sprintf(str,": %3.3f", averagePatchVis);
742	mQueryPatchVisibilityInfo->setCaption(str);
743	}
744	catch (...)
745	{
746	// ignore
747	}
748
749	// show the results
750	if (!mShowQueryStats && !mShowHelp)
751	{
752	mQueryOverlay->show();
753	mShowQueryStats = true;
754	}
755
756	delete mQueryManager;
757	}
758
759
760	bool TerrainFrameListener::processUnbufferedMouseInput(const FrameEvent& evt)
761	{
762	/* Rotation factors, may not be used if the second mouse button is pressed. */
763
764	/* If the second mouse button is pressed, then the mouse movement results in
765	sliding the camera, otherwise we rotate. */
766	if (mInputDevice->getMouseButton(1))
767	{
768	mTranslateVector.x += mInputDevice->getMouseRelativeX() * 0.13;
769	mTranslateVector.y -= mInputDevice->getMouseRelativeY() * 0.13;
770	}
771	else
772	{
773	mRotX = Degree(-mInputDevice->getMouseRelativeX() * 0.13);
774	mRotY = Degree(-mInputDevice->getMouseRelativeY() * 0.13);
775	}
776
777	return true;
778	}
779	//-----------------------------------------------------------------------
780	bool TerrainFrameListener::frameEnded(const FrameEvent& evt)
781	{
782	if (mShutdownRequested)
783	return false;
784
785	// timer end time
786	if (!mShowVisualization)
787	{
788	mTimeFrameEnded = mTimer->getMilliseconds();
789	}
790
791	updateStats();
792
793	if (mRecordVideo) // record current frame
794	{
795	takeVideoFrame(video_out);
796	}
797
798	//-- IMPORTANT: must be set, otherwise terrain is not rendered correctly
799	mSceneMgr->endFrame();
800
801	if (mTimeDelay <= 0) // simulates approx. one second
802	mTimeDelay = 1.0;
803
804	return true;
805	}
806	//-----------------------------------------------------------------------
807	void TerrainFrameListener::moveCamera()
808	{
809	// move node rather than camera so orientation is right in the visualization
810	mCamNode->yaw(mRotX, Ogre::Node::TS_WORLD);
811	//mCamNode->rotate(Vector3(0,1,0), mRotX, Ogre::Node::TS_WORLD);
812	mCamNode->pitch(mRotY);
813
814	mCamNode->translate(mCamNode->getLocalAxes(), mTranslateVector);
815	}
816	//-----------------------------------------------------------------------
817	void TerrainFrameListener::writeFrames(const std::string filename,
818	const FrameInfoContainer &frameInfo) const
819	{
820	std::ofstream ofstr(filename.c_str());
821	std::vector<frame_info>::const_iterator it, it_end;
822	it_end = frameInfo.end();
823
824	int i = 0;
825
826	for (it = frameInfo.begin(); it < it_end; ++ it, ++ i)
827	{
828	ofstr << StringConverter::toString((*it).position) << " "
829	<< StringConverter::toString((*it).orientation) << " "
830	<< StringConverter::toString((*it).timeElapsed) << " "
831	<< StringConverter::toString((*it).fps) << "\n";
832	}
833
834	std::stringstream d; d << "saved " << i << " frames to file " << filename;
835	Ogre::LogManager::getSingleton().logMessage(d.str());
836
837	ofstr.close();
838	}
839	//-----------------------------------------------------------------------
840	void TerrainFrameListener::loadFrames(const std::string filename,
841	FrameInfoContainer &frameInfo)
842	{
843	std::ifstream ifstr(filename.c_str());
844	char line[256];
845	frame_info info;
846
847	// reset current values
848	frameInfo.clear();
849
850	mCurrentFrame = 0;
851	int i = 0;
852	while (!ifstr.eof())
853	{
854	ifstr.getline(line, 256);
855	sscanf(line, "%f %f %f %f %f %f %f %f %f", &info.position.x, &info.position.y, &info.position.z,
856	&info.orientation.w, &info.orientation.x, &info.orientation.y, &info.orientation.z,
857	&info.timeElapsed, &info.fps);
858
859	mFrameInfo.push_back(info);
860
861	// std::stringstream d; d << StringConverter::toString(info.position) << " " << StringConverter::toString(info.orientation);
862	// LogManager::getSingleton().logMessage(d.str());
863	++ i;
864	}
865
866	std::stringstream d;
867	d << "loaded " << i << " frames from file " << filename;
868	Ogre::LogManager::getSingleton().logMessage(d.str());
869
870	ifstr.close();
871	}
872	//-----------------------------------------------------------------------
873	void TerrainFrameListener::nextAppState()
874	{
875	mCurrentFrame = 0;
876	int lastState = mAppState;
877
878	// transition to the next state
879	mAppState = (mAppState + 1) % STATE_NUM;
880
881	// if last state was replay state: post process
882	if (lastState == REPLAY)
883	{
884	// reset debug text
885	mWindow->setDebugText("");
886
887	// hack for producing demo:
888	// we produced precomputed fps during the last replay =>
889	// save them to file
890	if (mSavePrecomputedFps) //!mPrecomputedFpsFrameInfo.empty())
891	{
892	std::string filename = msApprevAlgorithmCaptions[mCurrentAlgorithm] + "_frames.out";
893
894	writeFrames(filename, mPrecomputedFpsFrameInfo);
895	mPrecomputedFpsFrameInfo.clear();
896	}
897
898	std::stringstream d;
899	mWalkthroughStats.Print(d, msApprevAlgorithmCaptions[mCurrentAlgorithm]);
900
901	LogManager::getSingleton().logMessage(d.str());
902	}
903
904	//-- replay recorded walkthrough
905	if (mAppState == REPLAY)
906	{
907	// no standard recording during replay
908	mRecordFrames = false;
909
910	// no stats information
911	mWindow->setDebugText("");
912
913	// clear previous walktrough
914	mFrameInfo.clear();
915
916	std::string filename;
917
918	// if recording demo,
919	// we use precomputed fps which corresponds to current method,
920	// e.g., for chc we load precomputed chc fps from disc.
921	if (mRecordDemo)
922	{
923	filename = msApprevAlgorithmCaptions[mCurrentAlgorithm] + "_frames.out";
924	}
925	else // standard filename
926	{
927	filename = frames_out_filename;
928	}
929
930	//-- load recorded walkthrough from disk
931	loadFrames(filename, mFrameInfo);
932
933
934	// if there are still no recorded frames,
935	// no walkthrough was recorded => set next state
936	if (mFrameInfo.empty())
937	{
938	nextAppState();
939	}
940	else // actual replay
941	{
942	mWindow->setDebugText("Replay");
943
944	// reset, because we measure fps stats during walkthrough
945	// (warning: average fps broken)
946	mWindow->resetStatistics();
947	mWalkthroughStats.Reset();
948
949	//-- initialise frame data
950	mReplayTimeElapsed = 0;
951
952	mCamNode->setPosition(mFrameInfo[0].position);
953	mCamNode->setOrientation(mFrameInfo[0].orientation);
954	}
955	}
956
957	}
958	//-----------------------------------------------------------------------
959	void TerrainFrameListener::toggleRecord()
960	{
961	mRecordFrames = !mRecordFrames;
962
963	if (mRecordFrames)
964	{
965	// starting new recording => clear old frame info
966	mFrameInfo.clear();
967	}
968	else // recording just ended => write frame info to file
969	{
970	writeFrames(frames_out_filename, mFrameInfo);
971	mWindow->setDebugText("");
972	}
973	}
974	//-----------------------------------------------------------------------
975	void TerrainFrameListener::changeThreshold(int incr)
976	{
977	mVisibilityThreshold += incr;
978
979	if (mVisibilityThreshold < 0)
980	{
981	mVisibilityThreshold = 0;
982	}
983
984	char str[100]; sprintf(str,": %d", mVisibilityThreshold);
985
986	mSceneMgr->setOption("Threshold", &mVisibilityThreshold);
987	mThresholdInfo->setCaption(str);
988	}
989	//-----------------------------------------------------------------------
990	void TerrainFrameListener::changeAssumedVisibility(int incr)
991	{
992	mAssumedVisibility += incr;
993
994	if (mAssumedVisibility < 0)
995	{
996	mAssumedVisibility = 0;
997	}
998
999	char str[100]; sprintf(str,": %d", mAssumedVisibility);
1000
1001	mSceneMgr->setOption("AssumedVisibility", &mAssumedVisibility);
1002	mAssumedVisibilityInfo->setCaption(str);
1003	}
1004	//-----------------------------------------------------------------------
1005	void TerrainFrameListener::changeVizScale(const int incr)
1006	{
1007	mVizScale += incr;
1008
1009	if (mVizScale < 1)
1010	{
1011	mVizScale = 1;
1012	}
1013
1014	mSceneMgr->setOption("NodeVizScale", &mVizScale);
1015	}
1016	//-----------------------------------------------------------------------
1017	void TerrainFrameListener::changeFloorDist(const float incr)
1018	{
1019	mFloorDist += incr;
1020
1021	if (mFloorDist < 2)
1022	{
1023	mFloorDist = 2;
1024	}
1025	}
1026	//-----------------------------------------------------------------------
1027	void TerrainFrameListener::zoomVizCamera(int zoom)
1028	{
1029	mVizCameraHeight += zoom;
1030
1031	if(mVizCameraHeight < 0)
1032	mVizCameraHeight = 0;
1033	}
1034	//-----------------------------------------------------------------------
1035	void TerrainFrameListener::nextAlgorithm()
1036	{
1037	// possible algorithms: 3 culling algorithms + standard rendering
1038	mCurrentAlgorithm = (mCurrentAlgorithm + 1) %
1039	(GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS + 1);
1040	applyCurrentAlgorithm();
1041	}
1042	//-----------------------------------------------------------------------
1043	void TerrainFrameListener::applyObjectType()
1044	{
1045	if (mCurrentObjectType >= 3) // TODO: define a constant
1046	mCurrentObjectType = 0;
1047
1048	// parameters for new object
1049	mTerrainContentGenerator->SetOffset(msObjectTerrainOffsets[mCurrentObjectType]);
1050	Real scale = msObjectScales[mCurrentObjectType];
1051	mTerrainContentGenerator->SetScale(Vector3(scale, scale, scale));
1052
1053	mCurrentObjectTypeInfo->setCaption(": " + msObjectCaptions[mCurrentObjectType]);
1054	}
1055	//-----------------------------------------------------------------------
1056	void TerrainFrameListener::applyCurrentAlgorithm()
1057	{
1058	bool isNormalExecution;
1059
1060	if (mCurrentAlgorithm < GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS)
1061	{
1062	isNormalExecution = false;
1063	mSceneMgr->setOption("Algorithm", &mCurrentAlgorithm);
1064	}
1065	else
1066	{ // standard rendering without changed render queue flow
1067	isNormalExecution = true;
1068	}
1069
1070	mSceneMgr->setOption("NormalExecution", &isNormalExecution);
1071	mAlgorithmInfo->setCaption(": " + msAlgorithmCaptions[mCurrentAlgorithm]);
1072
1073	if (1)
1074	{
1075	std::stringstream d; d << "algorithm: " << msAlgorithmCaptions[mCurrentAlgorithm];
1076	Ogre::LogManager::getSingleton().logMessage(d.str());
1077	}
1078	}
1079	//-----------------------------------------------------------------------
1080	void TerrainFrameListener::updateStats()
1081	{
1082	unsigned int opt = 0;
1083	char str[100];
1084
1085	static String currFpsString = "Current FPS: ";
1086	static String avgFpsString = "Average FPS: ";
1087	static String bestFpsString = "Best FPS: ";
1088	static String worstFpsString = "Worst FPS: ";
1089	static String trisString = "Triangle Count: ";
1090
1091	int currentFps;
1092
1093	// HACK for demo: use precomputed FPS instead of real FPS
1094	if (mRecordDemo)
1095	{
1096	currentFps = mPrecomputedFps;
1097	}
1098	else
1099	{
1100	currentFps = mWindow->getStatistics().lastFPS;
1101	}
1102
1103	#if 0
1104	// HACK: take pure rendering time, only measures the render call
1105	long pureRenderTime = mTimeFrameEnded - mTimeFrameStarted;
1106
1107	if (pureRenderTime)
1108	{
1109	mPureRenderTimeFps = 1000.0 / (float) pureRenderTime;
1110	}
1111	currentFps = mPureRenderRenderTimeFps;
1112	//std::stringstream d; d << "Pure render time fps: " << mPureRenderTimeFps << "\n";
1113	//Ogre::LogManager::getSingleton().logMessage(d.str());
1114	#endif
1115
1116	unsigned int nodeInfo[3];
1117	mSceneMgr->getOption("NumRenderedNodes", nodeInfo);
1118	mSceneMgr->getOption("NumQueryCulledNodes", nodeInfo+1);
1119	mSceneMgr->getOption("NumFrustumCulledNodes", nodeInfo+2);
1120
1121
1122	mWalkthroughStats.UpdateFrame(currentFps,
1123	mWindow->getBestFPS(),
1124	mWindow->getWorstFPS(),
1125	(int)mWindow->getTriangleCount(),
1126	nodeInfo[0],
1127	nodeInfo[1],
1128	nodeInfo[2]);
1129
1130	// HACK: compute average fps ourselfs, because ogre avg. fps is wrong
1131	// TODO: update only once per second
1132	float avgFps = (float)mWalkthroughStats.mAccFps / (float)(mWalkthroughStats.mFrameCount);
1133
1134
1135	// update stats when necessary
1136	try
1137	{
1138	OverlayElement* guiAvg = OverlayManager::getSingleton().getOverlayElement("Core/AverageFps");
1139	OverlayElement* guiCurr = OverlayManager::getSingleton().getOverlayElement("Core/CurrFps");
1140	OverlayElement* guiBest = OverlayManager::getSingleton().getOverlayElement("Core/BestFps");
1141	OverlayElement* guiWorst = OverlayManager::getSingleton().getOverlayElement("Core/WorstFps");
1142
1143	const RenderTarget::FrameStats& stats = mWindow->getStatistics();
1144
1145	// HACK: take newly computed avg. fps instead of Ogre avg fps and update only once per second
1146	if (mTimeDelay < 0)
1147	{
1148	guiAvg->setCaption(avgFpsString + StringConverter::toString(avgFps) + " ms");
1149	//guiCurr->setCaption(currFpsString + StringConverter::toString(currentFps));
1150	}
1151
1152	if (0)
1153	{
1154	std::stringstream d;
1155	d << "fps: " << StringConverter::toString(currentFps) << ", "
1156	<< "avg fps: " << StringConverter::toString(avgFps);
1157	LogManager::getSingleton().logMessage(d.str());
1158	}
1159
1160	//guiAvg->setCaption(avgFps + StringConverter::toString(stats.avgFPS));
1161	guiCurr->setCaption(currFpsString + StringConverter::toString(currentFps));
1162
1163	//std::stringstream d; d << "frame rate :" << stats.lastFPS;
1164	//Ogre::LogManager::getSingleton().logMessage(d.str());
1165
1166	guiBest->setCaption(bestFpsString + StringConverter::toString(stats.bestFPS)
1167	+ " " + StringConverter::toString(stats.bestFrameTime) + " ms");
1168	guiWorst->setCaption(worstFpsString + StringConverter::toString(stats.worstFPS)
1169	+ " " + StringConverter::toString(stats.worstFrameTime) + " ms");
1170
1171	OverlayElement* guiTris = OverlayManager::getSingleton().getOverlayElement("Core/NumTris");
1172	guiTris->setCaption(trisString + StringConverter::toString(stats.triangleCount));
1173
1174	//LogManager::getSingleton().logMessage(StringConverter::toString(stats.triangleCount));
1175
1176	OverlayElement* guiDbg = OverlayManager::getSingleton().getOverlayElement("Core/DebugText");
1177	guiDbg->setCaption(mWindow->getDebugText());
1178
1179
1180	//-- culling stats
1181
1182	mSceneMgr->getOption("NumFrustumCulledNodes", &opt); sprintf(str,": %d", opt);
1183	mFrustumCulledNodesInfo->setCaption(str);
1184
1185	mSceneMgr->getOption("NumQueryCulledNodes", &opt); sprintf(str,": %d", opt);
1186	mQueryCulledNodesInfo->setCaption(str);
1187
1188	mSceneMgr->getOption("NumHierarchyNodes", &opt); sprintf(str,": %d", opt);
1189	mHierarchyNodesInfo->setCaption(str);
1190
1191	mSceneMgr->getOption("NumRenderedNodes", &opt); sprintf(str,": %d", opt);
1192	mRenderedNodesInfo->setCaption(str);
1193
1194	sprintf(str,": %d", mTerrainContentGenerator->GetObjectCount());
1195	mObjectsCountInfo->setCaption(str);
1196
1197	// take old value into account in order to create no sudden changes
1198	mSceneMgr->getOption("NumQueriesIssued", &opt);
1199	mDelayedQueriesIssued = mDelayedQueriesIssued * 0.8 + (float)opt * 0.2f;
1200	sprintf(str,": %d", (int)mDelayedQueriesIssued);
1201	mQueriesIssuedInfo->setCaption(str);
1202
1203	mSceneMgr->getOption("NumTraversedNodes", &opt);
1204	mDelayedTraversedNodes = mDelayedTraversedNodes * 0.8 + (float)opt * 0.2f;
1205	sprintf(str,": %d", (int)mDelayedTraversedNodes);
1206	mTraversedNodesInfo->setCaption(str);
1207
1208	if (mRecordVideo)
1209	{
1210	// update stats for demo
1211	mMyStatsAlgorithmInfo->setCaption(msApprevAlgorithmCaptions[mCurrentAlgorithm]);
1212	sprintf(str,": %d", (int)currentFps);
1213	mMyStatsFpsInfo->setCaption(str);
1214	}
1215
1216	}
1217	catch (...)
1218	{
1219	// ignore
1220	}
1221	}
1222	//-----------------------------------------------------------------------
1223	void TerrainFrameListener::setTestGeometryForVisibleLeaves(bool testGeometryForVisibleLeaves)
1224	{
1225	mSceneMgr->setOption("TestGeometryForVisibleLeaves", &mTestGeometryForVisibleLeaves);
1226
1227	/* disable optimization which tests geometry instead of aabb
1228	* for "delayed" rendering of transparents (i.e., render transparents after all the solids)
1229	* because otherwise visible transparents could be skipped
1230	*/
1231	bool delayedRendering = !mTestGeometryForVisibleLeaves;
1232
1233	mSceneMgr->setOption("DelayRenderTransparents", &delayedRendering);
1234
1235	if (mTestGeometryForVisibleLeaves)
1236	{
1237	mTestGeometryForVisibleLeavesInfo->setCaption(": true");
1238	}
1239	else
1240	{
1241	mTestGeometryForVisibleLeavesInfo->setCaption(": false");
1242	}
1243	}
1244	//-----------------------------------------------------------------------
1245	void TerrainFrameListener::toggleShowOctree()
1246	{
1247	mShowOctree = !mShowOctree;
1248	mSceneMgr->setOption("ShowOctree", &mShowOctree);
1249	}
1250	//-----------------------------------------------------------------------
1251	void TerrainFrameListener::toggleShowViewCells()
1252	{
1253	if (0) // tmp matt
1254	{
1255	mShowViewCells = !mShowViewCells;
1256	mSceneMgr->setOption("ShowViewCells", &mShowViewCells);
1257	}
1258	else
1259	{
1260	unsigned int numObjects;
1261	mSceneMgr->getOption("VisibleObjects", &numObjects);
1262	}
1263	}
1264	//-----------------------------------------------------------------------
1265	void TerrainFrameListener::toggleUseViewCells()
1266	{
1267	// HACK: no view cells for hilly terrain
1268	if (mApplication->msShowHillyTerrain)
1269	return;
1270
1271	mUseViewCells = !mUseViewCells;
1272
1273	// load on demand
1274	if (mUseViewCells)// && !mViewCellsLoaded)
1275	{
1276	LogManager::getSingleton().logMessage("using view cells");
1277	mLoadingOverlay->show();
1278
1279	// call once to load view cell loading overlay
1280	mWindow->update();
1281	mViewCellsLoaded = mApplication->LoadViewCells(mApplication->mViewCellsFilename);
1282
1283	if (!mViewCellsLoaded)
1284	LogManager::getSingleton().logMessage("loading view cells failed");
1285	else
1286	LogManager::getSingleton().logMessage("view cells successfully loaded");
1287
1288	mLoadingOverlay->hide();
1289	}
1290
1291	if (mUseViewCells)
1292	mViewCellsInfo->setCaption(": on");
1293	else
1294	mViewCellsInfo->setCaption(": off");
1295
1296	mSceneMgr->setOption("UseViewCells", &mUseViewCells);
1297	}
1298	//-----------------------------------------------------------------------
1299	void TerrainFrameListener::toggleUseVisibilityFilter()
1300	{
1301	mUseVisibilityFilter = !mUseVisibilityFilter;
1302	mSceneMgr->setOption("UseVisibilityFilter", &mUseVisibilityFilter);
1303	}
1304	//-----------------------------------------------------------------------
1305	void TerrainFrameListener::toggleUseDepthPass()
1306	{
1307	mUseDepthPass = !mUseDepthPass;
1308
1309	mSceneMgr->setOption("UseDepthPass", &mUseDepthPass);
1310
1311	if (mUseDepthPass)
1312	{
1313	mUseDepthPassInfo->setCaption(": true");
1314	}
1315	else
1316	{
1317	mUseDepthPassInfo->setCaption(": false");
1318	}
1319	}
1320	//-----------------------------------------------------------------------
1321	void TerrainFrameListener::toggleFlushQueue()
1322	{
1323	mFlushQueue = !mFlushQueue;
1324
1325	mSceneMgr->setOption("FlushQueue", &mFlushQueue);
1326
1327	if (mFlushQueue)
1328	{
1329	LogManager::getSingleton().logMessage("flushing queue");
1330	//mFlushQueueInfo->setCaption(": true");
1331	}
1332	else
1333	{
1334	LogManager::getSingleton().logMessage("not flushing queue");
1335	//mFlushQueueInfo->setCaption(": false");
1336	}
1337	}
1338
1339	//-----------------------------------------------------------------------
1340	void TerrainFrameListener::toggleShowViz()
1341	{
1342	mVisualizeCulledNodes = mShowVisualization = !mShowVisualization;
1343
1344	// create viewport with priority VIZ_VIEWPORT_Z_ORDER:
1345	// will be rendered over standard viewport
1346	if (mShowVisualization)
1347	{
1348	Viewport *vizvp = mWindow->addViewport(mVizCamera,
1349	VIZ_VIEWPORT_Z_ORDER, 0.6, 0.6, 0.4, 0.4);
1350
1351	vizvp->setBackgroundColour(ColourValue(0.0, 0.3, 0.2, 1));
1352
1353	vizvp->setOverlaysEnabled(false);
1354	// Alter the camera aspect ratio to match the viewport
1355	mVizCamera->setAspectRatio(Real(vizvp->getActualWidth()) /
1356	Real(vizvp->getActualHeight()));
1357
1358	mSceneMgr->setOption("VisualizeCulledNodes", &mVisualizeCulledNodes);
1359
1360	}
1361	else
1362	{
1363	// remove visualization viewport
1364	mWindow->removeViewport(VIZ_VIEWPORT_Z_ORDER);
1365
1366	// octree bounding boxes are shown for visualization purpose, reset now
1367	mSceneMgr->setOption("ShowOctree", &mShowOctree);
1368	}
1369	}
1370	//-----------------------------------------------------------------------
1371	void TerrainFrameListener::toggleShowShadows()
1372	{
1373	mShowShadows = !mShowShadows;
1374
1375	mSunLight->setCastShadows(mShowShadows);
1376
1377	if (mShowShadows)
1378	{
1379	mSceneMgr->setShadowTechnique(SHADOWTYPE_TEXTURE_MODULATIVE);
1380	//mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_MODULATIVE);
1381	//mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_ADDITIVE);
1382	}
1383	else
1384	{
1385	mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
1386	}
1387
1388	}
1389	//-----------------------------------------------------------------------
1390	void TerrainFrameListener::nextNodeVizMode()
1391	{
1392	mNodeVizMode = (mNodeVizMode + 1) % NODEVIZ_MODES_NUM;
1393
1394	bool renderNodesForViz = (mNodeVizMode == NODEVIZ_RENDER_NODES) \|\|
1395	(mNodeVizMode == NODEVIZ_RENDER_NODES_AND_CONTENT);
1396	bool renderNodesContentForViz = (mNodeVizMode == NODEVIZ_RENDER_NODES_AND_CONTENT);
1397	//bool renderNodesContentForViz = mNodeVizMode == NODEVIZ_RENDER_GEOMETRY;
1398
1399	mSceneMgr->setOption("RenderNodesForViz", &renderNodesForViz);
1400	mSceneMgr->setOption("RenderNodesContentForViz", &renderNodesContentForViz);
1401	}
1402	//-----------------------------------------------------------------------
1403	void TerrainFrameListener::keyPressed(KeyEvent* e)
1404	{
1405	// hide exact visibility query overlay
1406	if (mShowQueryStats)
1407	{
1408	mQueryOverlay->hide();
1409	mShowQueryStats = false;
1410	}
1411
1412	switch(e->getKey())
1413	{
1414
1415	case KC_SUBTRACT:
1416	changeThreshold(-10);
1417	break;
1418	case KC_ADD:
1419	changeThreshold(10);
1420	break;
1421
1422	case KC_ESCAPE:
1423	mShutdownRequested = true;
1424	e->consume();
1425	return;
1426
1427	case KC_SPACE:
1428	nextAlgorithm();
1429	break;
1430
1431	case KC_LSHIFT:
1432	mShiftPressed = true;
1433	break;
1434	case KC_DELETE:
1435	mDeleteObjects = true;
1436	break;
1437
1438	case KC_C:
1439	if (mItemBufferMode != GtpVisibility::QueryManager::GEOMETRY_VISIBILITY)
1440	{
1441	mItemBufferMode = GtpVisibility::QueryManager::GEOMETRY_VISIBILITY;
1442	}
1443	else
1444	{
1445	mItemBufferMode = GtpVisibility::QueryManager::PATCH_VISIBILITY;
1446	}
1447	break;
1448	case KC_E: // hack for recording demo using precomputed fps
1449	mSavePrecomputedFps = !mSavePrecomputedFps;
1450	break;
1451
1452	case KC_F:
1453	nextFilter();
1454	break;
1455	case KC_G:
1456	mTestGeometryForVisibleLeaves = !mTestGeometryForVisibleLeaves;
1457	setTestGeometryForVisibleLeaves(mTestGeometryForVisibleLeaves);
1458	break;
1459	case KC_H:
1460	toggleShowShadows();
1461	break;
1462	case KC_L:
1463	toggleShowViewCells();
1464	break;
1465	case KC_M: // hack for recording demo using precomputed fps
1466	mRecordDemo = !mRecordDemo;
1467	break;
1468	case KC_O:
1469	switchMouseMode();
1470	break;
1471	case KC_P:
1472	toggleDisplayCameraDetails();
1473	break;
1474	case KC_V:
1475	toggleUseViewCells();
1476	break;
1477	case KC_Q:
1478	toggleUseVisibilityFilter();
1479	break;
1480	case KC_R:
1481	nextSceneDetailLevel();
1482	break;
1483	case KC_T:
1484	toggleShowOctree();
1485	break;
1486	case KC_U:
1487	mCamNode->resetOrientation();
1488	mCamNode->setPosition(mApplication->mInitialPosition);
1489	break;
1490	case KC_X:
1491	toggleUseDepthPass();
1492	break;
1493	case KC_I:
1494	toggleFlushQueue();
1495	break;
1496	case KC_Z:
1497	mCamNode->resetOrientation();
1498	break;
1499
1500
1501	///////////////
1502	//-- visualization
1503
1504	case KC_1:
1505	toggleShowViz();
1506	break;
1507	case KC_2:
1508	nextNodeVizMode();
1509	break;
1510	case KC_7:
1511	mTerrainContentGenerator->WriteObjects(objects_out_filename);
1512	break;
1513	case KC_8:
1514	changeAssumedVisibility(-5);
1515	// changeAssumedVisibility(-500);
1516	break;
1517	case KC_9:
1518	changeAssumedVisibility(5);
1519	// changeAssumedVisibility(500);
1520	break;
1521
1522	//#if USE_PERFHUD
1523	case KC_F1:
1524	toggleShowHelp();
1525	break;
1526	case KC_F2:
1527	mStatsOn = !mStatsOn;
1528	showStats(mStatsOn);
1529	break;
1530	case KC_F3:
1531	nextAppState();
1532	break;
1533	case KC_F4:
1534	toggleRecord();
1535	break;
1536
1537	case KC_F5:
1538	{
1539	unsigned int pixels = 0;
1540	mSceneMgr->getOption("VisibleObjects", &pixels);
1541
1542	std::stringstream d; d << "visible objects: " << pixels;
1543	LogManager::getSingleton().logMessage(d.str());
1544	const bool fromPoint = false;
1545	//applyVisibilityQuery(fromPoint, mShiftPressed, mUseItemBuffer);
1546	break;
1547	}
1548
1549	case KC_F6:
1550	{
1551	const bool fromPoint = true;
1552	applyVisibilityQuery(fromPoint, mShiftPressed, mUseItemBuffer);
1553	break;
1554	}
1555	case KC_F7:
1556	++ mCurrentObjectType;
1557	applyObjectType();
1558	break;
1559	//#endif
1560
1561	case KC_F8:
1562	{
1563	// generate new objects
1564	const int objNum = 500;
1565	mApplication->generateScene(objNum, mCurrentObjectType);
1566	}
1567	break;
1568	case KC_F9:
1569	mUseAnimation = !mUseAnimation;
1570	break;
1571
1572	case KC_F10:
1573	mRecordVideo = !mRecordVideo;
1574
1575	case KC_F11:
1576	takeScreenshot();
1577	break;
1578
1579	case KC_F12:
1580	break;
1581	//KEY_PRESSED(KC_F3, 0.3, writeFrames());
1582	//KEY_PRESSED(KC_F4, 0.3, loadFrames());
1583	default:
1584	break;
1585	}
1586
1587	CEGUI::System::getSingleton().injectKeyDown(e->getKey());
1588	CEGUI::System::getSingleton().injectChar(e->getKeyChar());
1589	e->consume();
1590	}
1591	//-----------------------------------------------------------------------
1592	void TerrainFrameListener::keyReleased(KeyEvent* e)
1593	{
1594	if (e->getKey() == KC_LSHIFT)
1595	{
1596	mShiftPressed = false;
1597	}
1598
1599	CEGUI::System::getSingleton().injectKeyUp(e->getKey());
1600	e->consume();
1601	}
1602	//-----------------------------------------------------------------------
1603	void TerrainFrameListener::keyClicked(KeyEvent* e)
1604	{
1605	// Do nothing
1606	e->consume();
1607	}
1608	//-----------------------------------------------------------------------
1609	void TerrainFrameListener::addFrameInfo(FrameInfoContainer &frameInfos,
1610	SceneNode *camNode,
1611	Real timeElapsed)
1612	{
1613	frame_info info;
1614
1615	info.orientation = mCamNode->getOrientation();
1616	info.position = mCamNode->getPosition();
1617	info.timeElapsed = timeElapsed;
1618	info.fps = mWindow->getStatistics().lastFPS;
1619
1620	frameInfos.push_back(info);
1621	}
1622	//-----------------------------------------------------------------------
1623	void TerrainFrameListener::setCurrentFrameInfo(const Real timeElapsed)
1624	{
1625	//-- find current frame relative to elapsed frame time
1626	mReplayTimeElapsed -= timeElapsed;
1627
1628	while ((mReplayTimeElapsed <= 0) && (mCurrentFrame < (int)mFrameInfo.size() - 1))
1629	{
1630	mReplayTimeElapsed += mFrameInfo[mCurrentFrame ++].timeElapsed;
1631	}
1632
1633
1634	// TODO: crashes here if recording / replaying on the same time!!
1635	const frame_info new_frame = mFrameInfo[mCurrentFrame];
1636	const frame_info old_frame = mFrameInfo[mCurrentFrame - 1];
1637
1638	/////////////
1639	//-- interpolate frames
1640	Real factor = 1;
1641
1642	if (old_frame.timeElapsed > 0)
1643	{
1644	factor = mReplayTimeElapsed / old_frame.timeElapsed;
1645	}
1646
1647	const Vector3 camPos = old_frame.position + factor
1648	* (new_frame.position - old_frame.position);
1649
1650	// interpolate the orientation
1651	const Quaternion camOrienation =
1652	Quaternion::Slerp(factor, old_frame.orientation, new_frame.orientation, true);
1653
1654	// HACK for demo: interpolate precomputed fps
1655	mPrecomputedFps = old_frame.fps + factor * (new_frame.fps - old_frame.fps);
1656
1657	mCamNode->setPosition(camPos);
1658	mCamNode->setOrientation(camOrienation);
1659
1660	// stop replaying after one full walkthrough
1661	if (mCurrentFrame == (int)mFrameInfo.size() - 1)
1662	{
1663	nextAppState();
1664	}
1665	}
1666	//-----------------------------------------------------------------------
1667	bool TerrainFrameListener::processUnbufferedKeyInput(const FrameEvent& evt)
1668	{
1669	bool cursorPressed = false;
1670
1671	/* Move camera forward by keypress. */
1672	if (mInputDevice->isKeyDown(KC_UP) \|\| mInputDevice->isKeyDown(KC_W))
1673	{
1674	mTranslateVector.z = -mMoveScale;
1675	cursorPressed = true;
1676	}
1677	/* Move camera backward by keypress. */
1678	if (mInputDevice->isKeyDown(KC_DOWN) \|\| mInputDevice->isKeyDown(KC_S))
1679	{
1680	mTranslateVector.z = mMoveScale;
1681	cursorPressed = true;
1682	}
1683
1684	if (mInputDevice->isKeyDown(KC_A))
1685	{
1686	mTranslateVector.x -= mMoveScale;
1687	mTranslateVector.y += mMoveScale;
1688
1689	cursorPressed = true;
1690	}
1691
1692	if (mInputDevice->isKeyDown(KC_D))
1693	{
1694	mTranslateVector.x += mMoveScale;
1695	mTranslateVector.y -= mMoveScale;
1696
1697	cursorPressed = true;
1698	}
1699
1700	if (mInputDevice->isKeyDown(KC_RIGHT))
1701	{
1702	mCamNode->yaw(-mRotScale, Ogre::Node::TS_WORLD);
1703	cursorPressed = true;
1704	}
1705
1706	if (mInputDevice->isKeyDown(KC_LEFT))
1707	{
1708	mCamNode->yaw(mRotScale, Ogre::Node::TS_WORLD);
1709	cursorPressed = true;
1710	}
1711	// visualization camera
1712	if (mInputDevice->isKeyDown(KC_3))
1713	{
1714	zoomVizCamera(50);
1715	}
1716	if (mInputDevice->isKeyDown(KC_4))
1717	{
1718	zoomVizCamera(-50);
1719	}
1720
1721	if (mInputDevice->isKeyDown(KC_5))
1722	{
1723	changeVizScale(-1);
1724	}
1725
1726	if (mInputDevice->isKeyDown(KC_6))
1727	{
1728	changeVizScale(1);
1729	}
1730
1731	if (mInputDevice->isKeyDown(KC_7))
1732	{
1733	changeFloorDist(-1);
1734	}
1735
1736	if (mInputDevice->isKeyDown(KC_8))
1737	{
1738	changeFloorDist(1);
1739	}
1740
1741
1742	// show the results
1743	if (cursorPressed && mShowQueryStats)
1744	{
1745	mQueryOverlay->hide();
1746	mShowQueryStats = false;
1747	}
1748
1749	// Return true to continue rendering
1750	return true;
1751	}
1752	//-----------------------------------------------------------------------
1753	void TerrainFrameListener::nextFilter()
1754	{
1755	switch (mFiltering)
1756	{
1757	case TFO_BILINEAR:
1758	mFiltering = TFO_TRILINEAR;
1759	mAniso = 1;
1760	break;
1761	case TFO_TRILINEAR:
1762	mFiltering = TFO_ANISOTROPIC;
1763	mAniso = 8;
1764	break;
1765	case TFO_ANISOTROPIC:
1766	mFiltering = TFO_BILINEAR;
1767	mAniso = 1;
1768	break;
1769	default:
1770	break;
1771	}
1772
1773	MaterialManager::getSingleton().setDefaultTextureFiltering(mFiltering);
1774	MaterialManager::getSingleton().setDefaultAnisotropy(mAniso);
1775
1776	// reload stats
1777	showStats(mStatsOn);
1778	}
1779	//-----------------------------------------------------------------------
1780	void TerrainFrameListener::nextSceneDetailLevel()
1781	{
1782	#if OGRE_103
1783	mSceneDetailIndex = (mSceneDetailIndex + 1) % 3;
1784	switch (mSceneDetailIndex)
1785	{
1786	case 0:
1787	mCamera->setDetailLevel(SDL_SOLID);
1788	break;
1789	case 1:
1790	mCamera->setDetailLevel(SDL_WIREFRAME);
1791	break;
1792	case 2:
1793	mCamera->setDetailLevel(SDL_POINTS);
1794	break;
1795	}
1796	#endif
1797	}
1798	//-----------------------------------------------------------------------
1799	void TerrainFrameListener::takeVideoFrame(std::ofstream &ofstr)
1800	{
1801	char name[50];
1802
1803	sprintf(name, "frame_%05d.tga", ++mNumVideoFrames);
1804	mWindow->writeContentsToFile(name);
1805	//mWindow->setDebugText(String("Wrote ") + name);
1806
1807	ofstr << name << "\n";
1808	}
1809	//-----------------------------------------------------------------------
1810	void TerrainFrameListener::takeScreenshot()
1811	{
1812	char name[50];
1813
1814	sprintf(name, "screenshot_%05d.png", ++mNumScreenShots);
1815	mWindow->writeContentsToFile(name);
1816	//mWindow->setDebugText(String("Wrote ") + name);
1817	}
1818	//-----------------------------------------------------------------------
1819	void TerrainFrameListener::toggleDisplayCameraDetails()
1820	{
1821	mDisplayCameraDetails = !mDisplayCameraDetails;
1822
1823	if (!mDisplayCameraDetails)
1824	{
1825	mWindow->setDebugText("");
1826	}
1827	}
1828	//-----------------------------------------------------------------------
1829	void TerrainFrameListener::showStats(bool show)
1830	{
1831	if (mDebugOverlay && mCullStatsOverlay)
1832	{
1833	if (show)
1834	{
1835	mDebugOverlay->show();
1836	mCullStatsOverlay->show();
1837	}
1838	else
1839	{
1840	mDebugOverlay->hide();
1841	mCullStatsOverlay->hide();
1842	}
1843	}
1844	}
1845
1846	//-----------------------------------------------------------------------
1847	void TerrainFrameListener::toggleShowHelp()
1848	{
1849	mShowHelp = !mShowHelp;
1850
1851	if (mShowHelp)
1852	{
1853	mHelpOverlay->show();
1854	}
1855	else
1856	{
1857	mHelpOverlay->hide();
1858	}
1859	}
1860	//-----------------------------------------------------------------------
1861	void TerrainFrameListener::initOverlayElement(OverlayElement **elInfo, String ext,
1862	String name, int top, String caption)
1863	{
1864	OverlayElement *el =
1865	OverlayManager::getSingleton().getOverlayElement(ext + name);
1866
1867	(*elInfo) = OverlayManager::getSingleton().getOverlayElement(ext + name + "Info");
1868	(*elInfo)->setCaption(caption);
1869
1870	el->setTop(top);
1871	(*elInfo)->setTop(top);
1872	}
1873	//-----------------------------------------------------------------------
1874	void TerrainFrameListener::initHelpOverlayElement(String name, int top)
1875	{
1876	OverlayElement *el = OverlayManager::getSingleton().getOverlayElement(
1877	"Example/Visibility/Help/" + name);
1878
1879	el->setTop(top);
1880	}
1881	//-----------------------------------------------------------------------
1882	void TerrainFrameListener::initHelpOverlay()
1883	{
1884	const int vert_space = 15;
1885	int top = 30;
1886
1887	initHelpOverlayElement("ShowHelp", top); top += vert_space;
1888	initHelpOverlayElement("Stats", top); top += vert_space;
1889	initHelpOverlayElement("AppState", top); top += vert_space;
1890	initHelpOverlayElement("Recorded", top); top += vert_space;
1891	initHelpOverlayElement("Animation", top); top += vert_space;
1892	initHelpOverlayElement("Video", top); top += vert_space;
1893	initHelpOverlayElement("Screenshots", top); top += vert_space;
1894	initHelpOverlayElement("WriteOut", top); top += vert_space;
1895
1896
1897	top +=vert_space;
1898	initHelpOverlayElement("SceneDetail", top); top += vert_space;
1899	initHelpOverlayElement("DisplayCameraDetails", top); top += vert_space;
1900	initHelpOverlayElement("DisplayOctree", top); top += vert_space;
1901	initHelpOverlayElement("UseShadows", top); top += vert_space;
1902	initHelpOverlayElement("Filter", top); top += vert_space;
1903
1904	//-- visualization
1905	top += vert_space;
1906	initHelpOverlayElement("VizSection", top); top += vert_space;
1907	initHelpOverlayElement("Viz", top); top += vert_space;
1908	initHelpOverlayElement("NextVizMode", top); top += vert_space;
1909	initHelpOverlayElement("ZoomViz", top); top += vert_space;
1910
1911
1912	//-- visibility queries
1913	top += vert_space;
1914	initHelpOverlayElement("VisQuery", top); top += vert_space;
1915	initHelpOverlayElement("FromCameraQuery", top); top += vert_space;
1916	initHelpOverlayElement("FromPointQuery", top); top += vert_space;
1917	initHelpOverlayElement("QueryType", top); top += vert_space;
1918	initHelpOverlayElement("QueryTarget", top); top += vert_space;
1919
1920	//-- object generation
1921	top += vert_space;
1922	initHelpOverlayElement("SceneObjects", top); top += vert_space;
1923	initHelpOverlayElement("PlaceObjects", top); top += vert_space;
1924	initHelpOverlayElement("GenerateObjects", top); top += vert_space;
1925	initHelpOverlayElement("RemoveObjects", top); top += vert_space;
1926	initHelpOverlayElement("DropObject", top); top += vert_space;
1927
1928	OverlayElement *helpPanel = OverlayManager::getSingleton().getOverlayElement(
1929	"Example/Visibility/Help/HelpPanel");
1930
1931	helpPanel->setHeight(top + 10);
1932	}
1933	//-----------------------------------------------------------------------
1934	void TerrainFrameListener::initVisStatsOverlay()
1935	{
1936	const int border_height = 10;
1937	const int vert_space = 15;
1938
1939	//-- visibility culling stats overlay
1940	int top = border_height;
1941
1942	String ext = "Example/Visibility/";
1943
1944	initOverlayElement(&mAlgorithmInfo, ext, "Algorithm", top,
1945	": " + msAlgorithmCaptions[mCurrentAlgorithm]); top += vert_space;
1946
1947	initOverlayElement(&mThresholdInfo, ext, "Threshold", top, ": 0"); top += vert_space;
1948	initOverlayElement(&mTestGeometryForVisibleLeavesInfo, ext,
1949	"TestGeometryForVisibleLeaves", top, ": true"); top += vert_space;
1950	initOverlayElement(&mUseDepthPassInfo, ext, "UseDepthPass", top, ": false"); top += vert_space;
1951	initOverlayElement(&mAssumedVisibilityInfo, ext, "AssumedVisibility", top, ": 0"); top += vert_space;
1952	initOverlayElement(&mCurrentObjectTypeInfo, ext, "CurrentObjectType", top, ": "); top += vert_space;
1953	initOverlayElement(&mViewCellsInfo, ext, "ViewCells", top, ": "); top += vert_space;
1954	//initOverlayElement(&mHelpInfo, ext, "Help", top, ": "); top += vert_space;
1955
1956	OverlayElement *optionsPanel = OverlayManager::getSingleton().
1957	getOverlayElement("Example/Visibility/VisibilityPanel");
1958
1959	optionsPanel->setHeight(top + border_height);
1960
1961	top = border_height;
1962	//ext = "Example/Visibility/";
1963	initOverlayElement(&mFrustumCulledNodesInfo, ext, "FrustumCulledNodes", top, ": 0"); top += vert_space;
1964	initOverlayElement(&mQueryCulledNodesInfo, ext, "QueryCulledNodes", top, ": 0"); top += vert_space;
1965	initOverlayElement(&mTraversedNodesInfo, ext, "TraversedNodes", top, ": 0"); top += vert_space;
1966	initOverlayElement(&mHierarchyNodesInfo, ext, "HierarchyNodes", top, ": 0"); top += vert_space;
1967	initOverlayElement(&mRenderedNodesInfo, ext, "RenderedNodes", top, ": 0"); top += vert_space;
1968	initOverlayElement(&mObjectsCountInfo, ext, "ObjectsCount", top, ": 0"); top += vert_space;
1969	initOverlayElement(&mQueriesIssuedInfo, ext, "QueriesIssued", top, ": 0"); top += vert_space;
1970
1971	OverlayElement *visPanel = OverlayManager::getSingleton().
1972	getOverlayElement("Example/Visibility/VisibilityStatsPanel");
1973
1974	visPanel->setHeight(top + border_height);
1975	}
1976	//-----------------------------------------------------------------------
1977	void TerrainFrameListener::initQueryOverlay()
1978	{
1979	const int border_height = 10;
1980	const int vert_space = 15;
1981
1982	//-- visibility culling stats overlay
1983	int top = border_height + 25;
1984
1985	const String ext = "Example/Visibility/Query/";
1986
1987	initOverlayElement(&mQueryTypeInfo , ext, "QueryType", top, ": 0"); top += vert_space;
1988
1989	initOverlayElement(&mQueryVisibleNodesInfo , ext, "VisibleNodes", top, ": 0"); top += vert_space;
1990	initOverlayElement(&mQueryVisibleGeometryInfo , ext, "VisibleGeometry", top, ": 0"); top += vert_space;
1991	initOverlayElement(&mQueryVisiblePatchInfo , ext, "VisiblePatches", top, ": 0"); top += vert_space;
1992
1993	initOverlayElement(&mQueryNodeVisibilityInfo , ext, "NodeVisibility", top, ": 0"); top += vert_space;
1994	initOverlayElement(&mQueryGeometryVisibilityInfo , ext, "GeometryVisibility", top, ": 0"); top += vert_space;
1995	initOverlayElement(&mQueryPatchVisibilityInfo , ext, "PatchVisibility", top, ": 0"); top += vert_space;
1996
1997	OverlayElement *queryPanel =
1998	OverlayManager::getSingleton().getOverlayElement("Example/Visibility/Query/QueryPanel");
1999
2000	queryPanel->setHeight(top + border_height);
2001	}
2002	//-----------------------------------------------------------------------
2003	void TerrainFrameListener::setAlgorithm(const int algorithm)
2004	{
2005	mCurrentAlgorithm = algorithm;
2006	applyCurrentAlgorithm();
2007	}

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

Download in other formats: