ruby-ogre 0.0.5-x86-linux → 0.1.0-x86-linux

data/deps/include/OGRE/RenderSystems/GL/OgreGLTextureManager.h

@@ -1,69 +0,0 @@
-/*
------------------------------------------------------------------------------
-This source file is part of OGRE
-    (Object-oriented Graphics Rendering Engine)
-For the latest info, see http://www.ogre3d.org/
-
-Copyright (c) 2000-2012 Torus Knot Software Ltd
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
------------------------------------------------------------------------------
-*/
-
-#ifndef __GLTextureManager_H__
-#define __GLTextureManager_H__
-
-#include "OgreGLPrerequisites.h"
-#include "OgreTextureManager.h"
-#include "OgreGLTexture.h"
-#include "OgreGLSupport.h"
-
-namespace Ogre {
-    /** GL-specific implementation of a TextureManager */
-    class _OgreGLExport GLTextureManager : public TextureManager
-    {
-    public:
-        GLTextureManager(GLSupport& support);
-        virtual ~GLTextureManager();
-
-		GLuint getWarningTextureID() { return mWarningTextureID; }
-
-		/// @copydoc TextureManager::getNativeFormat
-		PixelFormat getNativeFormat(TextureType ttype, PixelFormat format, int usage);
-
-        /// @copydoc TextureManager::isHardwareFilteringSupported
-        bool isHardwareFilteringSupported(TextureType ttype, PixelFormat format, int usage,
-            bool preciseFormatOnly = false);
-
-    protected:
-		friend class GLRenderSystem;
-
-        /// @copydoc ResourceManager::createImpl
-        Resource* createImpl(const String& name, ResourceHandle handle, 
-            const String& group, bool isManual, ManualResourceLoader* loader, 
-            const NameValuePairList* createParams);
-
-		/// Internal method to create a warning texture (bound when a texture unit is blank)
-		void createWarningTexture();
-
-        GLSupport& mGLSupport;
-		GLuint mWarningTextureID;
-    };
-}
-#endif

data/deps/include/OGRE/Sample.h

@@ -1,330 +0,0 @@
-/*
- -----------------------------------------------------------------------------
- This source file is part of OGRE
- (Object-oriented Graphics Rendering Engine)
- For the latest info, see http://www.ogre3d.org/
- 
- Copyright (c) 2000-2012 Torus Knot Software Ltd
- 
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
- 
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
- 
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE.
- -----------------------------------------------------------------------------
- */
-#ifndef __Sample_H__
-#define __Sample_H__
-
-#include "Ogre.h"
-#include <iostream>
-
-#include "OIS.h"
-
-#ifdef USE_RTSHADER_SYSTEM
-#	include "OgreRTShaderSystem.h"
-#endif //USE_RTSHADER_SYSTEM
-
-#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS
-#	include "macUtils.h"
-#endif
-
-#if OGRE_PLATFORM == OGRE_PLATFORM_NACL && !defined(USE_RTSHADER_SYSTEM)
-#   define USE_RTSHADER_SYSTEM
-#include "OgreShaderGenerator.h"
-#endif
-
-
-namespace OgreBites
-{
-	class FileSystemLayer;
-
-	/*=============================================================================
-	| Base class responsible for everything specific to one sample.
-	| Designed to be subclassed for each sample.
-	=============================================================================*/
-	class Sample : public Ogre::GeneralAllocatedObject
-    {
-    public:
-
-		/*=============================================================================
-		| Utility comparison structure for sorting samples using SampleSet.
-		=============================================================================*/
-		struct Comparer
-		{
-			bool operator() (Sample* a, Sample* b)
-			{
-				Ogre::NameValuePairList::iterator aTitle = a->getInfo().find("Title");
-				Ogre::NameValuePairList::iterator bTitle = b->getInfo().find("Title");
-				
-				if (aTitle != a->getInfo().end() && bTitle != b->getInfo().end())
-					return aTitle->second.compare(bTitle->second) < 0;
-				else return false;
-			}
-		};
-
-#ifdef USE_RTSHADER_SYSTEM
-		Sample() : mShaderGenerator(0)
-#else
-		Sample()
-#endif
-        {
-			mRoot = Ogre::Root::getSingletonPtr();
-			mWindow = 0;
-			mSceneMgr = 0;
-			mDone = true;
-			mResourcesLoaded = false;
-			mContentSetup = false;
-
-#if (OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS) || (OGRE_PLATFORM == OGRE_PLATFORM_ANDROID)
-			mMouse = 0;
-			mAccelerometer = 0;
-#else
-			mKeyboard = 0;
-			mMouse = 0;
-#endif
-			mFSLayer = 0;
-        }
-
-		virtual ~Sample() {}
-
-		/*-----------------------------------------------------------------------------
-		| Retrieves custom sample info.
-		-----------------------------------------------------------------------------*/
-		Ogre::NameValuePairList& getInfo()
-		{
-			return mInfo;
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Tests to see if target machine meets any special requirements of
-		| this sample. Signal a failure by throwing an exception.
-		-----------------------------------------------------------------------------*/
-		virtual void testCapabilities(const Ogre::RenderSystemCapabilities* caps) {}
-
-		/*-----------------------------------------------------------------------------
-		| If this sample requires a specific render system to run, this method
-		| will be used to return its name.
-		-----------------------------------------------------------------------------*/
-		virtual Ogre::String getRequiredRenderSystem()
-		{
-			return "";
-		}
-
-		/*-----------------------------------------------------------------------------
-		| If this sample requires specific plugins to run, this method will be
-		| used to return their names.
-		-----------------------------------------------------------------------------*/
-		virtual Ogre::StringVector getRequiredPlugins()
-		{
-			return Ogre::StringVector();
-		}
-
-		Ogre::SceneManager* getSceneManager()
-		{
-			return mSceneMgr;
-		}
-
-		bool isDone()
-		{
-			return mDone;
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Sets up a sample. Used by the SampleContext class. Do not call directly.
-		-----------------------------------------------------------------------------*/
-#if (OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS) || (OGRE_PLATFORM == OGRE_PLATFORM_ANDROID)
-		virtual void _setup(Ogre::RenderWindow* window, OIS::MultiTouch* mouse, FileSystemLayer* fsLayer)
-#else
-		virtual void _setup(Ogre::RenderWindow* window, OIS::Keyboard* keyboard, OIS::Mouse* mouse, FileSystemLayer* fsLayer)
-#endif
-		{
-			// assign mRoot here in case Root was initialised after the Sample's constructor ran.
-			mRoot = Ogre::Root::getSingletonPtr();
-			mWindow = window;
-#if (OGRE_PLATFORM != OGRE_PLATFORM_APPLE_IOS) && (OGRE_PLATFORM != OGRE_PLATFORM_ANDROID)
-			mKeyboard = keyboard;
-#endif
-			mMouse = mouse;
-			mFSLayer = fsLayer;
-
-			locateResources();
-			createSceneManager();
-			setupView();
-
-			loadResources();
-			mResourcesLoaded = true;
-			setupContent();
-			mContentSetup = true;
-
-			mDone = false;
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Shuts down a sample. Used by the SampleContext class. Do not call directly.
-		-----------------------------------------------------------------------------*/
-		virtual void _shutdown()
-
-		{
-			if (mContentSetup)
-                cleanupContent();
-			if (mSceneMgr)
-                mSceneMgr->clearScene();
-			mContentSetup = false;
-
-			if (mResourcesLoaded)
-                unloadResources();
-			mResourcesLoaded = false;
-			if (mSceneMgr) 
-			{
-#ifdef USE_RTSHADER_SYSTEM
-				mShaderGenerator->removeSceneManager(mSceneMgr);
-#endif
-				mRoot->destroySceneManager(mSceneMgr);				
-			}
-			mSceneMgr = 0;
-
-			mDone = true;
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Actions to perform when the context stops sending frame listener events
-		| and input device events to this sample.
-		-----------------------------------------------------------------------------*/
-		virtual void paused() {}
-
-		/*-----------------------------------------------------------------------------
-		| Actions to perform when the context continues sending frame listener
-		| events and input device events to this sample.
-		-----------------------------------------------------------------------------*/
-		virtual void unpaused() {}
-
-		/*-----------------------------------------------------------------------------
-		| Saves the sample state. Optional. Used during reconfiguration.
-		-----------------------------------------------------------------------------*/
-		virtual void saveState(Ogre::NameValuePairList& state) {}
-
-		/*-----------------------------------------------------------------------------
-		| Restores the sample state. Optional. Used during reconfiguration.
-		-----------------------------------------------------------------------------*/
-		virtual void restoreState(Ogre::NameValuePairList& state) {}
-
-		// callback interface copied from various listeners to be used by SampleContext
-
-		virtual bool frameStarted(const Ogre::FrameEvent& evt) { return true; }
-		virtual bool frameRenderingQueued(const Ogre::FrameEvent& evt) { return true; }
-		virtual bool frameEnded(const Ogre::FrameEvent& evt) { return true; }
-		virtual void windowMoved(Ogre::RenderWindow* rw) {}
-		virtual void windowResized(Ogre::RenderWindow* rw) {}
-		virtual bool windowClosing(Ogre::RenderWindow* rw) { return true; }
-		virtual void windowClosed(Ogre::RenderWindow* rw) {}
-		virtual void windowFocusChange(Ogre::RenderWindow* rw) {}
-		virtual bool keyPressed(const OIS::KeyEvent& evt) { return true; }
-		virtual bool keyReleased(const OIS::KeyEvent& evt) { return true; }
-#if (OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS) || (OGRE_PLATFORM == OGRE_PLATFORM_ANDROID)
-		virtual bool touchMoved(const OIS::MultiTouchEvent& evt) { return true; }
-		virtual bool touchPressed(const OIS::MultiTouchEvent& evt) { return true; }
-		virtual bool touchReleased(const OIS::MultiTouchEvent& evt) { return true; }
-#else
-		virtual bool mouseMoved(const OIS::MouseEvent& evt) { return true; }
-		virtual bool mousePressed(const OIS::MouseEvent& evt, OIS::MouseButtonID id) { return true; }
-		virtual bool mouseReleased(const OIS::MouseEvent& evt, OIS::MouseButtonID id) { return true; }
-#endif
-
-    protected:
-
-		/*-----------------------------------------------------------------------------
-		| Finds sample-specific resources. No such effort is made for most samples,
-		| but this is useful for special samples with large, exclusive resources.
-		-----------------------------------------------------------------------------*/
-		virtual void locateResources() {}
-
-		/*-----------------------------------------------------------------------------
-		| Loads sample-specific resources. No such effort is made for most samples,
-		| but this is useful for special samples with large, exclusive resources.
-		-----------------------------------------------------------------------------*/
-		virtual void loadResources() {}
-
-		/*-----------------------------------------------------------------------------
-		| Creates a scene manager for the sample. A generic one is the default,
-		| but many samples require a special kind of scene manager.
-		-----------------------------------------------------------------------------*/
-		virtual void createSceneManager()
-		{
-			mSceneMgr = Ogre::Root::getSingleton().createSceneManager(Ogre::ST_GENERIC);
-#ifdef USE_RTSHADER_SYSTEM
-			mShaderGenerator->addSceneManager(mSceneMgr);
-#endif
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Sets up viewport layout and camera.
-		-----------------------------------------------------------------------------*/
-		virtual void setupView() {}
-
-		/*-----------------------------------------------------------------------------
-		| Sets up the scene (and anything else you want for the sample).
-		-----------------------------------------------------------------------------*/
-		virtual void setupContent() {}
-
-		/*-----------------------------------------------------------------------------
-		| Cleans up the scene (and anything else you used).
-		-----------------------------------------------------------------------------*/
-		virtual void cleanupContent() {}
-
-		/*-----------------------------------------------------------------------------
-		| Unloads sample-specific resources. My method here is simple and good
-		| enough for most small samples, but your needs may vary.
-		-----------------------------------------------------------------------------*/
-		virtual void unloadResources()
-		{
-			Ogre::ResourceGroupManager::ResourceManagerIterator resMgrs =
-			Ogre::ResourceGroupManager::getSingleton().getResourceManagerIterator();
-
-			while (resMgrs.hasMoreElements())
-			{
-				resMgrs.getNext()->unloadUnreferencedResources();
-			}
-		}	
-
-		Ogre::Root* mRoot;                // OGRE root object
-		Ogre::RenderWindow* mWindow;      // context render window
-#if (OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS) || (OGRE_PLATFORM == OGRE_PLATFORM_ANDROID)
-		OIS::MultiTouch* mMouse;          // context multitouch device
-		OIS::JoyStick* mAccelerometer;    // context accelerometer device
-#else
-		OIS::Keyboard* mKeyboard;         // context keyboard device
-		OIS::Mouse* mMouse;               // context mouse device
-#endif
-		FileSystemLayer* mFSLayer; 		  // file system abstraction layer
-		Ogre::SceneManager* mSceneMgr;    // scene manager for this sample
-		Ogre::NameValuePairList mInfo;    // custom sample info
-		bool mDone;                       // flag to mark the end of the sample
-		bool mResourcesLoaded;    // whether or not resources have been loaded
-		bool mContentSetup;       // whether or not scene was created
-#ifdef USE_RTSHADER_SYSTEM
-		Ogre::RTShader::ShaderGenerator*			mShaderGenerator;			// The Shader generator instance.
-    public:
-		void setShaderGenerator(Ogre::RTShader::ShaderGenerator* shaderGenerator) 
-		{ 
-			mShaderGenerator = shaderGenerator;
-		};
-#endif
-    };
-
-	typedef std::set<Sample*, Sample::Comparer> SampleSet;
-}
-
-#endif

data/deps/include/OGRE/SampleContext.h

@@ -1,874 +0,0 @@
-/*
- -----------------------------------------------------------------------------
- This source file is part of OGRE
- (Object-oriented Graphics Rendering Engine)
- For the latest info, see http://www.ogre3d.org/
- 
- Copyright (c) 2000-2012 Torus Knot Software Ltd
- 
- Permission is hereby granted, free of charge, to any person obtaining a copy
- of this software and associated documentation files (the "Software"), to deal
- in the Software without restriction, including without limitation the rights
- to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
- 
- The above copyright notice and this permission notice shall be included in
- all copies or substantial portions of the Software.
- 
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- THE SOFTWARE.
- -----------------------------------------------------------------------------
- */
-#ifndef __SampleContext_H__
-#define __SampleContext_H__
-
-#include "OgreLogManager.h"
-#include "OgrePlugin.h"
-#include "FileSystemLayerImpl.h"
-
-// Static plugins declaration section
-// Note that every entry in here adds an extra header / library dependency
-#ifdef OGRE_STATIC_LIB
-#  ifdef OGRE_BUILD_RENDERSYSTEM_GL
-#    define OGRE_STATIC_GL
-#  endif
-#  ifdef OGRE_BUILD_RENDERSYSTEM_GLES
-#    define OGRE_STATIC_GLES
-#    undef USE_RTSHADER_SYSTEM
-#  endif
-#  ifdef OGRE_BUILD_RENDERSYSTEM_GLES2
-#undef OGRE_STATIC_GLES
-#    define USE_RTSHADER_SYSTEM
-#    define OGRE_STATIC_GLES2
-#  endif
-#  if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
-#    ifdef OGRE_BUILD_RENDERSYSTEM_D3D9
-#		define OGRE_STATIC_Direct3D9
-#    endif
-// dx11 will only work on vista, so be careful about statically linking
-#    ifdef OGRE_BUILD_RENDERSYSTEM_D3D11
-#      define OGRE_STATIC_Direct3D11
-#    endif
-#  endif
-
-#  ifdef OGRE_BUILD_PLUGIN_BSP
-#  define OGRE_STATIC_BSPSceneManager
-#  endif
-#  ifdef OGRE_BUILD_PLUGIN_PFX
-#  define OGRE_STATIC_ParticleFX
-#  endif
-#  ifdef OGRE_BUILD_PLUGIN_CG
-#  define OGRE_STATIC_CgProgramManager
-#  endif
-
-#  ifdef OGRE_USE_PCZ
-#    ifdef OGRE_BUILD_PLUGIN_PCZ
-#    define OGRE_STATIC_PCZSceneManager
-#    define OGRE_STATIC_OctreeZone
-#    endif
-#  else
-#    ifdef OGRE_BUILD_PLUGIN_OCTREE
-#    define OGRE_STATIC_OctreeSceneManager
-#  endif
-#     endif
-#  include "OgreStaticPluginLoader.h"
-#endif
-
-#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE || OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS
-#include "macUtils.h"
-#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS
-#   ifdef __OBJC__
-#       import <UIKit/UIKit.h>
-#   endif
-#endif
-#endif
-
-#include "Sample.h"
-
-#include "OIS.h"
-
-namespace OgreBites
-{
-	/*=============================================================================
-	| Base class responsible for setting up a common context for samples.
-	| May be subclassed for specific sample types (not specific samples).
-	| Allows one sample to run at a time, while maintaining a sample queue.
-	=============================================================================*/
-	class SampleContext :
-		public Ogre::FrameListener,
-		public Ogre::WindowEventListener,
-#if (OGRE_PLATFORM != OGRE_PLATFORM_APPLE_IOS) && (OGRE_PLATFORM != OGRE_PLATFORM_ANDROID)
-		public OIS::KeyListener,
-		public OIS::MouseListener
-#else
-        public OIS::MultiTouchListener
-#endif
-	{
-	public:
-
-		SampleContext()
-		{
-			mFSLayer = OGRE_NEW_T(FileSystemLayerImpl, Ogre::MEMCATEGORY_GENERAL)(OGRE_VERSION_NAME);
-			mRoot = 0;
-			mWindow = 0;
-			mCurrentSample = 0;
-			mSamplePaused = false;
-			mFirstRun = true;
-			mLastRun = false;
-			mLastSample = 0;
-			mInputMgr = 0;
-#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS
-			mMouse = 0;
-			mAccelerometer = 0;
-#elif OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
-			mMouse = 0;
-			mKeyboard = 0;
-#else
-			mKeyboard = 0;
-			mMouse = 0;
-#endif
-		}
-
-		virtual ~SampleContext() 
-		{
-			OGRE_DELETE_T(mFSLayer, FileSystemLayer, Ogre::MEMCATEGORY_GENERAL);
-		}
-
-		virtual Ogre::RenderWindow* getRenderWindow()
-		{
-			return mWindow;
-		}
-
-		virtual Sample* getCurrentSample()
-		{
-			return mCurrentSample;
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Quits the current sample and starts a new one.
-		-----------------------------------------------------------------------------*/
-		virtual void runSample(Sample* s)
-		{
-#if OGRE_PROFILING
-            Ogre::Profiler* prof = Ogre::Profiler::getSingletonPtr();
-            if (prof)
-                prof->setEnabled(false);
-#endif
-
-			if (mCurrentSample)
-			{
-				mCurrentSample->_shutdown();    // quit current sample
-				mSamplePaused = false;          // don't pause the next sample
-			}
-
-			mWindow->removeAllViewports();                  // wipe viewports
-
-			if (s)
-			{
-                // retrieve sample's required plugins and currently installed plugins
-				Ogre::Root::PluginInstanceList ip = mRoot->getInstalledPlugins();
-				Ogre::StringVector rp = s->getRequiredPlugins();
-
-				for (Ogre::StringVector::iterator j = rp.begin(); j != rp.end(); j++)
-				{
-					bool found = false;
-					// try to find the required plugin in the current installed plugins
-					for (Ogre::Root::PluginInstanceList::iterator k = ip.begin(); k != ip.end(); k++)
-					{
-						if ((*k)->getName() == *j)
-						{
-							found = true;
-							break;
-						}
-					}
-					if (!found)  // throw an exception if a plugin is not found
-					{
-						Ogre::String desc = "Sample requires plugin: " + *j;
-						Ogre::String src = "SampleContext::runSample";
-						OGRE_EXCEPT(Ogre::Exception::ERR_NOT_IMPLEMENTED, desc, src);
-					}
-				}
-
-				// throw an exception if samples requires the use of another renderer
-				Ogre::String rrs = s->getRequiredRenderSystem();
-				if (!rrs.empty() && rrs != mRoot->getRenderSystem()->getName())
-				{
-					Ogre::String desc = "Sample only runs with renderer: " + rrs;
-					Ogre::String src = "SampleContext::runSample";
-					OGRE_EXCEPT(Ogre::Exception::ERR_INVALID_STATE, desc, src);
-				}
-
-				// test system capabilities against sample requirements
-				s->testCapabilities(mRoot->getRenderSystem()->getCapabilities());
-
-#if (OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS) || (OGRE_PLATFORM == OGRE_PLATFORM_ANDROID)
-				s->_setup(mWindow, mMouse, mFSLayer);   // start new sample
-#else
-				s->_setup(mWindow, mKeyboard, mMouse, mFSLayer);   // start new sample
-#endif
-            }
-#if OGRE_PROFILING
-            if (prof)
-                prof->setEnabled(true);
-#endif
-
-			mCurrentSample = s;
-		}
-
-		/*-----------------------------------------------------------------------------
-		| This function initializes the render system and resources.
-		-----------------------------------------------------------------------------*/
-		virtual void initApp( Sample* initialSample = 0 )
-		{
-#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS
-            createRoot();
-
-			if (!oneTimeConfig()) return;
-
-            if (!mFirstRun) mRoot->setRenderSystem(mRoot->getRenderSystemByName(mNextRenderer));
-
-            setup();
-
-            if (!mFirstRun) recoverLastSample();
-            else if (initialSample) runSample(initialSample);
-
-            mRoot->saveConfig();
-
-			Ogre::Root::getSingleton().getRenderSystem()->_initRenderTargets();
-
-			// Clear event times
-			Ogre::Root::getSingleton().clearEventTimes();
-#elif OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
-			createRoot();
-
-            setup();
-
-            if (!mFirstRun) recoverLastSample();
-            else if (initialSample) runSample(initialSample);
-
-            //mRoot->saveConfig();
-
-			Ogre::Root::getSingleton().getRenderSystem()->_initRenderTargets();
-
-			// Clear event times
-			Ogre::Root::getSingleton().clearEventTimes();
-
-#else
-			createRoot();
-#if OGRE_PLATFORM == OGRE_PLATFORM_NACL
-            mNextRenderer = mRoot->getAvailableRenderers()[0]->getName();
-#else
-			if (!oneTimeConfig()) return;
-#endif
-
-			// if the context was reconfigured, set requested renderer
-			if (!mFirstRun) mRoot->setRenderSystem(mRoot->getRenderSystemByName(mNextRenderer));
-
-			setup();
-
-			// restore the last sample if there was one or, if not, start initial sample
-			if (!mFirstRun) recoverLastSample();
-			else if (initialSample) runSample(initialSample);
-#endif
-		}
-
-
-		/*-----------------------------------------------------------------------------
-		| This function closes down the application - saves the configuration then 
-		| shutdowns.
-		-----------------------------------------------------------------------------*/
-		virtual void closeApp()
-		{
-#if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
-			shutdown();
-#else
-			mRoot->saveConfig();
-			shutdown();
-			if (mRoot) OGRE_DELETE mRoot;
-#ifdef OGRE_STATIC_LIB
-			mStaticPluginLoader.unload();
-#endif
-#endif
-
-		}
-
-		/*-----------------------------------------------------------------------------
-		| This function encapsulates the entire lifetime of the context.
-		-----------------------------------------------------------------------------*/
-#if OGRE_PLATFORM != OGRE_PLATFORM_NACL
-		virtual void go(Sample* initialSample = 0)
-		{
-#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS || ((OGRE_PLATFORM == OGRE_PLATFORM_APPLE) && __LP64__)
-            createRoot();
-
-			if (!oneTimeConfig()) return;
-
-            if (!mFirstRun) mRoot->setRenderSystem(mRoot->getRenderSystemByName(mNextRenderer));
-
-            setup();
-
-            if (!mFirstRun) recoverLastSample();
-            else if (initialSample) runSample(initialSample);
-
-            mRoot->saveConfig();
-#else
-			while (!mLastRun)
-			{
-				mLastRun = true;  // assume this is our last run
-
-				initApp(initialSample);
-        
-                if (mRoot->getRenderSystem() != NULL)
-                {
-				    mRoot->startRendering();    // start the render loop
-                }
-
-				closeApp();
-
-				mFirstRun = false;
-			}
-#endif
-		}
-#endif
-        
-		virtual bool isCurrentSamplePaused()
-		{
-			if (mCurrentSample) return mSamplePaused;
-			return false;
-		}
-
-		virtual void pauseCurrentSample()
-		{
-			if (mCurrentSample && !mSamplePaused)
-			{
-				mSamplePaused = true;
-				mCurrentSample->paused();
-			}
-		}
-
-		virtual void unpauseCurrentSample()
-		{
-			if (mCurrentSample && mSamplePaused)
-			{
-				mSamplePaused = false;
-				mCurrentSample->unpaused();
-			}
-		}
-			
-		/*-----------------------------------------------------------------------------
-		| Processes frame started events.
-		-----------------------------------------------------------------------------*/
-		virtual bool frameStarted(const Ogre::FrameEvent& evt)
-		{
-			captureInputDevices();      // capture input
-
-			// manually call sample callback to ensure correct order
-			return (mCurrentSample && !mSamplePaused) ? mCurrentSample->frameStarted(evt) : true;
-		}
-			
-		/*-----------------------------------------------------------------------------
-		| Processes rendering queued events.
-		-----------------------------------------------------------------------------*/
-		virtual bool frameRenderingQueued(const Ogre::FrameEvent& evt)
-		{
-			// manually call sample callback to ensure correct order
-			return (mCurrentSample && !mSamplePaused) ? mCurrentSample->frameRenderingQueued(evt) : true;
-		}
-			
-		/*-----------------------------------------------------------------------------
-		| Processes frame ended events.
-		-----------------------------------------------------------------------------*/
-		virtual bool frameEnded(const Ogre::FrameEvent& evt)
-		{
-			// manually call sample callback to ensure correct order
-			if (mCurrentSample && !mSamplePaused && !mCurrentSample->frameEnded(evt)) return false;
-			// quit if window was closed
-			if (mWindow->isClosed()) return false;
-			// go into idle mode if current sample has ended
-			if (mCurrentSample && mCurrentSample->isDone()) runSample(0);
-
-			return true;
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Processes window size change event. Adjusts mouse's region to match that
-		| of the window. You could also override this method to prevent resizing.
-		-----------------------------------------------------------------------------*/
-		virtual void windowResized(Ogre::RenderWindow* rw)
-		{
-			// manually call sample callback to ensure correct order
-			if (mCurrentSample && !mSamplePaused) mCurrentSample->windowResized(rw);
-
-#if (OGRE_PLATFORM != OGRE_PLATFORM_APPLE_IOS) && (OGRE_PLATFORM != OGRE_PLATFORM_ANDROID)
-			const OIS::MouseState& ms = mMouse->getMouseState();
-			ms.width = rw->getWidth();
-			ms.height = rw->getHeight();
-#endif
-		}
-
-		// window event callbacks which manually call their respective sample callbacks to ensure correct order
-
-		virtual void windowMoved(Ogre::RenderWindow* rw)
-		{
-			if (mCurrentSample && !mSamplePaused) mCurrentSample->windowMoved(rw);
-		}
-
-		virtual bool windowClosing(Ogre::RenderWindow* rw)
-		{
-			if (mCurrentSample && !mSamplePaused) return mCurrentSample->windowClosing(rw);
-			return true;
-		}
-
-		virtual void windowClosed(Ogre::RenderWindow* rw)
-		{
-			if (mCurrentSample && !mSamplePaused) mCurrentSample->windowClosed(rw);
-		}
-
-		virtual void windowFocusChange(Ogre::RenderWindow* rw)
-		{
-			if (mCurrentSample && !mSamplePaused) mCurrentSample->windowFocusChange(rw);
-		}
-
-		// keyboard and mouse callbacks which manually call their respective sample callbacks to ensure correct order
-
-		virtual bool keyPressed(const OIS::KeyEvent& evt)
-		{
-			if (mCurrentSample && !mSamplePaused) return mCurrentSample->keyPressed(evt);
-			return true;
-		}
-
-		virtual bool keyReleased(const OIS::KeyEvent& evt)
-		{
-			if (mCurrentSample && !mSamplePaused) return mCurrentSample->keyReleased(evt);
-			return true;
-		}
-
-#if (OGRE_NO_VIEWPORT_ORIENTATIONMODE == 0)
-    #if (OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS) || (OGRE_PLATFORM == OGRE_PLATFORM_ANDROID)
-        void transformInputState(OIS::MultiTouchState &state)
-    #else
-        void transformInputState(OIS::MouseState &state)
-    #endif
-        {
-            int w = mWindow->getViewport(0)->getActualWidth();
-            int h = mWindow->getViewport(0)->getActualHeight();
-            int absX = state.X.abs;
-            int absY = state.Y.abs;
-            int relX = state.X.rel;
-            int relY = state.Y.rel;
-
-            switch (mWindow->getViewport(0)->getOrientationMode())
-            {
-            case Ogre::OR_DEGREE_0:
-                break;
-            case Ogre::OR_DEGREE_90:
-                state.X.abs = w - absY;
-                state.Y.abs = absX;
-                state.X.rel = -relY;
-                state.Y.rel = relX;
-                break;
-            case Ogre::OR_DEGREE_180:
-                state.X.abs = w - absX;
-                state.Y.abs = h - absY;
-                state.X.rel = -relX;
-                state.Y.rel = -relY;
-                break;
-            case Ogre::OR_DEGREE_270:
-                state.X.abs = absY;
-                state.Y.abs = h - absX;
-                state.X.rel = relY;
-                state.Y.rel = -relX;
-                break;
-            }
-        }
-#elif (OGRE_NO_VIEWPORT_ORIENTATIONMODE == 1) && (OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS)
-    // Variation based upon device orientation for use with a view controller
-    void transformInputState(OIS::MultiTouchState &state)
-    {
-        int w = mWindow->getViewport(0)->getActualWidth();
-        int h = mWindow->getViewport(0)->getActualHeight();
-        int absX = state.X.abs;
-        int absY = state.Y.abs;
-        int relX = state.X.rel;
-        int relY = state.Y.rel;
-
-        UIInterfaceOrientation interfaceOrientation = [UIApplication sharedApplication].statusBarOrientation;
-        switch (interfaceOrientation)
-        {
-            case UIInterfaceOrientationPortrait:
-                break;
-            case UIInterfaceOrientationLandscapeLeft:
-                state.X.abs = w - absY;
-                state.Y.abs = absX;
-                state.X.rel = -relY;
-                state.Y.rel = relX;
-                break;
-            case UIInterfaceOrientationPortraitUpsideDown:
-                state.X.abs = w - absX;
-                state.Y.abs = h - absY;
-                state.X.rel = -relX;
-                state.Y.rel = -relY;
-                break;
-            case UIInterfaceOrientationLandscapeRight:
-                state.X.abs = absY;
-                state.Y.abs = h - absX;
-                state.X.rel = relY;
-                state.Y.rel = -relX;
-                break;
-        }
-    }
-#endif
-
-#if (OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS) || (OGRE_PLATFORM == OGRE_PLATFORM_ANDROID)
-		virtual bool touchMoved(const OIS::MultiTouchEvent& evt)
-		{
-			if (mCurrentSample && !mSamplePaused) return mCurrentSample->touchMoved(evt);
-			return true;
-		}
-#else
-		virtual bool mouseMoved(const OIS::MouseEvent& evt)
-		{
-            if (mCurrentSample && !mSamplePaused) return mCurrentSample->mouseMoved(evt);
-			return true;
-		}
-#endif
-
-#if (OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS) || (OGRE_PLATFORM == OGRE_PLATFORM_ANDROID)
-		virtual bool touchPressed(const OIS::MultiTouchEvent& evt)
-		{
-			if (mCurrentSample && !mSamplePaused) return mCurrentSample->touchPressed(evt);
-			return true;
-		}
-#else
-		virtual bool mousePressed(const OIS::MouseEvent& evt, OIS::MouseButtonID id)
-		{
-			if (mCurrentSample && !mSamplePaused) return mCurrentSample->mousePressed(evt, id);
-			return true;
-		}
-#endif
-
-#if (OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS) || (OGRE_PLATFORM == OGRE_PLATFORM_ANDROID)
-		virtual bool touchReleased(const OIS::MultiTouchEvent& evt)
-		{
-			if (mCurrentSample && !mSamplePaused) return mCurrentSample->touchReleased(evt);
-			return true;
-		}
-#else
-		virtual bool mouseReleased(const OIS::MouseEvent& evt, OIS::MouseButtonID id)
-		{
-			if (mCurrentSample && !mSamplePaused) return mCurrentSample->mouseReleased(evt, id);
-			return true;
-		}
-#endif
-
-	protected:
-
-        /*-----------------------------------------------------------------------------
-         | Sets up the context after configuration.
-         -----------------------------------------------------------------------------*/
-		virtual void setup()
-		{
-			mWindow = createWindow();
-			setupInput();
-			locateResources();
-			loadResources();
-            
-			Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
-            
-			// adds context as listener to process context-level (above the sample level) events
-			mRoot->addFrameListener(this);
-#if OGRE_PLATFORM != OGRE_PLATFORM_ANDROID
-			Ogre::WindowEventUtilities::addWindowEventListener(mWindow, this);
-#endif
-		}
-        
-		/*-----------------------------------------------------------------------------
-		| Creates the OGRE root.
-		-----------------------------------------------------------------------------*/
-		virtual void createRoot()
-		{
-#if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
-			mRoot = Ogre::Root::getSingletonPtr();
-#else
-            Ogre::String pluginsPath = Ogre::StringUtil::BLANK;
-            #ifndef OGRE_STATIC_LIB
-				pluginsPath = mFSLayer->getConfigFilePath("plugins.cfg");
-            #endif
-			mRoot = OGRE_NEW Ogre::Root(pluginsPath, mFSLayer->getWritablePath("ogre.cfg"), 
-				mFSLayer->getWritablePath("ogre.log"));
-#endif
-
-#ifdef OGRE_STATIC_LIB
-            mStaticPluginLoader.load();
-#endif
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Configures the startup settings for OGRE. I use the config dialog here,
-		| but you can also restore from a config file. Note that this only happens
-		| when you start the context, and not when you reset it.
-		-----------------------------------------------------------------------------*/
-		virtual bool oneTimeConfig()
-		{
-			return mRoot->showConfigDialog();
-			// return mRoot->restoreConfig();
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Creates the render window to be used for this context. I use an auto-created
-		| window here, but you can also create an external window if you wish.
-		| Just don't forget to initialise the root.
-		-----------------------------------------------------------------------------*/
-		virtual Ogre::RenderWindow* createWindow()
-		{
-			return mRoot->initialise(true);
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Sets up OIS input.
-		-----------------------------------------------------------------------------*/
-		virtual void setupInput(bool nograb = false)
-		{
-#if OGRE_PLATFORM != OGRE_PLATFORM_ANDROID
-			OIS::ParamList pl;
-			size_t winHandle = 0;
-			std::ostringstream winHandleStr;
-
-			mWindow->getCustomAttribute("WINDOW", &winHandle);
-			winHandleStr << winHandle;
-
-			pl.insert(std::make_pair("WINDOW", winHandleStr.str()));
-            if (nograb)
-            {
-                pl.insert(std::make_pair("x11_keyboard_grab", "false"));
-                pl.insert(std::make_pair("x11_mouse_grab", "false"));
-                pl.insert(std::make_pair("w32_mouse", "DISCL_FOREGROUND"));
-                pl.insert(std::make_pair("w32_mouse", "DISCL_NONEXCLUSIVE"));
-                pl.insert(std::make_pair("w32_keyboard", "DISCL_FOREGROUND"));
-                pl.insert(std::make_pair("w32_keyboard", "DISCL_NONEXCLUSIVE"));
-            }
-
-			mInputMgr = OIS::InputManager::createInputSystem(pl);
-
-			createInputDevices();      // create the specific input devices
-
-			windowResized(mWindow);    // do an initial adjustment of mouse area
-#endif
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Creates the individual input devices. I only create a keyboard and mouse
-		| here because they are the most common, but you can override this method
-		| for other modes and devices.
-		-----------------------------------------------------------------------------*/
-		virtual void createInputDevices()
-		{
-#if OGRE_PLATFORM != OGRE_PLATFORM_ANDROID
-#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS
-			mMouse = static_cast<OIS::MultiTouch*>(mInputMgr->createInputObject(OIS::OISMultiTouch, true));
-			mAccelerometer = static_cast<OIS::JoyStick*>(mInputMgr->createInputObject(OIS::OISJoyStick, true));
-#else
-            OIS::Object* obj = mInputMgr->createInputObject(OIS::OISKeyboard, true);
-			mKeyboard = static_cast<OIS::Keyboard*>(obj);
-			mMouse = static_cast<OIS::Mouse*>(mInputMgr->createInputObject(OIS::OISMouse, true));
-
-			mKeyboard->setEventCallback(this);
-#endif
-			mMouse->setEventCallback(this);
-#endif
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Finds context-wide resource groups. I load paths from a config file here,
-		| but you can choose your resource locations however you want.
-		-----------------------------------------------------------------------------*/
-		virtual void locateResources()
-		{
-#if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
-			// TODO: This is handled externally for now
-#elif OGRE_PLATFORM == OGRE_PLATFORM_NACL
-            Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Essential.zip", "EmbeddedZip", "Essential");
-            Ogre::ResourceGroupManager::getSingleton().addResourceLocation("Popular.zip", "EmbeddedZip", "Popular");
-#else
-			// load resource paths from config file
-			Ogre::ConfigFile cf;
-			cf.load(mFSLayer->getConfigFilePath("resources.cfg"));
-
-			Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator();
-			Ogre::String sec, type, arch;
-
-			// go through all specified resource groups
-			while (seci.hasMoreElements())
-			{
-				sec = seci.peekNextKey();
-				Ogre::ConfigFile::SettingsMultiMap* settings = seci.getNext();
-				Ogre::ConfigFile::SettingsMultiMap::iterator i;
-
-				// go through all resource paths
-				for (i = settings->begin(); i != settings->end(); i++)
-				{
-					type = i->first;
-					arch = i->second;
-
-					#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE || OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS
-                    // OS X does not set the working directory relative to the app,
-                    // In order to make things portable on OS X we need to provide
-                    // the loading with it's own bundle path location
-					if (!Ogre::StringUtil::startsWith(arch, "/", false)) // only adjust relative dirs
-						arch = Ogre::String(Ogre::macBundlePath() + "/" + arch);
-					#endif
-					Ogre::ResourceGroupManager::getSingleton().addResourceLocation(arch, type, sec);
-				}
-			}
-#endif
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Loads context-wide resource groups. I chose here to simply initialise all
-		| groups, but you can fully load specific ones if you wish.
-		-----------------------------------------------------------------------------*/
-		virtual void loadResources()
-		{
-			Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Reconfigures the context. Attempts to preserve the current sample state.
-		-----------------------------------------------------------------------------*/
-		virtual void reconfigure(const Ogre::String& renderer, Ogre::NameValuePairList& options)
-		{
-			// save current sample state
-			mLastSample = mCurrentSample;
-			if (mCurrentSample) mCurrentSample->saveState(mLastSampleState);
-
-			mNextRenderer = renderer;
-			Ogre::RenderSystem* rs = mRoot->getRenderSystemByName(renderer);
-
-			// set all given render system options
-			for (Ogre::NameValuePairList::iterator it = options.begin(); it != options.end(); it++)
-			{
-				rs->setConfigOption(it->first, it->second);
-                
-#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS
-                // Change the viewport orientation on the fly if requested
-                if(it->first == "Orientation")
-                {
-                    if (it->second == "Landscape Left")
-                        mWindow->getViewport(0)->setOrientationMode(Ogre::OR_LANDSCAPELEFT, true);
-                    else if (it->second == "Landscape Right")
-                        mWindow->getViewport(0)->setOrientationMode(Ogre::OR_LANDSCAPERIGHT, true);
-                    else if (it->second == "Portrait")
-                        mWindow->getViewport(0)->setOrientationMode(Ogre::OR_PORTRAIT, true);
-                }
-#endif
-			}
-
-#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS
-            // Need to save the config on iOS to make sure that changes are kept on disk
-            mRoot->saveConfig();
-#endif
-			mLastRun = false;             // we want to go again with the new settings
-			mRoot->queueEndRendering();   // break from render loop
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Recovers the last sample after a reset. You can override in the case that
-		| the last sample is destroyed in the process of resetting, and you have to
-		| recover it through another means.
-		-----------------------------------------------------------------------------*/
-		virtual void recoverLastSample()
-		{
-			runSample(mLastSample);
-			mLastSample->restoreState(mLastSampleState);
-			mLastSample = 0;
-			mLastSampleState.clear();
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Cleans up and shuts down the context.
-		-----------------------------------------------------------------------------*/
-		virtual void shutdown()
-		{
-			if (mCurrentSample)
-			{
-				mCurrentSample->_shutdown();
-				mCurrentSample = 0;
-			}
-
-			// remove window event listener before shutting down OIS
-			Ogre::WindowEventUtilities::removeWindowEventListener(mWindow, this);
-
-			shutdownInput();
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Destroys OIS input devices and the input manager.
-		-----------------------------------------------------------------------------*/
-		virtual void shutdownInput()
-		{
-#if OGRE_PLATFORM != OGRE_PLATFORM_ANDROID
-			if (mInputMgr)
-			{
-#if OGRE_PLATFORM != OGRE_PLATFORM_APPLE_IOS
-				mInputMgr->destroyInputObject(mKeyboard);
-#else
-                mInputMgr->destroyInputObject(mAccelerometer);
-#endif
-				mInputMgr->destroyInputObject(mMouse);
-
-				OIS::InputManager::destroyInputSystem(mInputMgr);
-				mInputMgr = 0;
-			}
-#endif
-		}
-
-		/*-----------------------------------------------------------------------------
-		| Captures input device states.
-		-----------------------------------------------------------------------------*/
-		virtual void captureInputDevices()
-		{
-#if OGRE_PLATFORM != OGRE_PLATFORM_ANDROID
-#if OGRE_PLATFORM != OGRE_PLATFORM_APPLE_IOS
-			mKeyboard->capture();
-#else
-            mAccelerometer->capture();
-#endif
-			mMouse->capture();
-#endif
-		}
-
-		FileSystemLayer* mFSLayer; 		// File system abstraction layer
-		Ogre::Root* mRoot;              // OGRE root
-		OIS::InputManager* mInputMgr;   // OIS input manager
-#ifdef OGRE_STATIC_LIB
-        Ogre::StaticPluginLoader mStaticPluginLoader;
-#endif
-#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS
-		OIS::MultiTouch* mMouse;        // multitouch device
-		OIS::JoyStick* mAccelerometer;  // accelerometer device
-#elif OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
-		OIS::MultiTouch* mMouse;        // multitouch device
-		OIS::Keyboard* mKeyboard;       // keyboard device
-#else
-		OIS::Keyboard* mKeyboard;       // keyboard device
-		OIS::Mouse* mMouse;             // mouse device
-#endif
-		Sample* mCurrentSample;         // currently running sample
-		bool mSamplePaused;             // whether current sample is paused
-		bool mFirstRun;                 // whether or not this is the first run
-		bool mLastRun;                  // whether or not this is the final run
-		Ogre::String mNextRenderer;     // name of renderer used for next run
-		Sample* mLastSample;            // last sample run before reconfiguration
-		Ogre::NameValuePairList mLastSampleState;     // state of last sample
-    public:
-        Ogre::RenderWindow* mWindow;    // render window
-	};
-}
-
-#endif