source: GTP/trunk/App/Demos/Vis/HillyTerrain/OGRE/TestCullingTerrainApplication.h @ 924

#ifndef _TestCullingTerrainApplication_H__
#define _TestCullingTerrainApplication_H__

#include "CEGUIForwardRefs.h"
#include <OgreRenderTargetListener.h>
#include "ExampleApplication.h"

#include "OgreTerrainContentGenerator.h"
#include "TerrainFrameListener.h"

#include <OgreEntity.h>
#include <string>

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

class IVReader;

//-- constants for animation
const float walk_duration = 10.0f;
const float wait_duration = 2.0f;
const float rotate_factor = 0.7f;
const float move_factor = 0.03;


/** Rendertarget listener which shows a visualization.
*/
class VisualizationRenderTargetListener: public RenderTargetListener
{
public:
        VisualizationRenderTargetListener(SceneManager *sceneMgr);

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

        SceneManager *mSceneMgr;
        
        ShadowTechnique mSavedShadowTechnique;
        ColourValue mSavedAmbientLight;
};

/** Class storing the current state of an entity.
*/
class EntityState
{
public:
        enum State {STOP, WAITING, MOVING};

        EntityState(Entity *ent, State entityState, Real speed);
        ~EntityState();
        /** Update the entity state.
        */
        void update(Real timeSinceLastFrame);

        /** Returns entity.
        */
        Entity *GetEntity();

        /** Returns entity state index.
        */
        EntityState::State GetState();

        static bool OutOfBounds(SceneNode *node);

        static Vector3 msMinPos;
        static Vector3 msMaxPos;

protected:

        void SetAnimationState(String stateStr, bool loop);

        AnimationState *mAnimationState;
        Entity *mEntity;

        State mState;
        Real mAnimationSpeed;
        Real mTimeElapsed;
};

typedef std::vector<EntityState *> EntityStates;

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

        /** Generates a scene using num entities of a type. 
                @param num the number of objects
                @parma objectType the type of objects
        */
        void generateScene(int num, int objectType);

        /** Returns the caption of the given id of a scene object type.
        */
        String getCurrentObjectCaption(int id);

        /** Returns state vector of scene entities.
        */
        EntityStates &getEntityStates();

        /** Updates all animations according to time elapsed since last frame.
        */
    void updateAnimations(Real timeSinceLastFrame);

        /** Deletes vector of scene entity states.
        */
        void deleteEntityStates();

        // object types
        enum {ROBOT, TREE, NINJA};

        
        /** Clamps scene node to terrain.
                @param sceneNode the node to be clamped
                @param terrainOffs the offset of the node over the terrain
                @returns if clamping was successful (i.e., the ray hit the terrain)
        */
        bool Clamp2Terrain(SceneNode *node, int terrainOffs);

        /** Clamps camera to floor plane: used for vienna set.
        */
        bool Clamp2FloorPlane();

        /** Loads iv geometry.
        */
        bool LoadSceneIV(const String &filename, SceneNode *root, const int index);

        bool LoadScene(const std::string filename);

        bool LoadViewCells(const std::string filename);

        /** Loads configuration from disc.
        */
        void loadConfig(const String& filename);
        // if hilly terrain should be loaded
        static bool msShowHillyTerrain;

protected:

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

        void BakeSceneIntoStaticGeometry(const String &staticGeomName,
                                                                         const String &nodeName);

        std::vector<EntityState *> mEntityStates;

        /** 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;

        TerrainFrameListener *mTerrainFrameListener;
        ColourValue mAmbientLight;
        RayQueryExecutor *mRayQueryExecutor;

        Vector3 mTerrainMinPos;
        Vector3 mTerrainMaxPos;

        IVReader *mIVReader;
        
        StaticGeometry *mStaticGeometry;

        String mFilename;
        //String mViewCellsFilename;

private:
        void chooseSceneManager(void);
};

#endif // TestCullingTerrainApplication