Context Navigation

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

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

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

Download in other formats: