Context Navigation

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

Revision 1268, 54.2 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	{LogManager::getSingleton().logMessage("here52");
1187	// HACK: no view cells for hilly terrain
1188	if (mApplication->msShowHillyTerrain)
1189	return;
1190	LogManager::getSingleton().logMessage("here533");
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	LogManager::getSingleton().logMessage("here5");
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("here7");
1208	LogManager::getSingleton().logMessage(d.str());
1209	}
1210
1211	LogManager::getSingleton().logMessage("here82");
1212	mLoadingOverlay->hide();
1213	}
1214
1215	if (mUseViewCells)
1216	mViewCellsInfo->setCaption(": on");
1217	else
1218	mViewCellsInfo->setCaption(": off");
1219
1220	mSceneMgr->setOption("UseViewCells", &mUseViewCells);
1221	}
1222	//-----------------------------------------------------------------------
1223	void TerrainFrameListener::toggleUseVisibilityFilter()
1224	{
1225	mUseVisibilityFilter = !mUseVisibilityFilter;
1226	mSceneMgr->setOption("UseVisibilityFilter", &mUseVisibilityFilter);
1227	}
1228	//-----------------------------------------------------------------------
1229	void TerrainFrameListener::toggleUseDepthPass()
1230	{
1231	mUseDepthPass = !mUseDepthPass;
1232
1233	mSceneMgr->setOption("UseDepthPass", &mUseDepthPass);
1234
1235	if (mUseDepthPass)
1236	{
1237	mUseDepthPassInfo->setCaption(": true");
1238	}
1239	else
1240	{
1241	mUseDepthPassInfo->setCaption(": false");
1242	}
1243	}
1244	//-----------------------------------------------------------------------
1245	void TerrainFrameListener::toggleShowViz()
1246	{
1247	mVisualizeCulledNodes = mShowVisualization = !mShowVisualization;
1248
1249	// create viewport with priority VIZ_VIEWPORT_Z_ORDER:
1250	// will be rendered over standard viewport
1251	if (mShowVisualization)
1252	{
1253	Viewport *vizvp = mWindow->addViewport(mVizCamera,
1254	VIZ_VIEWPORT_Z_ORDER, 0.6, 0.6, 0.4, 0.4);
1255
1256	vizvp->setBackgroundColour(ColourValue(0.0, 0.3, 0.2, 1));
1257
1258	vizvp->setOverlaysEnabled(false);
1259	// Alter the camera aspect ratio to match the viewport
1260	mVizCamera->setAspectRatio(Real(vizvp->getActualWidth()) /
1261	Real(vizvp->getActualHeight()));
1262
1263	mSceneMgr->setOption("VisualizeCulledNodes", &mVisualizeCulledNodes);
1264	//vizvp->setClearEveryFrame(false);
1265
1266	// Create a skyplane (for visualization background)
1267	/*
1268	Plane plane;
1269	plane.d = -1000;
1270	plane.normal = Vector3::UNIT_Y;
1271	mSceneMgr->setSkyPlane(true, plane, "Examples/TransparentTest", 4000, 75, false);
1272	*/
1273	}
1274	else
1275	{
1276	// remove visualization viewport
1277	mWindow->removeViewport(VIZ_VIEWPORT_Z_ORDER);
1278
1279	// octree bounding boxes are shown for visualization purpose, reset now
1280	mSceneMgr->setOption("ShowOctree", &mShowOctree);
1281	}
1282	}
1283	//-----------------------------------------------------------------------
1284	void TerrainFrameListener::toggleShowShadows()
1285	{
1286	mShowShadows = !mShowShadows;
1287
1288	mSunLight->setCastShadows(mShowShadows);
1289
1290	if (mShowShadows)
1291	{
1292	mSceneMgr->setShadowTechnique(SHADOWTYPE_TEXTURE_MODULATIVE);
1293	//mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_MODULATIVE);
1294	//mSceneMgr->setShadowTechnique(SHADOWTYPE_STENCIL_ADDITIVE);
1295	}
1296	else
1297	{
1298	mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
1299	}
1300
1301	}
1302	//-----------------------------------------------------------------------
1303	void TerrainFrameListener::nextNodeVizMode()
1304	{
1305	mNodeVizMode = (mNodeVizMode + 1) % NODEVIZ_MODES_NUM;
1306
1307	bool renderNodesForViz = (mNodeVizMode == NODEVIZ_RENDER_NODES) \|\|
1308	(mNodeVizMode == NODEVIZ_RENDER_NODES_AND_CONTENT);
1309	bool renderNodesContentForViz = (mNodeVizMode == NODEVIZ_RENDER_NODES_AND_CONTENT);
1310	//bool renderNodesContentForViz = mNodeVizMode == NODEVIZ_RENDER_GEOMETRY;
1311
1312	mSceneMgr->setOption("RenderNodesForViz", &renderNodesForViz);
1313	mSceneMgr->setOption("RenderNodesContentForViz", &renderNodesContentForViz);
1314	}
1315	//-----------------------------------------------------------------------
1316	void TerrainFrameListener::keyPressed(KeyEvent* e)
1317	{
1318	// hide exact visibility query overlay
1319	if (mShowQueryStats)
1320	{
1321	mQueryOverlay->hide();
1322	mShowQueryStats = false;
1323	}
1324
1325	switch(e->getKey())
1326	{
1327	case KC_ESCAPE:
1328	mShutdownRequested = true;
1329	e->consume();
1330	return;
1331
1332	case KC_SPACE:
1333	nextAlgorithm();
1334	break;
1335
1336	case KC_F:
1337	nextFilter();
1338	break;
1339	case KC_R:
1340	nextSceneDetailLevel();
1341	break;
1342	case KC_P:
1343	toggleDisplayCameraDetails();
1344	break;
1345	case KC_G:
1346	mTestGeometryForVisibleLeaves = !mTestGeometryForVisibleLeaves;
1347	setTestGeometryForVisibleLeaves(mTestGeometryForVisibleLeaves);
1348	break;
1349	case KC_T:
1350	toggleShowOctree();
1351	break;
1352	case KC_X:
1353	toggleUseDepthPass();
1354	break;
1355	case KC_H:
1356	toggleShowShadows();
1357	break;
1358
1359	case KC_I:
1360	mUseItemBuffer = !mUseItemBuffer;
1361	break;
1362
1363	case KC_C:
1364
1365	if (mItemBufferMode != GtpVisibility::QueryManager::GEOMETRY_VISIBILITY)
1366	mItemBufferMode = GtpVisibility::QueryManager::GEOMETRY_VISIBILITY;
1367	else
1368	mItemBufferMode = GtpVisibility::QueryManager::PATCH_VISIBILITY;
1369
1370	break;
1371
1372	case KC_SUBTRACT:
1373	changeThreshold(-10);
1374	break;
1375	case KC_ADD:
1376	changeThreshold(10);
1377	break;
1378
1379	//-- visualization
1380	case KC_1:
1381	toggleShowViz();
1382	break;
1383	case KC_2:
1384	nextNodeVizMode();
1385	break;
1386
1387	case KC_F2:
1388	mStatsOn = !mStatsOn;
1389	showStats(mStatsOn);
1390	break;
1391	case KC_F3:
1392	nextAppState();
1393	break;
1394	case KC_F4:
1395	toggleRecord();
1396	break;
1397	#if USE_PERFHUD
1398	case KC_F1:
1399	toggleShowHelp();
1400	break;
1401
1402	case KC_F5:
1403	applyVisibilityQuery(false, mShiftPressed, mUseItemBuffer);
1404	break;
1405
1406	case KC_F6:
1407	applyVisibilityQuery(true, mShiftPressed, mUseItemBuffer);
1408	break;
1409
1410	case KC_F7:
1411	setObjectType(++ mCurrentObjectType);
1412	break;
1413	#endif
1414	case KC_F8:
1415	mApplication->generateScene(500, mCurrentObjectType);
1416	break;
1417	case KC_F9:
1418	mUseAnimation = !mUseAnimation;
1419	break;
1420
1421	case KC_F10:
1422	mRecordVideo = !mRecordVideo;
1423
1424	case KC_F11:
1425	takeScreenshot();
1426	break;
1427	case KC_7:
1428	mTerrainContentGenerator->WriteObjects(objects_out_filename);
1429	break;
1430	case KC_8:
1431	changeAssumedVisibility(-5);
1432	// changeAssumedVisibility(-500);
1433	break;
1434	case KC_9:
1435	// changeAssumedVisibility(500);
1436	changeAssumedVisibility(5);
1437	break;
1438	case KC_LSHIFT:
1439	mShiftPressed = true;
1440	break;
1441	case KC_DELETE:
1442	mDeleteObjects = true;
1443	break;
1444	case KC_M: // hack for recording demo using precomputed fps
1445	mRecordDemo = !mRecordDemo;
1446	break;
1447	case KC_E: // hack for recording demo using precomputed fps
1448	mSavePrecomputedFps = !mSavePrecomputedFps;
1449	break;
1450	case KC_O:
1451	switchMouseMode();
1452	break;
1453	case KC_V:
1454	toggleUseViewCells();
1455	break;
1456	case KC_Q:
1457	toggleUseVisibilityFilter();
1458	break;
1459	//KEY_PRESSED(KC_F3, 0.3, writeFrames());
1460	//KEY_PRESSED(KC_F4, 0.3, loadFrames());
1461	default:
1462	break;
1463	}
1464
1465	CEGUI::System::getSingleton().injectKeyDown(e->getKey());
1466	CEGUI::System::getSingleton().injectChar(e->getKeyChar());
1467	e->consume();
1468	}
1469	//-----------------------------------------------------------------------
1470	void TerrainFrameListener::keyReleased(KeyEvent* e)
1471	{
1472	if (e->getKey() == KC_LSHIFT)
1473	{
1474	mShiftPressed = false;
1475	}
1476
1477	CEGUI::System::getSingleton().injectKeyUp(e->getKey());
1478	e->consume();
1479	}
1480	//-----------------------------------------------------------------------
1481	void TerrainFrameListener::keyClicked(KeyEvent* e)
1482	{
1483	// Do nothing
1484	e->consume();
1485	}
1486	//-----------------------------------------------------------------------
1487	void TerrainFrameListener::addFrameInfo(FrameInfoContainer &frameInfos,
1488	SceneNode *camNode,
1489	Real timeElapsed)
1490	{
1491	frame_info info;
1492
1493	info.orientation = mCamNode->getOrientation();
1494	info.position = mCamNode->getPosition();
1495	info.timeElapsed = timeElapsed;
1496	info.fps = mWindow->getStatistics().lastFPS;
1497
1498	frameInfos.push_back(info);
1499	}
1500	//-----------------------------------------------------------------------
1501	void TerrainFrameListener::setCurrentFrameInfo(const Real timeElapsed)
1502	{
1503	//-- find current frame relative to elapsed frame time
1504	mReplayTimeElapsed -= timeElapsed;
1505
1506	while ((mReplayTimeElapsed <= 0) && (mCurrentFrame < (int)mFrameInfo.size() - 1))
1507	{
1508	mReplayTimeElapsed += mFrameInfo[mCurrentFrame ++].timeElapsed;
1509	}
1510
1511
1512	// TODO: crashes here if recording / replaying on the same time!!
1513	const frame_info new_frame = mFrameInfo[mCurrentFrame];
1514	const frame_info old_frame = mFrameInfo[mCurrentFrame - 1];
1515
1516	//-- interpolate frames
1517	Real factor = 1;
1518
1519	if (old_frame.timeElapsed > 0)
1520	{
1521	factor = mReplayTimeElapsed / old_frame.timeElapsed;
1522	}
1523
1524	const Vector3 camPos = old_frame.position + factor
1525	* (new_frame.position - old_frame.position);
1526
1527	// interpolate the orientation
1528	const Quaternion camOrienation =
1529	Quaternion::Slerp(factor, old_frame.orientation, new_frame.orientation, true);
1530
1531	// HACK for demo: interpolate precomputed fps
1532	mPrecomputedFps = old_frame.fps + factor * (new_frame.fps - old_frame.fps);
1533
1534	mCamNode->setPosition(camPos);
1535	mCamNode->setOrientation(camOrienation);
1536
1537	// stop replaying after one full walkthrough
1538	if (mCurrentFrame == (int)mFrameInfo.size() - 1)
1539	{
1540	nextAppState();
1541	}
1542	}
1543	//-----------------------------------------------------------------------
1544	bool TerrainFrameListener::processUnbufferedKeyInput(const FrameEvent& evt)
1545	{
1546	bool cursorPressed = false;
1547
1548	/* Move camera forward by keypress. */
1549	if (mInputDevice->isKeyDown(KC_UP) \|\| mInputDevice->isKeyDown(KC_W))
1550	{
1551	mTranslateVector.z = -mMoveScale;
1552	cursorPressed = true;
1553	}
1554	/* Move camera backward by keypress. */
1555	if (mInputDevice->isKeyDown(KC_DOWN) \|\| mInputDevice->isKeyDown(KC_S))
1556	{
1557	mTranslateVector.z = mMoveScale;
1558	cursorPressed = true;
1559	}
1560
1561	if (mInputDevice->isKeyDown(KC_A))
1562	{
1563	mTranslateVector.x -= mMoveScale;
1564	mTranslateVector.y += mMoveScale;
1565
1566	cursorPressed = true;
1567	}
1568
1569	if (mInputDevice->isKeyDown(KC_D))
1570	{
1571	mTranslateVector.x += mMoveScale;
1572	mTranslateVector.y -= mMoveScale;
1573
1574	cursorPressed = true;
1575	}
1576
1577	if (mInputDevice->isKeyDown(KC_RIGHT))
1578	{
1579	mCamNode->yaw(-mRotScale);
1580	cursorPressed = true;
1581	}
1582
1583	if (mInputDevice->isKeyDown(KC_LEFT))
1584	{
1585	mCamNode->yaw(mRotScale);
1586	cursorPressed = true;
1587	}
1588	// visualization camera
1589	if (mInputDevice->isKeyDown(KC_3))
1590	{
1591	zoomVizCamera(50);
1592	}
1593	if (mInputDevice->isKeyDown(KC_4))
1594	{
1595	zoomVizCamera(-50);
1596	}
1597
1598	if (mInputDevice->isKeyDown(KC_5))
1599	{
1600	changeVizScale(-1);
1601	}
1602
1603	if (mInputDevice->isKeyDown(KC_6))
1604	{
1605	changeVizScale(1);
1606	}
1607
1608	// show the results
1609	if (cursorPressed && mShowQueryStats)
1610	{
1611	mQueryOverlay->hide();
1612	mShowQueryStats = false;
1613	}
1614
1615	// Return true to continue rendering
1616	return true;
1617	}
1618	//-----------------------------------------------------------------------
1619	void TerrainFrameListener::nextFilter()
1620	{
1621	switch (mFiltering)
1622	{
1623	case TFO_BILINEAR:
1624	mFiltering = TFO_TRILINEAR;
1625	mAniso = 1;
1626	break;
1627	case TFO_TRILINEAR:
1628	mFiltering = TFO_ANISOTROPIC;
1629	mAniso = 8;
1630	break;
1631	case TFO_ANISOTROPIC:
1632	mFiltering = TFO_BILINEAR;
1633	mAniso = 1;
1634	break;
1635	default:
1636	break;
1637	}
1638
1639	MaterialManager::getSingleton().setDefaultTextureFiltering(mFiltering);
1640	MaterialManager::getSingleton().setDefaultAnisotropy(mAniso);
1641
1642	// reload stats
1643	showStats(mStatsOn);
1644	}
1645	//-----------------------------------------------------------------------
1646	void TerrainFrameListener::nextSceneDetailLevel()
1647	{
1648	#if OGRE_103
1649	mSceneDetailIndex = (mSceneDetailIndex + 1) % 3;
1650	switch (mSceneDetailIndex)
1651	{
1652	case 0:
1653	mCamera->setDetailLevel(SDL_SOLID);
1654	break;
1655	case 1:
1656	mCamera->setDetailLevel(SDL_WIREFRAME);
1657	break;
1658	case 2:
1659	mCamera->setDetailLevel(SDL_POINTS);
1660	break;
1661	}
1662	#endif
1663	}
1664	//-----------------------------------------------------------------------
1665	void TerrainFrameListener::takeVideoFrame(std::ofstream &ofstr)
1666	{
1667	char name[50];
1668
1669	sprintf(name, "frame_%05d.tga", ++mNumVideoFrames);
1670	mWindow->writeContentsToFile(name);
1671	//mWindow->setDebugText(String("Wrote ") + name);
1672
1673	ofstr << name << "\n";
1674	}
1675	//-----------------------------------------------------------------------
1676	void TerrainFrameListener::takeScreenshot()
1677	{
1678	char name[50];
1679
1680	sprintf(name, "screenshot_%05d.png", ++mNumScreenShots);
1681	mWindow->writeContentsToFile(name);
1682	//mWindow->setDebugText(String("Wrote ") + name);
1683	}
1684	//-----------------------------------------------------------------------
1685	void TerrainFrameListener::toggleDisplayCameraDetails()
1686	{
1687	mDisplayCameraDetails = !mDisplayCameraDetails;
1688
1689	if (!mDisplayCameraDetails)
1690	{
1691	mWindow->setDebugText("");
1692	}
1693	}
1694	//-----------------------------------------------------------------------
1695	void TerrainFrameListener::showStats(bool show)
1696	{
1697	if (mDebugOverlay && mCullStatsOverlay)
1698	{
1699	if (show)
1700	{
1701	mDebugOverlay->show();
1702	mCullStatsOverlay->show();
1703	}
1704	else
1705	{
1706	mDebugOverlay->hide();
1707	mCullStatsOverlay->hide();
1708	}
1709	}
1710	}
1711
1712	//-----------------------------------------------------------------------
1713	void TerrainFrameListener::toggleShowHelp()
1714	{
1715	mShowHelp = !mShowHelp;
1716
1717	if (mShowHelp)
1718	{
1719	mHelpOverlay->show();
1720	}
1721	else
1722	{
1723	mHelpOverlay->hide();
1724	}
1725	}
1726	//-----------------------------------------------------------------------
1727	void TerrainFrameListener::initOverlayElement(OverlayElement **elInfo, String ext,
1728	String name, int top, String caption)
1729	{
1730	OverlayElement *el =
1731	OverlayManager::getSingleton().getOverlayElement(ext + name);
1732
1733	(*elInfo) = OverlayManager::getSingleton().getOverlayElement(ext + name + "Info");
1734	(*elInfo)->setCaption(caption);
1735
1736	el->setTop(top);
1737	(*elInfo)->setTop(top);
1738	}
1739	//-----------------------------------------------------------------------
1740	void TerrainFrameListener::initHelpOverlayElement(String name, int top)
1741	{
1742	OverlayElement *el = OverlayManager::getSingleton().getOverlayElement(
1743	"Example/Visibility/Help/" + name);
1744
1745	el->setTop(top);
1746	}
1747	//-----------------------------------------------------------------------
1748	void TerrainFrameListener::initHelpOverlay()
1749	{
1750	const int vert_space = 15;
1751	int top = 30;
1752
1753	initHelpOverlayElement("ShowHelp", top); top += vert_space;
1754	initHelpOverlayElement("Stats", top); top += vert_space;
1755	initHelpOverlayElement("AppState", top); top += vert_space;
1756	initHelpOverlayElement("Recorded", top); top += vert_space;
1757	initHelpOverlayElement("Animation", top); top += vert_space;
1758	initHelpOverlayElement("Video", top); top += vert_space;
1759	initHelpOverlayElement("Screenshots", top); top += vert_space;
1760	initHelpOverlayElement("WriteOut", top); top += vert_space;
1761
1762
1763	top +=vert_space;
1764	initHelpOverlayElement("SceneDetail", top); top += vert_space;
1765	initHelpOverlayElement("DisplayCameraDetails", top); top += vert_space;
1766	initHelpOverlayElement("DisplayOctree", top); top += vert_space;
1767	initHelpOverlayElement("UseShadows", top); top += vert_space;
1768	initHelpOverlayElement("Filter", top); top += vert_space;
1769
1770	//-- visualization
1771	top += vert_space;
1772	initHelpOverlayElement("VizSection", top); top += vert_space;
1773	initHelpOverlayElement("Viz", top); top += vert_space;
1774	initHelpOverlayElement("NextVizMode", top); top += vert_space;
1775	initHelpOverlayElement("ZoomViz", top); top += vert_space;
1776
1777
1778	//-- visibility queries
1779	top += vert_space;
1780	initHelpOverlayElement("VisQuery", top); top += vert_space;
1781	initHelpOverlayElement("FromCameraQuery", top); top += vert_space;
1782	initHelpOverlayElement("FromPointQuery", top); top += vert_space;
1783	initHelpOverlayElement("QueryType", top); top += vert_space;
1784	initHelpOverlayElement("QueryTarget", top); top += vert_space;
1785
1786	//-- object generation
1787	top += vert_space;
1788	initHelpOverlayElement("SceneObjects", top); top += vert_space;
1789	initHelpOverlayElement("PlaceObjects", top); top += vert_space;
1790	initHelpOverlayElement("GenerateObjects", top); top += vert_space;
1791	initHelpOverlayElement("RemoveObjects", top); top += vert_space;
1792	initHelpOverlayElement("DropObject", top); top += vert_space;
1793
1794	OverlayElement *helpPanel = OverlayManager::getSingleton().getOverlayElement(
1795	"Example/Visibility/Help/HelpPanel");
1796
1797	helpPanel->setHeight(top + 10);
1798	}
1799	//-----------------------------------------------------------------------
1800	void TerrainFrameListener::initVisStatsOverlay()
1801	{
1802	const int border_height = 10;
1803	const int vert_space = 15;
1804
1805	//-- visibility culling stats overlay
1806	int top = border_height;
1807
1808	String ext = "Example/Visibility/";
1809
1810	initOverlayElement(&mAlgorithmInfo, ext, "Algorithm", top,
1811	": " + msAlgorithmCaptions[mCurrentAlgorithm]); top += vert_space;
1812
1813	initOverlayElement(&mThresholdInfo, ext, "Threshold", top, ": 0"); top += vert_space;
1814	initOverlayElement(&mTestGeometryForVisibleLeavesInfo, ext,
1815	"TestGeometryForVisibleLeaves", top, ": true"); top += vert_space;
1816	initOverlayElement(&mUseDepthPassInfo, ext, "UseDepthPass", top, ": false"); top += vert_space;
1817	initOverlayElement(&mAssumedVisibilityInfo, ext, "AssumedVisibility", top, ": 0"); top += vert_space;
1818	initOverlayElement(&mCurrentObjectTypeInfo, ext, "CurrentObjectType", top, ": "); top += vert_space;
1819	initOverlayElement(&mViewCellsInfo, ext, "ViewCells", top, ": "); top += vert_space;
1820	//initOverlayElement(&mHelpInfo, ext, "Help", top, ": "); top += vert_space;
1821
1822	OverlayElement *optionsPanel = OverlayManager::getSingleton().
1823	getOverlayElement("Example/Visibility/VisibilityPanel");
1824
1825	optionsPanel->setHeight(top + border_height);
1826
1827	top = border_height;
1828	//ext = "Example/Visibility/";
1829	initOverlayElement(&mFrustumCulledNodesInfo, ext, "FrustumCulledNodes", top, ": 0"); top += vert_space;
1830	initOverlayElement(&mQueryCulledNodesInfo, ext, "QueryCulledNodes", top, ": 0"); top += vert_space;
1831	initOverlayElement(&mTraversedNodesInfo, ext, "TraversedNodes", top, ": 0"); top += vert_space;
1832	initOverlayElement(&mHierarchyNodesInfo, ext, "HierarchyNodes", top, ": 0"); top += vert_space;
1833	initOverlayElement(&mRenderedNodesInfo, ext, "RenderedNodes", top, ": 0"); top += vert_space;
1834	initOverlayElement(&mObjectsCountInfo, ext, "ObjectsCount", top, ": 0"); top += vert_space;
1835	initOverlayElement(&mQueriesIssuedInfo, ext, "QueriesIssued", top, ": 0"); top += vert_space;
1836
1837	OverlayElement *visPanel = OverlayManager::getSingleton().
1838	getOverlayElement("Example/Visibility/VisibilityStatsPanel");
1839
1840	visPanel->setHeight(top + border_height);
1841	}
1842	//-----------------------------------------------------------------------
1843	void TerrainFrameListener::initQueryOverlay()
1844	{
1845	const int border_height = 10;
1846	const int vert_space = 15;
1847
1848	//-- visibility culling stats overlay
1849	int top = border_height + 25;
1850
1851	String ext = "Example/Visibility/Query/";
1852
1853	initOverlayElement(&mQueryTypeInfo , ext, "QueryType", top, ": 0"); top += vert_space;
1854
1855	initOverlayElement(&mQueryVisibleNodesInfo , ext, "VisibleNodes", top, ": 0"); top += vert_space;
1856	initOverlayElement(&mQueryVisibleGeometryInfo , ext, "VisibleGeometry", top, ": 0"); top += vert_space;
1857	initOverlayElement(&mQueryVisiblePatchInfo , ext, "VisiblePatches", top, ": 0"); top += vert_space;
1858
1859	initOverlayElement(&mQueryNodeVisibilityInfo , ext, "NodeVisibility", top, ": 0"); top += vert_space;
1860	initOverlayElement(&mQueryGeometryVisibilityInfo , ext, "GeometryVisibility", top, ": 0"); top += vert_space;
1861	initOverlayElement(&mQueryPatchVisibilityInfo , ext, "PatchVisibility", top, ": 0"); top += vert_space;
1862
1863
1864	OverlayElement *queryPanel = OverlayManager::getSingleton().
1865	getOverlayElement("Example/Visibility/Query/QueryPanel");
1866
1867	queryPanel->setHeight(top + border_height);
1868	}

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

Download in other formats: