source: branches/VUT/0.2/work/TestCullingTerrain/TestCullingTerrainApplication.h @ 183

#ifndef _TestCullingTerrainApplication_H__
#define _TestCullingTerrainApplication_H__

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

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

#include <OgreEntity.h>

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


//-- 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, ATHENA, 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);

protected:

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

        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;


private:
        void chooseSceneManager(void);
};

#endif // TestCullingTerrainApplication