source: trunk/VUT/OcclusionCullingSceneManager/TestCulling/TestCullingApplication.cpp @ 34

/**
    \file 
        TestCullingApplication.cpp
    \brief
        Tests the occlusion culling algorithm
*/

#include <OgreNoMemoryMacros.h>
#include <CEGUI/CEGUI.h>
#include <../CEGUIRenderer/include/OgreCEGUIRenderer.h>
#include <../CEGUIRenderer/include/OgreCEGUIResourceProvider.h>
#include <../CEGUIRenderer/include/OgreCEGUITexture.h>
#include <OgreMemoryMacros.h>

#include "Ogre.h"
#include "TestCullingApplication.h"
#include "OgreOcclusionCullingSceneTraverser.h"

#define WIN32_LEAN_AND_MEAN
#include "windows.h"

RaySceneQuery* raySceneQuery = 0;

/***********************************************/
/* TestCullingApplication implementation       */
/***********************************************/
TestCullingApplication::~TestCullingApplication()
{
        delete raySceneQuery;
}
//-----------------------------------------------------------------------
void TestCullingApplication::createCamera( void )
{
        // Create the camera
        mCamera = mSceneMgr->createCamera("PlayerCam");

        // Position it at 500 in Z direction
        mCamera->setPosition(Vector3(128,25,128));

        // Look back along -Z
    mCamera->lookAt(Vector3(0,0,-300));
    mCamera->setNearClipDistance( 1 );
    mCamera->setFarClipDistance( 1000 );
}
//-----------------------------------------------------------------------
void TestCullingApplication::createScene(void)
{
        Plane waterPlane;
        // Set ambient light
        mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5));
        
        // Create a light
        Light* l = mSceneMgr->createLight("MainLight");
        // Accept default settings: point light, white diffuse, just set position
        // NB I could attach the light to a SceneNode if I wanted it to move automatically with
        //  other objects, but I don't
        l->setPosition(20,80,50);

        // Fog
        // NB it's VERY important to set this before calling setWorldGeometry 
        // because the vertex program picked will be different
        ColourValue fadeColour(0.93, 0.86, 0.76);
        mSceneMgr->setFog( FOG_LINEAR, fadeColour, .001, 500, 1000);
        mWindow->getViewport(0)->setBackgroundColour(fadeColour);

        std::string terrain_cfg("terrain.cfg");
#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
        terrain_cfg = mResourcePath + terrain_cfg;
#endif
        mSceneMgr -> setWorldGeometry( terrain_cfg );
        // Infinite far plane?
        if (mRoot->getRenderSystem()->getCapabilities()->hasCapability(RSC_INFINITE_FAR_PLANE))
        {
                mCamera->setFarClipDistance(0);
        }

        // Define the required skyplane
        Plane plane;
        // 5000 world units from the camera
        plane.d = 5000;
        // Above the camera, facing down
        plane.normal = -Vector3::UNIT_Y;

        // Set a nice viewpoint
        mCamera->setPosition(707,2500,528);
        mCamera->setOrientation(Quaternion(-0.3486, 0.0122, 0.9365, 0.0329));

        raySceneQuery = mSceneMgr->createRayQuery(
        Ray(mCamera->getPosition(), Vector3::NEGATIVE_UNIT_Y));

     // Create a skybox
  //   mSceneMgr->setSkyBox(true, "Examples/SpaceSkyBox");

         // CEGUI setup
         setupGui();
}
//-----------------------------------------------------------------------
void TestCullingApplication::setupGui( void )
{
         mGUIRenderer = new CEGUI::OgreCEGUIRenderer(mWindow, Ogre::RENDER_QUEUE_OVERLAY, false, 3000, ST_EXTERIOR_CLOSE);
     mGUISystem = new CEGUI::System(mGUIRenderer);

         // Mouse
     CEGUI::SchemeManager::getSingleton().loadScheme((CEGUI::utf8*)"TaharezLook.scheme");
     CEGUI::MouseCursor::getSingleton().setImage("TaharezLook", "MouseArrow");
         mGUISystem->setDefaultMouseCursor(
                (CEGUI::utf8*)"TaharezLook", (CEGUI::utf8*)"MouseArrow");

         CEGUI::MouseCursor::getSingleton().show( );
     
        /* CEGUI::Window* sheet = 
            CEGUI::WindowManager::getSingleton().loadWindowLayout(
                (CEGUI::utf8*)"ogregui.layout"); 

     mGUISystem->setGUISheet(sheet);*/
}
//-----------------------------------------------------------------------
void TestCullingApplication::createFrameListener(void)
{
        mFrameListener= new MouseQueryListener(mWindow, mCamera, mSceneMgr, mGUIRenderer);
        mFrameListener->showDebugOverlay(true);
        mRoot->addFrameListener(mFrameListener);
}
//-----------------------------------------------------------------------
void TestCullingApplication::chooseSceneManager(void)
{
    //mSceneMgr = mRoot->getSceneManager(ST_GENERIC);
        mSceneMgr = mRoot->getSceneManager(ST_EXTERIOR_CLOSE);
}

/***********************************************/
/* MouseQueryListener implementation           */
/***********************************************/

//-----------------------------------------------------------------------
MouseQueryListener::MouseQueryListener(RenderWindow* win, Camera* cam, SceneManager *sceneManager, CEGUI::Renderer *renderer)
        : ExampleFrameListener(win, cam, false, true), mGUIRenderer(renderer), 
                mShutdownRequested(false)
{

        // Setup default variables
//      mCurrentObject = NULL;
        mLMouseDown = false;
        mRMouseDown = false;
        mSceneMgr = sceneManager;

    // Reduce move speed
        mMoveSpeed = 50;
        mRotateSpeed *= 2;

        mCurrentAlgorithm = OcclusionCullingSceneTraverser::RENDER_COHERENT;
        mThreshold = 0;
    
        // Register this so that we get mouse events.
        mEventProcessor->addMouseListener(this);
        mEventProcessor->addMouseMotionListener(this);
        mEventProcessor->addKeyListener(this);

        // show overlay
        Overlay* pOver = OverlayManager::getSingleton().getByName("Example/OcclusionDemoOverlay"); 

        mAlgorithmInfo = OverlayManager::getSingleton().getOverlayElement("Example/Occlusion/AlgorithmInfo");
        mThresholdInfo = OverlayManager::getSingleton().getOverlayElement("Example/Occlusion/ThresholdInfo");
        mFrustumCulledNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Occlusion/FrustumCulledNodesInfo");
        mQueryCulledNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Occlusion/QueryCulledNodesInfo");
    mTraversedNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Occlusion/TraversedNodesInfo");

        mAlgorithmInfo->setCaption(": " + mCurrentAlgorithmCaptions[mCurrentAlgorithm]);
        mThresholdInfo->setCaption(": 0");
        mFrustumCulledNodesInfo->setCaption(": 0");
        mQueryCulledNodesInfo->setCaption(": 0");
        mTraversedNodesInfo->setCaption(": 0");

    pOver->show();
} // MouseQueryListener
//-----------------------------------------------------------------------
void MouseQueryListener::mouseMoved (MouseEvent *e)
{
        // Update CEGUI with the mouse motion
    CEGUI::System::getSingleton().injectMouseMove(e->getRelX() * mGUIRenderer->getWidth(), e->getRelY() * mGUIRenderer->getHeight());
}
//-----------------------------------------------------------------------
void MouseQueryListener::mousePressed(MouseEvent* e)
{
     // Left mouse button down
     if (e->getButtonID() & InputEvent::BUTTON0_MASK)
     {
                 CEGUI::MouseCursor::getSingleton().hide( );
                 mLMouseDown = true;
     } // if
     // Right mouse button down
     else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
     {
         CEGUI::MouseCursor::getSingleton().hide( );
         mRMouseDown = true;
     } // else if
} // mousePressed

 //-----------------------------------------------------------------------
void MouseQueryListener::mouseReleased(MouseEvent* e)
{
    // Left mouse button up
    if (e->getButtonID() & InputEvent::BUTTON0_MASK)
    {
                CEGUI::MouseCursor::getSingleton().show( );
        mLMouseDown = false;
    }
    // Right mouse button up
    else if (e->getButtonID() & InputEvent::BUTTON1_MASK)
    {
        CEGUI::MouseCursor::getSingleton().show( );
        mRMouseDown = false;
    }
} 
//-----------------------------------------------------------------------
void MouseQueryListener::mouseDragged (MouseEvent *e)
 {
         /*
         // If we are dragging the left mouse button.    
         if ( mLMouseDown )
         {
                mShipNode->translate(-e->getRelX() * 200, -e->getRelY() * 200, 0.0);
     }
         */
         
         // If we are dragging the right mouse button.
         if ( mRMouseDown )
         {
                 mCamera->yaw( -e->getRelX() * mRotateSpeed );
                 mCamera->pitch( -e->getRelY() * mRotateSpeed );
         }
}
//-----------------------------------------------------------------------
bool MouseQueryListener::frameStarted(const FrameEvent &evt)
{
        // clamp to terrain
        static Ray updateRay;
        updateRay.setOrigin(mCamera->getPosition());
        updateRay.setDirection(Vector3::NEGATIVE_UNIT_Y);
        raySceneQuery->setRay(updateRay);
        RaySceneQueryResult& qryResult = raySceneQuery->execute();
        RaySceneQueryResult::iterator i = qryResult.begin();
         
        if (i != qryResult.end() && i->worldFragment)
        {
                SceneQuery::WorldFragment* wf = i->worldFragment;
                mCamera->setPosition(mCamera->getPosition().x, 
                        i->worldFragment->singleIntersection.y + 10, 
                        mCamera->getPosition().z);
        }
         
        return ExampleFrameListener::frameStarted(evt);
}
//-----------------------------------------------------------------------
bool MouseQueryListener::frameEnded(const FrameEvent& evt)
{
        if (mShutdownRequested)
                return false;

    if (timeDelay >= 0) 
        timeDelay -= evt.timeSinceLastFrame;

    KEY_PRESSED(KC_SPACE, 0.3, changeAlgorithm());

        KEY_PRESSED(KC_SUBTRACT, 0.3, changeThreshold(-10));
        KEY_PRESSED(KC_ADD, 0, changeThreshold(10));
        //KEY_PRESSED(KC_T, 1, change);
      
        changeStats();

    return ExampleFrameListener::frameStarted(evt) && ExampleFrameListener::frameEnded(evt);        
}
//-----------------------------------------------------------------------
void MouseQueryListener::changeThreshold(int incr)
{
        mThreshold += incr; if(mThreshold < 0) mThreshold = 0;
        
        char str[100]; sprintf(str,": %d", mThreshold);

        mSceneMgr->setOption("Threshold", &mThreshold); 
        mThresholdInfo->setCaption(str);
}
//-----------------------------------------------------------------------
void MouseQueryListener::changeAlgorithm()
{
    mCurrentAlgorithm = ++mCurrentAlgorithm % OcclusionCullingSceneTraverser::NUM_RENDERMODES;

        mAlgorithmInfo->setCaption(": " + mCurrentAlgorithmCaptions[mCurrentAlgorithm]);
        mSceneMgr->setOption("Algorithm", &mCurrentAlgorithm);
}
//-----------------------------------------------------------------------
void MouseQueryListener::changeStats()
{
        unsigned int opt = 0;
        char str[100];
        
        mSceneMgr->getOption("NumFrustumCulledNodes", &opt); sprintf(str,": %d", opt); 
        mFrustumCulledNodesInfo->setCaption(str);
        
        mSceneMgr->getOption("NumQueryCulledNodes", &opt); sprintf(str,": %d", opt); 
        mQueryCulledNodesInfo->setCaption(str);
        
        mSceneMgr->getOption("NumTraversedNodes", &opt); sprintf(str,": %d", opt); 
        mTraversedNodesInfo->setCaption(str);
}
//-----------------------------------------------------------------------
void MouseQueryListener::keyPressed(KeyEvent* e)
{
        if(e->getKey() == KC_ESCAPE)
    {
                mShutdownRequested = true;
                e->consume();
                return;
        }

        CEGUI::System::getSingleton().injectKeyDown(e->getKey());
        CEGUI::System::getSingleton().injectChar(e->getKeyChar());
        e->consume();
}
//-----------------------------------------------------------------------
void MouseQueryListener::keyReleased(KeyEvent* e)
{
        CEGUI::System::getSingleton().injectKeyUp(e->getKey());
        e->consume();
}
//-----------------------------------------------------------------------
void MouseQueryListener::keyClicked(KeyEvent* e) 
{
        // Do nothing
        e->consume();
}
//-----------------------------------------------------------------------
INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT )
{
    // Create application object
    TestCullingApplication app;

        try 
        {
        app.go();
    } 
        catch( Ogre::Exception& e ) 
        {
        MessageBox( NULL, e.getFullDescription().c_str(), "An exception has occured!", MB_OK | MB_ICONERROR | MB_TASKMODAL);
    }   

    return 0;
}