source: trunk/VUT/work/iv/IVFrameListener.h @ 259

#ifndef _IVFrameListener_H__
#define _IVFrameListener_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"



class TestCullingIVApplication;


using namespace Ogre;


/** Frame listener specialised for terrains.
*/
class IVFrameListener: public FrameListener, public MouseListener, 
                                                        public MouseMotionListener, public KeyListener
{
public:

        IVFrameListener(RenderWindow* win, 
                                                Camera* cam, 
                                                SceneManager *sceneManager, 
                                                CEGUI::Renderer *renderer, 
                                                Camera *vizCamera,
                                                SceneNode *camNode, 
                                                Light *sunLight,
                                                TestCullingIVApplication *app);

        ~IVFrameListener();


        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.
        void mousePressed(MouseEvent* e);

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

        /* MouseMotionListener callbacks */
        void mouseMoved(MouseEvent *e);

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

        void mouseDragDropped(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();

        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();

        bool Clamp2Floor();

        static String msAlgorithmCaptions[];
                
        protected:

        void initHelpOverlayElement(String name, int top);
        void initOverlayElement(OverlayElement **elInfo, String ext, String name, 
                                                        int top, String caption);

        //-- initialise overlays
        void initHelpOverlay();
        void initVisStatsOverlay();
        void initQueryOverlay();

        void resetStats();

        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;
        // visualization mode
        int mNodeVizMode;


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

        OverlayElement *mQueryTypeInfo;
        OverlayElement *mQueryVisibleNodesInfo;
        OverlayElement *mQueryVisibleGeometryInfo;
        OverlayElement *mQueryVisiblePatchInfo;

        OverlayElement *mQueryVisiblityInfo;
        OverlayElement *mQueryNodeVisibilityInfo;
        OverlayElement *mQueryGeometryVisibilityInfo;
        OverlayElement *mQueryPatchVisibilityInfo;
        //OverlayElement *mHelpInfo;
        
        bool mTestGeometryForVisibleLeaves;
        bool mShowOctree;
        bool mUseDepthPass;
        bool mShowVisualization;
        bool mCullCamera;
        bool mRecordFrames;
        bool mShowShadows;
        bool mVisualizeCulledNodes;
        bool mShowHelp;
        bool mStatsOn;
        bool mLMouseDown, mRMouseDown;     // True if the mouse buttons are down
        bool mShutdownRequested;
        bool mDisplayCameraDetails;
        bool mUseItemBuffer;
        bool mUseAnimation;

        int mItemBufferMode;

        Real mVizCameraHeight;

        Camera *mVizCamera;
        SceneNode *mCamNode;

        std::vector<frame_info> mFrameInfo;
                
        Real mReplayTimeElapsed;
        //EventProcessor* mEventProcessor;
        InputReader* mInputDevice;
        Camera* mCamera;

        Vector3 mTranslateVector;
        RenderWindow* mWindow;

        unsigned int mNumScreenShots;
        int mSceneDetailIndex;
        int mAniso;

        float mMoveScale;
        Real mMoveSpeed;
        Degree mRotScale;

        // just to stop toggles flipping too fast
        Real mTimeDelay;
        Radian mRotX, mRotY;
        TextureFilterOptions mFiltering;

        Degree mRotateSpeed;

        Overlay* mDebugOverlay;
        Overlay* mHelpOverlay;
        Overlay* mCullStatsOverlay;
        Overlay* mQueryOverlay;

        Light *mSunLight;
        GtpVisibility::VisibilityManager *mVisibilityManager;
        EventProcessor* mEventProcessor;

        bool mShiftPressed;
        bool mShowQueryStats;

        unsigned long mAccumulatedFps;
        unsigned long mAccumulatedTris;
        unsigned long mFrameCount;

        //bool mUseBufferedInputKeys, mUseBufferedInputMouse, mInputTypeSwitchingOn;
        
        float mDelayedQueriesIssued;
        float mDelayedTraversedNodes;

        TestCullingIVApplication *mApplication;
        RaySceneQuery *mRaySceneQuery;
};


#endif //_IVFrameListener_H__