source: trunk/VUT/work/TestCullingTerrain/TerrainFrameListener.h @ 155

#ifndef _TerrainFrameListener_H__
#define _TerrainFrameListener_H__

#include "CEGUIForwardRefs.h"
#include <Ogre.h>
#include <OgreKeyEvent.h>
#include <OgreEventListeners.h>
#include <OgreStringConverter.h>
#include <OgreException.h>
#include "VisibilityEnvironment.h"
#include "VisibilityManager.h"
#include "OgreTerrainContentGenerator.h"
#include "OgrePlatformQueryManager.h"

using namespace Ogre;

// z order index of visualizaion viewport
#define VIZ_VIEWPORT_Z_ORDER 10


/** Mouse query listener for terrain 
*/
class TerrainFrameListener: public FrameListener, public MouseListener, public MouseMotionListener, public KeyListener
{
public:
        
   TerrainFrameListener(RenderWindow* win, Camera* cam, SceneManager *sceneManager, 
                CEGUI::Renderer *renderer, TerrainContentGenerator *contentGenerator, Camera *vizCamera,
                SceneNode *camNode, Light *sunLight);

   ~TerrainFrameListener();


   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);
  
   /** The information about camera position and orienation per frame */
   typedef struct
   {
           Vector3 position;
           Quaternion orientation;
           Real timeElapsed;
   } frame_info;

   enum  {WALKTHROUGH, REPLAY, STATE_NUM};

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

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

   void setAlgorithm(int algorithm);

   void moveCamera();

   void writeFrames();
   void loadFrames();

  
    // Constructor takes a RenderWindow because it uses that to determine input context
    //ExampleFrameListener(RenderWindow* win, Camera* cam, bool useBufferedInputKeys = false, bool useBufferedInputMouse = false)
    
    bool processUnbufferedKeyInput(const FrameEvent& evt);
    bool processUnbufferedMouseInput(const FrameEvent& evt);

    void showStats(bool show);

        void updateStats();

        void toggleShowHelp();
        void toggleShowStats();

        void toggleShowShadows();
        void toggleDisplayCameraDetails();
        void takeScreenShot();
        void nextSceneDetailLevel();
        void nextFilter();
        void nextAlgorithm();
        void nextNodeVizMode();
        void nextAppState();
    void changeThreshold(int incr);
        void changeAssumedVisibility(int incr);
        void toggleTestGeometryForVisibleLeaves();
        void toggleShowOctree();
        void toggleUseDepthPass();
        void toggleShowViz();
        void toggleRecord();

        /** Applies visibility query. Collects the visible objects 
                and their visibility information.
                @param fromPoint if query should be from point or from camera
                @param relativeVisibility if query should return number of visible pixels or 
                the ratio visible / projected pixels.
                @param useItemBuffer if item buffer should be used or occlusion queries
        */
        void ApplyVisibilityQuery(bool fromPoint, bool relativeVisibility, bool useItemBuffer);

        void toggleShowQueryStats();

protected:

        void resetStats();

        /** Clamp camera to terrain.
        */
        void Clamp2Terrain();
        
        SceneManager *mSceneMgr;           // A pointer to the scene manager
    
        CEGUI::Renderer *mGUIRenderer;     // cegui renderer
        
        int mCurrentAlgorithm;
        int mVisibilityThreshold;
        int mAssumedVisibility;
        // the current frame number
        int mCurrentFrame;
        // the current application state
        int mAppState;
        // The number of objects on the screen
        int mObjectCount;            
        // visualization mode
        int mNodeVizMode;

        SceneNode *mCurrentObject;    // the newly created object

        OverlayElement *mAlgorithmInfo;
        OverlayElement *mThresholdInfo;
        OverlayElement *mAssumedVisibilityInfo;
        OverlayElement *mFrustumCulledNodesInfo;
        OverlayElement *mQueryCulledNodesInfo;
    OverlayElement *mTraversedNodesInfo;
        OverlayElement *mHierarchyNodesInfo;
        OverlayElement *mTestGeometryForVisibleLeavesInfo;
        OverlayElement *mUseDepthPassInfo;
        OverlayElement *mRenderedNodesInfo;
        OverlayElement *mObjectsInfo;
        OverlayElement *mQueriesIssuedInfo;
        OverlayElement *mDelayedQueriesIssuedInfo;
        OverlayElement *mDelayedTraversedNodesInfo;

        OverlayElement *mQueryTypeInfo;
        OverlayElement *mQueryVisibleNodesInfo;
    OverlayElement *mQueryVisibleGeometryInfo;
        OverlayElement *mQueryVisiblityInfo;
        OverlayElement *mQueryNodeVisibilityInfo;
        OverlayElement *mQueryGeometryVisibilityInfo;

        RayQueryExecutor *mRayQueryExecutor;
        TerrainContentGenerator *mTerrainContentGenerator;

        bool mTestGeometryForVisibleLeaves;
        bool mShowOctree;
        bool mUseDepthPass;
        bool mShowVisualization;
        bool mCullCamera;
        bool mRecord;
        bool mShowShadows;
        bool mVisualizeCulledNodes;
        bool mShowHelp;
        bool mStatsOn;
        bool mLMouseDown, mRMouseDown;     // True if the mouse buttons are down
        bool mShutdownRequested;
        bool mDisplayCameraDetails;
        
        Real mVizCameraHeight;

        Camera *mVizCamera;
        SceneNode *mCamNode;
        
        //std::deque<Vector3> mWalkList;   // The list of points we are walking to
        std::vector<frame_info> mFrameInfo;
                
        Real mTimeElapsed;
        //EventProcessor* mEventProcessor;
    InputReader* mInputDevice;
    Camera* mCamera;

    Vector3 mTranslateVector;
    RenderWindow* mWindow;
   
    //bool mUseBufferedInputKeys, mUseBufferedInputMouse, mInputTypeSwitchingOn;
        unsigned int mNumScreenShots;
    int mSceneDetailIndex;
        int mAniso;

        float mMoveScale;
    Degree mRotScale;
    // just to stop toggles flipping too fast
    Real mTimeDelay;
    Radian mRotX, mRotY;
    TextureFilterOptions mFiltering;
  
        Real mMoveSpeed;
    Degree mRotateSpeed;
    
        Overlay* mDebugOverlay;
        Overlay* mHelpOverlay;
        Overlay* mCullStatsOverlay;
        Overlay* mQueryOverlay;

        Light *mSunLight;
        GtpVisibility::VisibilityManager *mVisibilityManager;
        EventProcessor* mEventProcessor;
        
        bool mShiftPressed;
        bool mShowQueryStats;

        unsigned long mAvgFps;
        unsigned long mFrameCount;
        //bool mUseBufferedInputKeys, mUseBufferedInputMouse, mInputTypeSwitchingOn;
        PlatformQueryManager *mQueryManager;

        float mDelayedQueriesIssued;
        float mDelayedTraversedNodes;
};


#endif //_TerrainFrameListener_H__