Ogre 1.7版本中 ExampleApplication类的改造

http://www.cnblogs.com/summericeyl/archive/2011/06/24/2088704.html

Ogre 1.7 版本使用了插件机制来加载和卸载各个Sample Demo, 插件机制的好处在于添加一个Sample某个例子只需要加载该例子dll即可, 不过分析源码框架时则会有一些困难. 对于 Ogre 1.6.5以及之前的版本, 分析某个Sample如何运行, 只需要查看Sample中的ExampleApplication.h以及ExampleListener.h即可.

我修改了ExampleApplication.h, 重写了BaseApplication类, 并重写了一些函数, 这样分析某个Sample时, 只需要从 BaseApplication类派生一个类, 而后根据该Sample的头文件重写 setupContent, setupView等方法即可, 非常方便

注: 还需要自己拷贝 FileSystemLayerImpl.h, 该头文件主要用于确定config配置文件以及log文件的位置

BaseApplication.h

#ifndef __BaseApplication_H__
#define __BaseApplication_H__
 
#include <Ogre.h>
#include "FileSystemLayerImpl.h"
#include "OIS/OIS.h"
#include "SdkTrays.h"
#include "SdkCameraMan.h"
 
#ifdef USE_RTSHADER_SYSTEM
#include "RTShaderSystem/OgreRTShaderSystem.h"
#endif
 
#ifdef USE_RTSHADER_SYSTEM
 
/** This class demonstrates basic usage of the RTShader system.
It sub class the material manager listener class and when a target scheme callback
is invoked with the shader generator scheme it tries to create an equivalent shader
based technique based on the default technique of the given material.
*/
class ShaderGeneratorTechniqueResolverListener : public Ogre::MaterialManager::Listener
{
public:
 
    ShaderGeneratorTechniqueResolverListener(Ogre::RTShader::ShaderGenerator* pShaderGenerator)
    {
        mShaderGenerator = pShaderGenerator;           
    }
 
    /** This is the hook point where shader based technique will be created.
    It will be called whenever the material manager won't find appropriate technique
    that satisfy the target scheme name. If the scheme name is out target RT Shader System
    scheme name we will try to create shader generated technique for it.
    */
    virtual Ogre::Technique* handleSchemeNotFound(unsigned short schemeIndex,
        const Ogre::String& schemeName, Ogre::Material* originalMaterial, unsigned short lodIndex,
        const Ogre::Renderable* rend)
    {  
        Ogre::Technique* generatedTech = NULL;
 
        // Case this is the default shader generator scheme.
        if (schemeName == Ogre::RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME)
        {
            bool techniqueCreated;
 
            // Create shader generated technique for this material.
            techniqueCreated = mShaderGenerator->createShaderBasedTechnique(
                originalMaterial->getName(),
                Ogre::MaterialManager::DEFAULT_SCHEME_NAME,
                schemeName);   
 
            // Case technique registration succeeded.
            if (techniqueCreated)
            {
                // Force creating the shaders for the generated technique.
                mShaderGenerator->validateMaterial(schemeName, originalMaterial->getName());
                 
                // Grab the generated technique.
                Ogre::Material::TechniqueIterator itTech = originalMaterial->getTechniqueIterator();
 
                while (itTech.hasMoreElements())
                {
                    Ogre::Technique* curTech = itTech.getNext();
 
                    if (curTech->getSchemeName() == schemeName)
                    {
                        generatedTech = curTech;
                        break;
                    }
                }              
            }
        }
 
        return generatedTech;
    }
 
protected: 
    Ogre::RTShader::ShaderGenerator*    mShaderGenerator;           // The shader generator instance.      
};
#endif
 
class BaseApplication :
    public Ogre::FrameListener,
    public Ogre::WindowEventListener,
    public OIS::KeyListener,
    public OIS::MouseListener,
    public OgreBites::SdkTrayListener
{
public:
    BaseApplication(void):
        mResourcesCfg(Ogre::StringUtil::BLANK),
        mPluginsCfg(Ogre::StringUtil::BLANK),
        mRoot(0), mWindow(0), mSceneMgr(0), mInputMgr(0), mKeyboard(0), mMouse(0),
        mTrayMgr(0), mCameraMan(0), mCamera(0), mViewport(0), mDetailsPanel(0), mCursorWasVisible(false),
        mDragLook(false), mIsExit(false)
    {
        mFSLayer = OGRE_NEW_T(OgreBites::FileSystemLayerImpl, Ogre::MemoryCategory::MEMCATEGORY_GENERAL)(OGRE_VERSION_NAME);
#ifdef USE_RTSHADER_SYSTEM
        mShaderGenerator     = NULL;       
        mMaterialMgrListener = NULL;
#endif
    }
    virtual ~BaseApplication(void)
    {
        OGRE_DELETE_T(mFSLayer, FileSystemLayer, Ogre::MEMCATEGORY_GENERAL);
        if(mRoot) OGRE_DELETE mRoot;
    }
 
    virtual void go()
    {
#ifdef _DEBUG
        mResourcesCfg = "resources_d.cfg";
        mPluginsCfg = "plugins_d.cfg";
#else
        mResourcesCfg = "resources.cfg";
        mPluginsCfg = "plugins.cfg";
#endif
        if(!setup())
            return;
 
        mRoot->startRendering();
 
        shutdown();
        //  if(mRoot) OGRE_DELETE mRoot;
    }
 
protected:
    virtual bool setup()
    {
 
        mRoot = OGRE_NEW Ogre::Root(mPluginsCfg, mFSLayer->getWritablePath("ogre.cfg"),
            mFSLayer->getWritablePath("ogre.log"));
 
        bool carryOn = configure();
        if(!carryOn)
            return false;
 
 
        createWindow();
        testCapabilities(mRoot->getRenderSystem()->getCapabilities());
        setupInput();
        locateResources();
 
        // 用于 SDK Tray, 可显示加载工具条
        Ogre::ResourceGroupManager::getSingleton().initialiseResourceGroup("Essential");
        mTrayMgr = new OgreBites::SdkTrayManager("TrayManager", mWindow, mMouse, this);
        mTrayMgr->showBackdrop("SdkTrays/Bands");
        mTrayMgr->getTrayContainer(OgreBites::TrayLocation::TL_NONE)->hide();
 
        createSceneManager();
        createDummyScene();
        loadResources();
        destroyDummyScene();
 
        setupView();
 
#ifdef USE_RTSHADER_SYSTEM
        // Initialize shader generator.
        // Must be before resource loading in order to allow parsing extended material attributes.
        bool success = initializeRTShaderSystem(mSceneMgr);
        if (!success)
        {
            OGRE_EXCEPT(Ogre::Exception::ERR_FILE_NOT_FOUND,
                "Shader Generator Initialization failed - Core shader libs path not found",
                "Sample::_setup");
        }
#endif
 
        mTrayMgr->hideBackdrop();
        mTrayMgr->showFrameStats(OgreBites::TL_BOTTOMLEFT);
        mTrayMgr->showLogo(OgreBites::TL_BOTTOMRIGHT);
        mTrayMgr->hideCursor();
        Ogre::StringVector items;
        items.push_back("cam.pX");
        items.push_back("cam.pY");
        items.push_back("cam.pZ");
        items.push_back("");
        items.push_back("cam.oW");
        items.push_back("cam.oX");
        items.push_back("cam.oY");
        items.push_back("cam.oZ");
        items.push_back("");
        items.push_back("Filtering");
        items.push_back("Poly Mode");
 
#ifdef USE_RTSHADER_SYSTEM
        items.push_back("RT Shaders");
        items.push_back("Lighting Model");
        items.push_back("Compact Policy");
        items.push_back("Generated VS");
        items.push_back("Generated FS");                                                       
#endif
 
        mDetailsPanel = mTrayMgr->createParamsPanel(OgreBites::TL_NONE, "DetailsPanel", 200, items);
        mDetailsPanel->hide();
 
        mDetailsPanel->setParamValue(9, "Bilinear");
        mDetailsPanel->setParamValue(10, "Solid");
 
#ifdef USE_RTSHADER_SYSTEM
        mDetailsPanel->setParamValue(11, "Off");
        mDetailsPanel->setParamValue(12, "Vertex");
        mDetailsPanel->setParamValue(13, "Low");
        mDetailsPanel->setParamValue(14, "0");
        mDetailsPanel->setParamValue(15, "0");                                                          
#endif
 
        Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
        mRoot->addFrameListener(this);
        Ogre::WindowEventUtilities::addWindowEventListener(mWindow, this);
 
        setupContent();
 
        return true;
    }
 
    virtual void loadResources()
    {
        mTrayMgr->showLoadingBar(1, 0);
        Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
        mTrayMgr->hideLoadingBar();
    }
 
    virtual bool configure(void)
    {
        if (!mRoot->restoreConfig()) return mRoot->showConfigDialog();
        return true;
    }
 
    virtual void createWindow()
    {
        mWindow = mRoot->initialise(true, "Main Window");
    }
 
    virtual void setupInput()
    {
        OIS::ParamList pl;
        size_t winHandle = 0;
        std::ostringstream winHandleStr;
 
        mWindow->getCustomAttribute("WINDOW", &winHandle);
        winHandleStr << winHandle;
 
        pl.insert(std::make_pair("WINDOW", winHandleStr.str()));
 
        mInputMgr = OIS::InputManager::createInputSystem(pl);
 
        createInputDevices();      // create the specific input devices
 
        windowResized(mWindow);    // do an initial adjustment of mouse area
    }
 
    virtual void createInputDevices()
    {
        mKeyboard = static_cast<OIS::Keyboard*>(mInputMgr->createInputObject(OIS::OISKeyboard, true));
        mMouse = static_cast<OIS::Mouse*>(mInputMgr->createInputObject(OIS::OISMouse, true));
 
        mKeyboard->setEventCallback(this);
        mMouse->setEventCallback(this);
    }
 
    virtual void locateResources()
    {
        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;
                Ogre::ResourceGroupManager::getSingleton().addResourceLocation(arch, type, sec);
            }
        }
    }
 
    virtual void shutdown()
    {
        if(mTrayMgr)
        {
            delete mTrayMgr;
            mTrayMgr = 0;
        }
        if (mCameraMan) delete mCameraMan;
 
#ifdef USE_RTSHADER_SYSTEM
        // Finalize the RT Shader System.
        finalizeRTShaderSystem();
#endif
 
        cleanupContent();
        if (mSceneMgr) mSceneMgr->clearScene();
        unloadResources();
        mRoot->destroySceneManager(mSceneMgr);
        mSceneMgr = 0;
 
        Ogre::MaterialManager::getSingleton().setDefaultTextureFiltering(Ogre::TFO_BILINEAR);
        Ogre::MaterialManager::getSingleton().setDefaultAnisotropy(1);
 
        Ogre::WindowEventUtilities::removeWindowEventListener(mWindow, this);
        shutdownInput();
    }
 
    virtual void shutdownInput()
    {
        if (mInputMgr)
        {
            mInputMgr->destroyInputObject(mKeyboard);
            mInputMgr->destroyInputObject(mMouse);
            OIS::InputManager::destroyInputSystem(mInputMgr);
            mInputMgr = 0;
        }
 
    }
 
    virtual void unloadResources()
    {
        Ogre::ResourceGroupManager::ResourceManagerIterator resMgrs =
            Ogre::ResourceGroupManager::getSingleton().getResourceManagerIterator();
 
        while (resMgrs.hasMoreElements())
        {
            resMgrs.getNext()->unloadUnreferencedResources();
        }
    }
 
    virtual void testCapabilities(const Ogre::RenderSystemCapabilities* caps) {}
 
    virtual void captureInputDevices()
    {
        mKeyboard->capture();
        mMouse->capture();
    }
 
    virtual void createSceneManager()
    {
        mSceneMgr = Ogre::Root::getSingleton().createSceneManager(Ogre::ST_GENERIC);
    }
 
    virtual void setupView()
    {
        mCamera = mSceneMgr->createCamera("MainCamera");
        mViewport = mWindow->addViewport(mCamera);
        mCamera->setAspectRatio((Ogre::Real)mViewport->getActualWidth() / (Ogre::Real)mViewport->getActualWidth());
        mCamera->setNearClipDistance(5);
 
        mCameraMan = new OgreBites::SdkCameraMan(mCamera);
    }
 
    virtual void setupContent() {}
    virtual void cleanupContent() {}
 
    virtual Ogre::RenderWindow* getRenderWindow() { return mWindow; }
    Ogre::SceneManager* getSceneManager() { return mSceneMgr; }
 
    virtual bool frameStarted(const Ogre::FrameEvent& evt)
    {
        if(mIsExit) return false;
        captureInputDevices();
 
        return true;
    }
 
    virtual bool frameRenderingQueued(const Ogre::FrameEvent& evt)
    {
        // Sample
        mTrayMgr->frameRenderingQueued(evt);
 
        if (!mTrayMgr->isDialogVisible())
        {
            mCameraMan->frameRenderingQueued(evt);   // if dialog isn't up, then update the camera
 
            if (mDetailsPanel->isVisible())   // if details panel is visible, then update its contents
            {
                mDetailsPanel->setParamValue(0, Ogre::StringConverter::toString(mCamera->getDerivedPosition().x));
                mDetailsPanel->setParamValue(1, Ogre::StringConverter::toString(mCamera->getDerivedPosition().y));
                mDetailsPanel->setParamValue(2, Ogre::StringConverter::toString(mCamera->getDerivedPosition().z));
                mDetailsPanel->setParamValue(4, Ogre::StringConverter::toString(mCamera->getDerivedOrientation().w));
                mDetailsPanel->setParamValue(5, Ogre::StringConverter::toString(mCamera->getDerivedOrientation().x));
                mDetailsPanel->setParamValue(6, Ogre::StringConverter::toString(mCamera->getDerivedOrientation().y));
                mDetailsPanel->setParamValue(7, Ogre::StringConverter::toString(mCamera->getDerivedOrientation().z));
 
#ifdef USE_RTSHADER_SYSTEM
                mDetailsPanel->setParamValue(14, Ogre::StringConverter::toString(mShaderGenerator->getVertexShaderCount()));
                mDetailsPanel->setParamValue(15, Ogre::StringConverter::toString(mShaderGenerator->getFragmentShaderCount()));       
#endif
            }  
        }
 
        return true;
    }
 
    virtual bool frameEnded(const Ogre::FrameEvent& evt)
    {
        // Sample
        if (mWindow->isClosed()) return false;
        return true;
    }
 
    virtual void windowResized(Ogre::RenderWindow* rw)
    {
        // Sample  
        if(mCamera)
        {
            mCamera->setAspectRatio((Ogre::Real)mViewport->getActualWidth() / (Ogre::Real)mViewport->getActualHeight());
        }
 
        const OIS::MouseState& ms = mMouse->getMouseState();
        ms.width = rw->getWidth();
        ms.height = rw->getHeight();
    }
 
    virtual void windowMoved(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)
    {
        if (mTrayMgr->isDialogVisible()) return true;
 
        if (evt.key == OIS::KC_H || evt.key == OIS::KC_F1)   // toggle visibility of help dialog
        {
            if (!mTrayMgr->isDialogVisible() && mInfo["Help"] != "") mTrayMgr->showOkDialog("Help", mInfo["Help"]);
            else mTrayMgr->closeDialog();
        }
 
        if(evt.key == OIS::KC_ESCAPE) mIsExit = true;
 
        if (mTrayMgr->isDialogVisible()) return true;   // don't process any more keys if dialog is up
 
        if (evt.key == OIS::KC_F)   // toggle visibility of advanced frame stats
        {
            mTrayMgr->toggleAdvancedFrameStats();
        }
        else if (evt.key == OIS::KC_G)   // toggle visibility of even rarer debugging details
        {
            if (mDetailsPanel->getTrayLocation() == OgreBites::TL_NONE)
            {
                mTrayMgr->moveWidgetToTray(mDetailsPanel, OgreBites::TL_TOPRIGHT, 0);
                mDetailsPanel->show();
            }
            else
            {
                mTrayMgr->removeWidgetFromTray(mDetailsPanel);
                mDetailsPanel->hide();
            }
        }
        else if (evt.key == OIS::KC_T)   // cycle polygon rendering mode
        {
            Ogre::String newVal;
            Ogre::TextureFilterOptions tfo;
            unsigned int aniso;
 
            switch (mDetailsPanel->getParamValue(9).asUTF8()[0])
            {
            case 'B':
                newVal = "Trilinear";
                tfo = Ogre::TFO_TRILINEAR;
                aniso = 1;
                break;
            case 'T':
                newVal = "Anisotropic";
                tfo = Ogre::TFO_ANISOTROPIC;
                aniso = 8;
                break;
            case 'A':
                newVal = "None";
                tfo = Ogre::TFO_NONE;
                aniso = 1;
                break;
            default:
                newVal = "Bilinear";
                tfo = Ogre::TFO_BILINEAR;
                aniso = 1;
            }
 
            Ogre::MaterialManager::getSingleton().setDefaultTextureFiltering(tfo);
            Ogre::MaterialManager::getSingleton().setDefaultAnisotropy(aniso);
            mDetailsPanel->setParamValue(9, newVal);
        }
        else if (evt.key == OIS::KC_R)   // cycle polygon rendering mode
        {
            Ogre::String newVal;
            Ogre::PolygonMode pm;
 
            switch (mCamera->getPolygonMode())
            {
            case Ogre::PM_SOLID:
                newVal = "Wireframe";
                pm = Ogre::PM_WIREFRAME;
                break;
            case Ogre::PM_WIREFRAME:
                newVal = "Points";
                pm = Ogre::PM_POINTS;
                break;
            default:
                newVal = "Solid";
                pm = Ogre::PM_SOLID;
            }
 
            mCamera->setPolygonMode(pm);
            mDetailsPanel->setParamValue(10, newVal);
        }
        else if(evt.key == OIS::KC_F5)   // refresh all textures
        {
            Ogre::TextureManager::getSingleton().reloadAll();
        }
        else if (evt.key == OIS::KC_SYSRQ)   // take a screenshot
        {
            mWindow->writeContentsToTimestampedFile("screenshot", ".png");
        }
 
#ifdef USE_RTSHADER_SYSTEM     
        // Toggle schemes.         
        else if (evt.key == OIS::KC_F2)
        {  
            Ogre::Viewport* mainVP = mCamera->getViewport();
            const Ogre::String& curMaterialScheme = mainVP->getMaterialScheme();
 
            if (curMaterialScheme == Ogre::MaterialManager::DEFAULT_SCHEME_NAME)
            {                          
                mainVP->setMaterialScheme(Ogre::RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME);
                mDetailsPanel->setParamValue(11, "On");
            }
            else if (curMaterialScheme == Ogre::RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME)
            {
                mainVP->setMaterialScheme(Ogre::MaterialManager::DEFAULT_SCHEME_NAME);
                mDetailsPanel->setParamValue(11, "Off");
            }                                                      
        }          
 
#ifdef RTSHADER_SYSTEM_BUILD_EXT_SHADERS
 
        // Toggles per pixel per light model.
        else if (evt.key == OIS::KC_F3)
        {
            static bool usePerPixelLighting = true;                
 
            // Grab the scheme render state.                                               
            Ogre::RTShader::RenderState* schemRenderState = mShaderGenerator->getRenderState(Ogre::RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME);
 
 
            // Add per pixel lighting sub render state to the global scheme render state.
            // It will override the default FFP lighting sub render state.
            if (usePerPixelLighting)
            {
                Ogre::RTShader::SubRenderState* perPixelLightModel = mShaderGenerator->createSubRenderState(Ogre::RTShader::PerPixelLighting::Type);
 
                schemRenderState->addTemplateSubRenderState(perPixelLightModel);                
            }
 
            // Search the per pixel sub render state and remove it.
            else
            {
                const Ogre::RTShader::SubRenderStateList& subRenderStateList = schemRenderState->getTemplateSubRenderStateList();
                Ogre::RTShader::SubRenderStateListConstIterator it = subRenderStateList.begin();
                Ogre::RTShader::SubRenderStateListConstIterator itEnd = subRenderStateList.end();
 
                for (; it != itEnd; ++it)
                {
                    Ogre::RTShader::SubRenderState* curSubRenderState = *it;
 
                    // This is the per pixel sub render state -> remove it.
                    if (curSubRenderState->getType() == Ogre::RTShader::PerPixelLighting::Type)
                    {
                        schemRenderState->removeTemplateSubRenderState(*it);
                        break;
                    }
                }
            }
 
            // Invalidate the scheme in order to re-generate all shaders based technique related to this scheme.
            mShaderGenerator->invalidateScheme(Ogre::RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME);
 
 
            // Update UI.
            if (usePerPixelLighting)
                mDetailsPanel->setParamValue(12, "Pixel");
            else
                mDetailsPanel->setParamValue(12, "Vertex");
            usePerPixelLighting = !usePerPixelLighting;            
        }  
#endif
        // Switch vertex shader outputs compaction policy.
        else if (evt.key == OIS::KC_F4)  
        {
            switch (mShaderGenerator->getVertexShaderOutputsCompactPolicy())
            {
            case Ogre::RTShader::VSOCP_LOW:
                mShaderGenerator->setVertexShaderOutputsCompactPolicy(Ogre::RTShader::VSOCP_MEDIUM);
                mDetailsPanel->setParamValue(13, "Medium");
                break;
 
            case Ogre::RTShader::VSOCP_MEDIUM:
                mShaderGenerator->setVertexShaderOutputsCompactPolicy(Ogre::RTShader::VSOCP_HIGH);
                mDetailsPanel->setParamValue(13, "High");
                break;
 
            case Ogre::RTShader::VSOCP_HIGH:
                mShaderGenerator->setVertexShaderOutputsCompactPolicy(Ogre::RTShader::VSOCP_LOW);
                mDetailsPanel->setParamValue(13, "Low");
                break;
            }
 
            // Invalidate the scheme in order to re-generate all shaders based technique related to this scheme.
            mShaderGenerator->invalidateScheme(Ogre::RTShader::ShaderGenerator::DEFAULT_SCHEME_NAME);
        }  
#endif
 
        mCameraMan->injectKeyDown(evt);
        return true;
    }
 
    virtual bool keyReleased(const OIS::KeyEvent& evt)
    {
        if (mTrayMgr->isDialogVisible()) return true;
 
        mCameraMan->injectKeyUp(evt);
        return true;
    }
 
    virtual bool mouseMoved(const OIS::MouseEvent& evt)
    {
        //OIS::MouseState state = evt.state;
        //OIS::MouseEvent orientedEvt((OIS::Object*)evt.device, state);
        //if (mTrayMgr->injectMouseMove(orientedEvt)) return true;
 
        if (mTrayMgr->injectMouseMove(evt)) return true;
        mCameraMan->injectMouseMove(evt);
 
        return true;
    }
 
    virtual bool mousePressed(const OIS::MouseEvent& evt, OIS::MouseButtonID id)
    {
        //OIS::MouseState state = evt.state;
        //OIS::MouseEvent orientedEvt((OIS::Object*)evt.device, state);
        //if (mTrayMgr->injectMouseDown(orientedEvt, id)) return true;
 
        if (mTrayMgr->injectMouseDown(evt, id)) return true;
 
        if (mDragLook && id == OIS::MB_Left)
        {
            mCameraMan->setStyle(OgreBites::CS_FREELOOK);
            mTrayMgr->hideCursor();
        }
 
        mCameraMan->injectMouseDown(evt, id);
 
        return true;
    }
 
    virtual bool mouseReleased(const OIS::MouseEvent& evt, OIS::MouseButtonID id)
    {
        //OIS::MouseState state = evt.state;
        //OIS::MouseEvent orientedEvt((OIS::Object*)evt.device, state);
        //if (mTrayMgr->injectMouseUp(orientedEvt, id)) return true;
 
        if (mTrayMgr->injectMouseUp(evt, id)) return true;
 
        if (mDragLook && id == OIS::MB_Left)
        {
            mCameraMan->setStyle(OgreBites::CS_MANUAL);
            mTrayMgr->showCursor();
        }
 
        mCameraMan->injectMouseUp(evt, id);
        return true;
    }
 
    virtual void createDummyScene()
    {
        mWindow->removeAllViewports();
        Ogre::SceneManager* sm = mRoot->createSceneManager(Ogre::ST_GENERIC, "DummyScene");
        Ogre::Camera* cam = sm->createCamera("DummyCamera");
        mWindow->addViewport(cam);
    }
 
    virtual void destroyDummyScene()
    {
        mWindow->removeAllViewports();
        mRoot->destroySceneManager(mRoot->getSceneManager("DummyScene"));
    }
 
#ifdef USE_RTSHADER_SYSTEM
 
        /*-----------------------------------------------------------------------------
        | Initialize the RT Shader system. 
        -----------------------------------------------------------------------------*/
        virtual bool initializeRTShaderSystem(Ogre::SceneManager* sceneMgr)
        {          
            if (Ogre::RTShader::ShaderGenerator::initialize())
            {
                mShaderGenerator = Ogre::RTShader::ShaderGenerator::getSingletonPtr();
 
                mShaderGenerator->addSceneManager(sceneMgr);
 
                // Setup core libraries and shader cache path.
                Ogre::StringVector groupVector = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
                Ogre::StringVector::iterator itGroup = groupVector.begin();
                Ogre::StringVector::iterator itGroupEnd = groupVector.end();
                Ogre::String shaderCoreLibsPath;
                Ogre::String shaderCachePath;
             
                for (; itGroup != itGroupEnd; ++itGroup)
                {
                    Ogre::ResourceGroupManager::LocationList resLocationsList = Ogre::ResourceGroupManager::getSingleton().getResourceLocationList(*itGroup);
                    Ogre::ResourceGroupManager::LocationList::iterator it = resLocationsList.begin();
                    Ogre::ResourceGroupManager::LocationList::iterator itEnd = resLocationsList.end();
                    bool coreLibsFound = false;
 
                    // Try to find the location of the core shader lib functions and use it
                    // as shader cache path as well - this will reduce the number of generated files
                    // when running from different directories.
                    for (; it != itEnd; ++it)
                    {
                        if ((*it)->archive->getName().find("RTShaderLib") != Ogre::String::npos)
                        {
                            shaderCoreLibsPath = (*it)->archive->getName() + "/";
                            shaderCachePath = shaderCoreLibsPath;
                            coreLibsFound = true;
                            break;
                        }
                    }
                    // Core libs path found in the current group.
                    if (coreLibsFound)
                        break;
                }
 
                // Core shader libs not found -> shader generating will fail.
                if (shaderCoreLibsPath.empty())        
                    return false;          
                                 
#ifdef _RTSS_WRITE_SHADERS_TO_DISK
                // Set shader cache path.
                mShaderGenerator->setShaderCachePath(shaderCachePath);      
#endif
                // Create and register the material manager listener.
                mMaterialMgrListener = new ShaderGeneratorTechniqueResolverListener(mShaderGenerator);             
                Ogre::MaterialManager::getSingleton().addListener(mMaterialMgrListener);
            }
 
            return true;
        }
 
        /*-----------------------------------------------------------------------------
        | Finalize the RT Shader system.   
        -----------------------------------------------------------------------------*/
        virtual void finalizeRTShaderSystem()
        {
            // Restore default scheme.
            Ogre::MaterialManager::getSingleton().setActiveScheme(Ogre::MaterialManager::DEFAULT_SCHEME_NAME);
 
            // Unregister the material manager listener.
            if (mMaterialMgrListener != NULL)
            {          
                Ogre::MaterialManager::getSingleton().removeListener(mMaterialMgrListener);
                delete mMaterialMgrListener;
                mMaterialMgrListener = NULL;
            }
 
            // Finalize RTShader system.
            if (mShaderGenerator != NULL)
            {              
                Ogre::RTShader::ShaderGenerator::finalize();
                mShaderGenerator = NULL;
            }
        }
#endif
 
    OgreBites::FileSystemLayer* mFSLayer;
    Ogre::Root* mRoot;
    Ogre::RenderWindow* mWindow;
    Ogre::SceneManager* mSceneMgr;
    Ogre::Viewport* mViewport;
    Ogre::Camera* mCamera;
 
    OIS::InputManager* mInputMgr;
    OIS::Keyboard* mKeyboard;
    OIS::Mouse* mMouse;
 
    Ogre::String mResourcesCfg;
    Ogre::String mPluginsCfg;
 
    Ogre::NameValuePairList mInfo;
 
    OgreBites::SdkTrayManager* mTrayMgr;
    OgreBites::SdkCameraMan* mCameraMan;
    OgreBites::ParamsPanel* mDetailsPanel;
    bool mCursorWasVisible;
    bool mDragLook;
 
    bool mIsExit;
 
#ifdef USE_RTSHADER_SYSTEM
    Ogre::RTShader::ShaderGenerator*            mShaderGenerator;           // The Shader generator instance.
    ShaderGeneratorTechniqueResolverListener*   mMaterialMgrListener;       // Shader generator material manager listener. 
#endif
};
 
#endif