source: GTP/trunk/App/Demos/Vis/KdTreeDemo/OGRE/include/TestKdTreeAppListener.h @ 2455

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

You may use this sample code for anything you like, it is not covered by the
LGPL like the rest of the engine.
-----------------------------------------------------------------------------
*/
/*
-----------------------------------------------------------------------------
Filename:    ExampleFrameListener.h
Description: Defines an example frame listener which responds to frame events.
This frame listener just moves a specified camera around based on
keyboard and mouse movements.
Mouse:    Freelook
W or Up:  Forward
S or Down:Backward
A:        Step left
D:        Step right
             PgUp:     Move upwards
             PgDown:   Move downwards
             F:        Toggle frame rate stats on/off
                         R:        Render mode
             T:        Cycle texture filtering
                       Bilinear, Trilinear, Anisotropic(8)
             P:        Toggle on/off display of camera position / orientation
-----------------------------------------------------------------------------
*/

#ifndef __KdTreeAppListener_H__
#define __KdTreeAppListener_H__

#include <Ogre.h>
#include <OgreKeyEvent.h>
#include <OgreEventListeners.h>
#include <OgreStringConverter.h>
#include <OgreException.h>
#include <OgreTextAreaOverlayElement.h>

#include <OgreKdTree.h>

#define CONV_OCM_TO_KDT_ALG(i) (i == 0 ? 3 : i)
#define CONV_KDT_TO_OCM_ALG(i) (i % 3)
#define VIZ_VIEWPORT_Z_ORDER 10

#define TERRAIN_SCENE "terrain"

using namespace Ogre;

struct FrameInfo
{
        FrameInfo(Vector3 pos, Quaternion or, Real time):
        mPosition(pos), mOrientation(or), mElapsedTime(time)
        { }

        Vector3 mPosition;
        Quaternion mOrientation;
        Real    mElapsedTime;
};

typedef std::list<FrameInfo> FrameList;

class KdTreeApp;

class KdTreeAppListener: public FrameListener, public KeyListener
{

public:
        // visualization modes for scene nodes
        enum VizMode
        {
                NODEVIZ_NONE, 
                NODEVIZ_RENDER_NODES, 
                NODEVIZ_RENDER_NODES_AND_CONTENT, 
                NODEVIZ_RENDER_PVS,
                NODEVIZ_MODES_NUM
        };

        enum SceneType
        {
                ST_SIMPLE,
                ST_TERRAIN,
                ST_GEOMETRY
        };

        enum SceneMgr
        {
                SM_KDT,
                SM_KTE,
                SM_BVH,
                SM_BIH,
                SM_OCM,
                SM_OCT,
                SM_TER,
                SM_GEN,
                SM_SIZE,
                SM_NOTSET
        };

        enum ViewCellsMode
        {
                VCM_OFF,
                VCM_ON,
                VCM_FILTER,
                VCM_SIZE,
                VCM_NOTSET
        };

        enum ShowTree
        {
                SHOWTREE_OFF,
                SHOWTREE_HILITE,
                SHOWTREE_ALL,
                SHOWTREE_MODES_NUM
        };

        enum AppState
        {
                AS_NORMAL,
                AS_RECORD,
                AS_PLAYBACK
        };

        struct Options
        {
                Options():
                mRotateSpeed(36.0f),
                mMoveSpeed(100.0f),
                mRotationPeriod(30.0f),
                mKT(2.0f),
                mKI(1.0f),
                mMaxDepth(10),
                mSceneManager(SM_BVH),  //changed cse 
                mRenderMethod(KdTree::KDRM_GTP_CHC),
                mBuildMethod(KdTree::KDBM_RECURSIVE),
                mSceneType(ST_SIMPLE),
                mViewCells(VCM_OFF),
                mDelRenderQueue(true),
                mFastStart(false),
                mBurnIn(false),
                mDemoMode(false),
                mEnhancedVisibility(false),
                mDemoInterval(1.0f),
                myApp(0)
                {

                }

                String mSceneOutfileName;
                String mDemoInfileName;
                String mDemoOutfileName;
                String mDemoLogfileName;
                String mComment;
                Degree mRotateSpeed;
                Real mMoveSpeed;
                Real mRotationPeriod;
                Real mKT;
                Real mKI;
                int mMaxDepth;
                int mSceneManager;
                int mRenderMethod;
                int mBuildMethod;
                int mSceneType;
                int mViewCells;
                bool mDelRenderQueue;
                bool mFastStart;
                bool mBurnIn;
                bool mDemoMode;
                bool mEnhancedVisibility;
                Real mDemoInterval;
                KdTreeApp *myApp;
        };

        struct DemoStats
        {
                unsigned int mTotalNumFrames;
                unsigned int mNumFrames;
                Real mTotalEllapsedTime;
                Real mEllapsedTime;
        } mDemoStats;

    // Constructor takes a RenderWindow because it uses that to determine input context
    KdTreeAppListener(RenderWindow* win, SceneManager* sm, const Options& options,  
                bool useBufferedInputKeys = false, bool useBufferedInputMouse = false);

    virtual ~KdTreeAppListener(void);

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

        void initStatsOverlay(void);

        void initKdTreeOverlay(void);

        void showDebugOverlay(bool show);

        void toggleUseViewCells(void);

        void toggleUseVisibilityFilter(void);

        void toggleVizCamera(void);

        void toggleShowBoxes(void);

        void toggleEnhancedVisibility(void);

        void toggleBuildMethod(void);

        void toggleRenderMethod(void);

    virtual bool processUnbufferedKeyInput(const FrameEvent& evt);

    bool processUnbufferedMouseInput(const FrameEvent& evt);

        void moveCamera(void);

    // Override frameStarted event to process that (don't care about frameEnded)
    bool frameStarted(const FrameEvent& evt);

    bool frameEnded(const FrameEvent& evt);

        void switchMouseMode(void);

        void switchKeyMode(void);

        void keyClicked(KeyEvent* e);

        void keyPressed(KeyEvent* e) {};
        void keyReleased(KeyEvent* e) {};

        const static Real       DEMO_WAIT;
        const static String NA;
        const static String RENDERMETHOD[];
        const static String RENDERMETHODCAPTION[];
        const static String BUILDMETHOD[];
        const static String BUILDMETHODCAPTION[];
        const static String SCENEMANAGER[];
        const static String SCENEMANAGERNAME[];
protected:
        // basic
        RenderWindow* mWindow;
        SceneManager *mSceneMgr;
        Options mOptions;
        bool mUseBufferedInputKeys, mUseBufferedInputMouse, mInputTypeSwitchingOn;

        // elements
        SceneNode *mCamNode;
        Camera* mCamera;
        Camera* mTopCam;

        // toggle
        bool mStatsOn;

        bool mVizCamera;
        bool mFreeMove;
        bool mTopCamFollow;

        int mShowTree;

        // view cells
        bool mViewCellsLoaded;
        bool mUseViewCells;
        bool mUseVisibilityFilter;

        // counters
        int mSeqNum;
        unsigned int mNumScreenShots;

        // rendering/texture options
        int mSceneDetailIndex;
        TextureFilterOptions mFiltering;
        int mAniso;

        // chc stats
        Real mDelayedQueriesIssued;
        Real mDelayedTraversedNodes;

        // overlays
        Overlay *mDemoOverlay;
        Overlay *mDebugOverlay;
        Overlay *mKdTreeOverlay;
        Overlay *mLoadingOverlay;

        OverlayElement *mMyLoadingInfo;
        OverlayElement *mDemoStatus;
        TextAreaOverlayElement *mDemoTime;
        TextAreaOverlayElement *mDemoFPSDisp;

        OverlayElement *mRenderMethodInfo;
        OverlayElement *mEnhancedVisInfo;
        OverlayElement *mBuildMethodInfo;
        OverlayElement *mKdTreeMaxDepthInfo;
        OverlayElement *mHighlightLevelInfo;
        OverlayElement *mKTInfo;
        OverlayElement *mKIInfo;
        OverlayElement *mMovementInfo;
        OverlayElement *mTopCamInfo;
        OverlayElement *mViewCellsInfo;
        OverlayElement *mViewFilterInfo;

        OverlayElement *mFrustumCulledNodesInfo;
        OverlayElement *mQueryCulledNodesInfo;
        OverlayElement *mTraversedNodesInfo;
        OverlayElement *mHierarchyNodesInfo;
        OverlayElement *mRenderedNodesInfo;
        OverlayElement *mObjectsCountInfo;
        OverlayElement *mQueriesIssuedInfo;

        // input
        EventProcessor* mEventProcessor;
        InputReader* mInputDevice;

        // movement
        Vector3 mTranslateVector;
        Vector3 mVizCamTransVect;
        Radian mRotX, mRotY;
        float mMoveScale;
        Degree mRotScale;
        Radian mDeathAngle;
        // for terrain
        RaySceneQuery *mRaySceneQuery;

        // just to stop toggles flipping too fast
        Real mTimeUntilNextToggle ;

        // stuff for walkthrough recording/playback
        //std::ofstream mDemoFramesLog;
        std::list<Real> mDemoFPS;
        Real mTimeUntilNextLogWrite;
        FrameList mFrameList;
        FrameList::iterator mCurrFrame;
        Real mTimeRemaining;
        Real mWaitBeforeDemoStart;

        AppState mAppState;

        void setDemoOverlay();

        void toggleRecord();
        void togglePlayback();

        /** write FPS stats to log file (csv) **/
        void saveLog();

        void saveFrameInfo(Real elapsedTime);

        /** save demo frame data to file **/
        static void saveFrames(const String& filename, FrameList& framelist);
        static void saveFramesAscii(const String& filename, FrameList& framelist);
        static void saveFramesBinary(const String& filename, FrameList& framelist);

        /** load demo frame data from file **/
        static void loadFrames(const String& filename, FrameList& framelist);
        static void loadFramesAscii(const String& filename, FrameList& framelist);
        static void loadFramesBinary(const String& filename, FrameList& framelist);

        void updateStats(void);
};

#endif