source: trunk/VUT/OcclusionCullingSceneManager/TestCulling/TestCullingApplication.h @ 18

/**
    \file 
        TestCullingApplication.h
*/
#include "CEGUIForwardRefs.h"
#include "ExampleApplication.h"


class MouseQueryListener : public ExampleFrameListener, public MouseListener, public MouseMotionListener
{
public:

    MouseQueryListener(RenderWindow* win, Camera* cam, SceneManager *sceneManager, CEGUI::Renderer *renderer,
                                           SceneNode* shipNode)
        : ExampleFrameListener(win, cam, false, true), mGUIRenderer(renderer), mShipNode(shipNode)
    {
                // Setup default variables
        mCurrentObject = NULL;
        mLMouseDown = false;
        mRMouseDown = false;
        mSceneMgr = sceneManager;

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

                // Register this so that we get mouse events.
        mEventProcessor->addMouseListener( this );
        mEventProcessor->addMouseMotionListener( this );
    } // MouseQueryListener

    ~MouseQueryListener( )
    {
    }

    bool frameStarted(const FrameEvent &evt)
    {
        return ExampleFrameListener::frameStarted( evt );
    }

   /* MouseListener callbacks. */
   virtual void mouseClicked(MouseEvent* e) { }
   virtual void mouseEntered(MouseEvent* e) { }
   virtual void mouseExited(MouseEvent* e)  { }

   // This is when the mouse button goes DOWN.
   virtual void mousePressed(MouseEvent* e);

   // This is when the mouse button is let UP.
   virtual void mouseReleased(MouseEvent* e);

   /* MouseMotionListener callbacks */
   virtual void mouseMoved (MouseEvent *e);
   
   // This is when the mouse is clicked, held and dragged.
   virtual void mouseDragged (MouseEvent *e);

protected:
    bool mLMouseDown, mRMouseDown;     // True if the mouse buttons are down
    SceneManager *mSceneMgr;           // A pointer to the scene manager
    SceneNode *mCurrentObject;         // The newly created object
    CEGUI::Renderer *mGUIRenderer;     // cegui renderer
        SceneNode* mShipNode;
};


class TestCullingFrameListener : public ExampleFrameListener
{
protected:
    SceneNode* mShipNode;

public:
    TestCullingFrameListener(RenderWindow* win, Camera* cam, SceneNode* shipNode) : ExampleFrameListener(win, cam)
    {
                mShipNode = shipNode;
    };

        bool frameStarted(const FrameEvent& evt)
        {
                Real MoveFactor = 80.0 * evt.timeSinceLastFrame;
 
                mInputDevice->capture();
 
                if(mInputDevice->isKeyDown(Ogre::KC_UP))
                        mShipNode->translate(0.0, MoveFactor, 0.0);
 
                if(mInputDevice->isKeyDown(Ogre::KC_DOWN))
                        mShipNode->translate(0.0, -MoveFactor, 0.0);
 
                if(mInputDevice->isKeyDown(Ogre::KC_LEFT))
                        mShipNode->translate(-MoveFactor, 0.0, 0.0);
 
                if(mInputDevice->isKeyDown(Ogre::KC_RIGHT))
                        mShipNode->translate(MoveFactor, 0.0, 0.0);             
 
                if(mInputDevice->isKeyDown(Ogre::KC_ESCAPE))
                        return false;
 
                return true;
        }
};

class TestCullingApplication : public ExampleApplication
{
public:
    /*TestCullingApplication()
    {


    }*/

protected:
        void createScene(void);

        void createFrameListener(void)
    {
                mFrameListener= new MouseQueryListener(mWindow, mCamera, mSceneMgr, mGUIRenderer, mShipNode);
                mFrameListener->showDebugOverlay(true);
                mRoot->addFrameListener(mFrameListener);
    }

        CEGUI::OgreCEGUIRenderer *mGUIRenderer;
        CEGUI::System *mGUISystem;

private:
        Entity* mShip;
        SceneNode* mShipNode;

/*    String mQuakePk3;
    String mQuakeLevel;

    // Override resource sources (include Quake3 archives)
    void setupResources(void)
    {

        // Load Quake3 locations from a file
        ConfigFile cf;

        cf.load("quake3settings.cfg");

        mQuakePk3 = cf.getSetting("Pak0Location");
        mQuakeLevel = cf.getSetting("Map");

                ExampleApplication::setupResources();
        ResourceManager::addCommonArchiveEx(mQuakePk3, "Zip");

    }*/
    // Override scene manager (use indoor instead of generic)
    void chooseSceneManager(void)
    {
        mSceneMgr = mRoot->getSceneManager(ST_GENERIC);
                //mSceneMgr = mRoot->getSceneManager(ST_INTERIOR);
    }
        /*
    // Scene creation
    void createScene(void)
    {

        // Load world geometry
        mSceneMgr->setWorldGeometry(mQuakeLevel);

        // modify camera for close work
        mCamera->setNearClipDistance(4);
        mCamera->setFarClipDistance(4000);

        // Also change position, and set Quake-type orientation
        // Get random player start point
        ViewPoint vp = mSceneMgr->getSuggestedViewpoint(true);
        mCamera->setPosition(vp.position);
        mCamera->pitch(Degree(90)); // Quake uses X/Y horizon, Z up
        mCamera->rotate(vp.orientation);
        // Don't yaw along variable axis, causes leaning
        mCamera->setFixedYawAxis(true, Vector3::UNIT_Z);
    }*/

};