source: trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.h @ 113

/**
    \file 
        TestCullingTerrainApplication.h
*/
#include "CEGUIForwardRefs.h"
#include "ExampleApplication.h"
#include "OgreTerrainContentGenerator.h"
#include "VisibilityEnvironment.h"
#include <OgreRenderTargetListener.h>
#include <vector>

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

String mCurrentAlgorithmCaptions[GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS] = 
{
    "View Frustum Culling", 
        "Stop and Wait Culling", 
        "Coherent Hierarchical Culling"
};

/** The information about camera position and orienation per frame */
typedef struct
{
        Vector3 position;
        Quaternion orientation;
        Real timeElapsed;
} frame_info;


class VisualizationRenderTargetListener: public RenderTargetListener
{
public:
        VisualizationRenderTargetListener(SceneManager *sceneMgr);

protected:
        void preViewportUpdate (const RenderTargetViewportEvent &evt);
        void postRenderTargetUpdate (const RenderTargetEvent &evt);

        SceneManager *mSceneMgr;
};

class MouseQueryListener : public ExampleFrameListener, public MouseListener, public MouseMotionListener
{
public:
        
    MouseQueryListener(RenderWindow* win, Camera* cam, SceneManager *sceneManager, 
                CEGUI::Renderer *renderer, TerrainContentGenerator *contentGenerator, Camera *vizCamera,
                SceneNode *camNode);

    ~MouseQueryListener();

        bool frameStarted(const FrameEvent& evt);
        bool frameEnded(const FrameEvent& evt);
        bool processUnbufferedKeyInput(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);

        void keyReleased(KeyEvent* e);
        void keyClicked(KeyEvent* e);

        enum  {WALKTHROUGH, REPLAY, STATE_NUM};

        // visualization modes for scene nodes
        enum {NODEVIZ_NONE, NODEVIZ_RENDER_NODES, 
                  NODEVIZ_RENDER_NODES_AND_CONTENT, NODEVIZ_MODES_NUM};

        void nextAlgorithm();
        void changeThreshold(int incr);
        void updateStats();

        void toggleUseOptimization();
        void toggleShowOctree();
        void toggleUseVisibilityCulling();
        void toggleShowViz();
        void nextNodeVizMode();
        void toggleRecord();

        void zoomVizCamera(int zoom);
        
        void addFrameInfo(SceneNode *camNode, Real timeElapsed);
        void setCurrentFrameInfo(Real timeElapsed);

        void setAppState(int state);
        void nextAppState();

        void setAlgorithm(int algorithm);

        void moveCamera();
        
        void writeFrames();
        void loadFrames();

        void toggleUseShadows();

protected:
        void Clamp2Terrain();
        
    bool mLMouseDown, mRMouseDown;     // True if the mouse buttons are down
    SceneManager *mSceneMgr;           // A pointer to the scene manager
    
        CEGUI::Renderer *mGUIRenderer;     // cegui renderer
        
        bool mShutdownRequested;
        int mCurrentAlgorithm;
        int mVisibilityThreshold;
        
        OverlayElement *mAlgorithmInfo;
        OverlayElement *mThresholdInfo;
        OverlayElement *mFrustumCulledNodesInfo;
        OverlayElement *mQueryCulledNodesInfo;
    OverlayElement *mTraversedNodesInfo;
        OverlayElement *mHierarchyNodesInfo;
        OverlayElement *mUseOptimizationInfo;
        OverlayElement *mRenderedNodesInfo;
        OverlayElement *mObjectsInfo;
        OverlayElement *mQueriesIssuedInfo;

        SceneNode *mCurrentObject;    // the newly created object
        int mObjectCount;             // The number of objects on the screen

        RayQueryExecutor *mRayQueryExecutor;
        TerrainContentGenerator *mTerrainContentGenerator;

        bool mUseOptimization;
        bool mShowOctree;
        bool mUseVisibilityCulling;
        bool mShowVisualization;
        int mNodeVizMode;
        bool mCullCamera;

        Real mVizCameraHeight;

        Camera *mVizCamera;
        SceneNode *mCamNode;
        
        //std::deque<Vector3> mWalkList;   // The list of points we are walking to
        std::vector<frame_info> mFrameInfo;
                
        int mCurrentFrame;
        // the current application state
        int mAppState;
        bool mRecord;
        Real mTimeElapsed;
        bool mUseShadows;

        bool mVisualizeCulledNodes;
};


class TestCullingTerrainApplication : public ExampleApplication
{
public:
        ~TestCullingTerrainApplication();

protected:
        //-- inherited from ExampleApplication
        bool setup();
        void createScene();
        void createFrameListener();
        void createCamera();
        //void createViewports();
        
        virtual void createRenderTargetListener();

        /** cegui setup */
        void setupGui();

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

        Vector3 mMinTranslation;
        Vector3 mMaxTranslation;

        Vector3 mMinAngle;
        Vector3 mMaxAngle;

        TerrainContentGenerator *mTerrainContentGenerator;
        
        Camera *mVizCamera;
        SceneNode *mCamNode;
        Light *mSunLight;
        VisualizationRenderTargetListener *mRenderTargetListener;

private:
        void chooseSceneManager(void);
};