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

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

Real timeDelay = 0;
#define KEY_PRESSED(_key,_timeDelay, _macro) \
{ \
    if (mInputDevice->isKeyDown(_key) && timeDelay <= 0) \
{ \
    timeDelay = _timeDelay; \
    _macro ; \
} \
}

String mCurrentAlgorithmCaptions[OcclusionCullingSceneManager::NUM_RENDERMODES] = 
{
    "Cull Frustum", 
        "Stop and Wait", 
        "Coherent Occlusion Culling"
};

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

    MouseQueryListener(RenderWindow* win, Camera* cam, SceneManager *sceneManager, CEGUI::Renderer *renderer,
                                           SceneNode* shipNode);


    ~MouseQueryListener( )
    {
    }

        bool frameEnded(const FrameEvent& 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);
/*
    void 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 keyReleased(KeyEvent* e)
        {
                CEGUI::System::getSingleton().injectKeyUp(e->getKey());
                e->consume();
        }
        void keyClicked(KeyEvent* e) 
        {
                // Do nothing
                e->consume();
        }

    bool frameEnded(const FrameEvent& evt)
    {
        if (mShutdownRequested)
            return false;
        else
            return ExampleFrameListener::frameEnded(evt);
    }
*/
        void changeAlgorithm();


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;
//      bool mShutdownRequested;
        int mCurrentAlgorithm;
        OverlayElement *mAlgorithmInfo;
};


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

    }*/

protected:
        void createScene(void);
        void createFrameListener(void);

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

private:
        void chooseSceneManager(void);

        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)
    

        
};