Changeset 161 for trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.cpp

Timestamp:

07/08/05 17:34:05 (19 years ago)

Author:

mattausch

Message:

added moving robots

File:

• trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.cpp (modified) (6 diffs)

trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.cpp

@@ -7 +7 @@
 
 #include <Ogre.h>
+
 //#include "OgreReferenceAppLayer.h"
 //#include "OgreRefAppWorld.h"
@@ -23 +24 @@
 };
 
+/***************************************/
+/*      EntityState implementation     */
+/***************************************/
+EntityState::EntityState(Entity *ent, State entityState, Real speed):
+mEntity(ent), mState(entityState), mAnimationSpeed(speed)
+{
+        switch(entityState)
+        {
+        case MOVING:
+                mAnimationState = mEntity->getAnimationState("Walk");
+                break;
+        case WAITING:
+                mAnimationState = mEntity->getAnimationState("Idle");
+                break;
+        case STOP:
+                mAnimationState = NULL;
+                break;
+        default:
+                break;
+        }
+        // enable animation state
+        if (mAnimationState)
+        {
+                mAnimationState->setLoop(true);
+                mAnimationState->setEnabled(true);
+        }
+        mTimeElapsed = Math::RangeRandom(1, 5);
+}
+//-----------------------------------------------------------------------
+Entity *EntityState::GetEntity()
+{
+        return mEntity;
+}
+//-----------------------------------------------------------------------
+EntityState::State EntityState::GetState()
+{
+        return mState;
+}
+//-----------------------------------------------------------------------
+void EntityState::update(Real timeSinceLastFrame)
+{
+        mTimeElapsed -= timeSinceLastFrame * mAnimationSpeed;
+        
+        if (mState == MOVING) // toggle between moving (longer) and waiting (short)
+        {
+                SceneNode *parent = mEntity->getParentSceneNode();
+
+                if (mTimeElapsed <= 0) // toggle animation state
+                {
+                        if (mAnimationState->getAnimationName() == "Idle")
+                        {
+                                SetAnimationState("Walk", true);
+                                mTimeElapsed = 10; // walk for mTimeElapsed units
+
+                                // choose random direction between zero and two pi
+                                Radian rnd = Radian(Math::UnitRandom() * Math::HALF_PI);
+
+                                //mEntity->getParentSceneNode()->rotate();
+                                parent->yaw(rnd);                                               
+                        }
+                        else 
+                        {
+                                SetAnimationState("Idle", true);
+                                mTimeElapsed = 2; // wait for mTimeElapsed seconds
+                        }
+                }
+
+                if (mAnimationState->getAnimationName() == "Walk")
+                {
+                        Vector3 oldPos = parent->getPosition();
+
+                        parent->translate(parent->getLocalAxes(), Vector3(0.03 * mAnimationSpeed, 0, 0));
+
+                        // HACK: if out of bounds => go back to idle
+                        if (OutOfBounds(parent)) 
+                        {
+                                parent->setPosition(oldPos);
+                                SetAnimationState("Idle);
+                                
+                                mTimeElapsed = 2;
+                        }
+                }
+        }
+                
+        if (mAnimationState) // add time to drive animation
+        {
+                mAnimationState->addTime(timeSinceLastFrame * mAnimationSpeed);
+        }
+}
+//-----------------------------------------------------------------------
+void EntityState::SetAnimationState(String stateStr, bool loop)
+{
+        mAnimationState = mEntity->getAnimationState(stateStr);
+        mAnimationState->setLoop(loop);
+        mAnimationState->setEnabled(true);
+}
+//-----------------------------------------------------------------------
+bool EntityState::OutOfBounds(SceneNode *node)
+{
+        Vector3 pos = node->getPosition();
+
+        if ((pos > msMinPos) && (pos < msMaxPos))
+                return true;
+
+        return false;
+}
 /*********************************************************/
 /*      TestCullingTerrainApplication implementation     */
@@ -35 +142 @@
 TestCullingTerrainApplication::~TestCullingTerrainApplication()
 {
-        if (mTerrainContentGenerator)
-        {
-                delete mTerrainContentGenerator;
-                mTerrainContentGenerator = NULL;
-        }
+        OGRE_DELETE(mTerrainContentGenerator);
+        OGRE_DELETE(mRayQueryExecutor);
+        deleteEntityStates();
+}
+//-----------------------------------------------------------------------
+void TestCullingTerrainApplication::deleteEntityStates()
+{
+        for (int i = 0; i < (int)mEntityStates.size(); ++i)
+        {
+                delete mEntityStates[i];
+                mEntityStates[i] = NULL;
+        }
+        mEntityStates.clear();
 }
 //-----------------------------------------------------------------------
@@ -133 +248 @@
         mSceneMgr->setWorldGeometry(terrain_cfg);
         
+        // ray query executor
+        mRayQueryExecutor = new RayQueryExecutor(mSceneMgr);
+
         //-- CEGUI setup
         setupGui();
@@ -185 +303 @@
 
         //-- add animation state for new robots (located at the end of the list)
-        for (int i = entList->size() - num; i < entList->size(); ++i)
-        {
-                Entity *ent = (*entList)[i];
-                AnimationState *st = ent->getAnimationState("Idle");
-                st->setEnabled(true);
-                st->setLoop(true);
-
-                mAnimationStates.push_back(st);
-                mAnimationSpeed.push_back(Math::RangeRandom(0.5, 1.5));
-        }
-}
-//-----------------------------------------------------------------------
-std::vector<AnimationState *> &TestCullingTerrainApplication::getAnimationStates()
-{
-        return mAnimationStates;
-}
-//-----------------------------------------------------------------------
-std::vector<Real> &TestCullingTerrainApplication::getAnimationSpeed()
-{
-        return mAnimationSpeed;
+        for (int i = entList->size() - num; i < (int)entList->size(); ++i)
+        {
+                mEntityStates.push_back(new EntityState((*entList)[i], 
+                        EntityState::WAITING, Math::RangeRandom(0.5, 1.5)));
+        }
+}
+//-----------------------------------------------------------------------
+void TestCullingTerrainApplication::updateAnimations(Real timeSinceLastFrame)
+{
+        for (int i = 0; i < (int)mEntityStates.size(); ++i)
+        {
+                SceneNode *sm = mEntityStates[i]->GetEntity()->getParentSceneNode();
+
+                mEntityStates[i]->update(timeSinceLastFrame);
+
+                if (mEntityStates[i]->GetState() == EntityState::MOVING)
+                {
+                        Clamp2Terrain(sn, 0);
+                        //sm->setNodeVisible(false);
+                }
+        }
+}
+//-----------------------------------------------------------------------
+EntityStates  &TestCullingTerrainApplication::getEntityStates()
+{
+        return mEntityStates;
 }
 //-----------------------------------------------------------------------
@@ -239 +363 @@
         mSceneMgr = mRoot->getSceneManager(ST_EXTERIOR_CLOSE);
 }
+//-----------------------------------------------------------------------
+bool TestCullingTerrainApplication::Clamp2Terrain(SceneNode *node, int terrainOffs)
+{
+        // clamp scene node to terrain
+        Vector3 pos = node->getPosition();
+        Vector3 queryResult;
+
+        if (mRayQueryExecutor->executeRayQuery(&queryResult, 
+                        Vector3(pos.x, MAX_HEIGHT, pos.z), Vector3::NEGATIVE_UNIT_Y))
+        {
+        node->setPosition(pos.x, queryResult.y + terrainOffs, pos.z);
+                return true;
+        }
+
+        return false;
+}
+
+
 /**************************************************************/
 /*      VisualizationRenderTargetListener implementation      */