Changeset 164


Ignore:
Timestamp:
07/11/05 03:25:50 (19 years ago)
Author:
mattausch
Message:

bug fix (deleting while animation)

Location:
trunk/VUT
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/Ogre/include/OgreVisibilityTerrainSceneManager.h

    r159 r164  
    3333        */ 
    3434         
    35         virtual bool setOption( const String &, const void * ); 
     35        virtual bool setOption(const String &, const void *); 
    3636        /** Gets the given option for the Scene VisibilityManager. 
    3737            @remarks 
    3838                See setOption 
    3939        */ 
    40         virtual bool getOption( const String &, void * ); 
     40        virtual bool getOption(const String &, void *); 
    4141 
    42         bool getOptionValues( const String & key, StringVector &refValueList ); 
    43         bool getOptionKeys( StringVector &refKeys ); 
     42        bool getOptionValues(const String & key, StringVector &refValueList); 
     43        bool getOptionKeys(StringVector &refKeys); 
    4444 
    4545        /** Sets the visibility manager. 
    … …  
    7575        /** Override from SceneManager so that sub entities can be assigned an id for item buffer. 
    7676        */ 
    77         //Entity* createEntity(const String& entityName, const String& meshName); 
     77        Entity* createEntity(const String& entityName, const String& meshName); 
    7878 
    7979        /** Returns pointer to visibility manager. 
    … …  
    8585        OctreeHierarchyInterface *GetHierarchyInterface(); 
    8686 
     87        /** Inherited from scene manager. Neccesary to draw terrain properly. 
     88        */ 
    8789        void endFrame(); 
    8890 

  • trunk/VUT/Ogre/src/OgreItemBufferQueryManager.cpp

    r159 r164  
    66 
    77namespace Ogre { 
     8 
    89//-----------------------------------------------------------------------  
    9 ItemBufferQueryManager::ItemBufferQueryManager(PlatformHierarchyInterface *hierarchyInterface, Viewport *vp, 
     10ItemBufferQueryManager::ItemBufferQueryManager(PlatformHierarchyInterface *hierarchyInterface,  
     11                                                                                           Viewport *vp, 
    1012                                                                                           const bool renderPatches): 
    1113PlatformQueryManager(hierarchyInterface, vp), mRenderPatchesForItemBuffer(renderPatches) 
    … …  
    1315} 
    1416//----------------------------------------------------------------------- 
    15 bool ItemBufferQueryManager::ShootRay(const Ray &ray, std::vector<Mesh *> *visibleMeshes, bool isGlobalLine) 
     17bool ItemBufferQueryManager::ShootRay(const Ray &ray,  
     18                                                                          std::vector<Mesh *> *visibleMeshes,  
     19                                                                          bool isGlobalLine) 
    1620{ 
    1721    // run OGRE ray shooting query 
    … …  
    5054        ColourValue bg = mViewport->getBackgroundColour(); 
    5155        mViewport->setBackgroundColour(ColourValue(0, 0, 0, 0)); 
     56        pfHierarchyInterface->GetRenderSystem()->clearFrameBuffer(FBT_COLOUR | FBT_DEPTH); 
    5257 
     58        //-- render item buffer 
     59        sm->_renderScene(pCam, mViewport, false); 
     60    //mViewport->getTarget()->update(); 
    5361 
    54         // --- render item buffer 
    55         pfHierarchyInterface->GetSceneManager()->_renderScene(pCam, mViewport, false); 
     62//for(int j=0; j<10000000; j++) printf("wait"); 
    5663 
    5764 
    … …  
    6471 
    6572        int n = mRenderPatchesForItemBuffer ? (int)visiblePatches->size() : (int)visibleGeometry->size(); 
    66          
     73 
     74        std::stringstream d; d << "dimx: " << dimx << ", dimy: " << dimy; 
     75        LogManager::getSingleton().logMessage(d.str()); 
     76 
    6777        // loop through frame buffer & collect visible pixels 
    6878        for (int idx = 0; idx < dimy * dimx * 3; idx += 3) 
    6979        { 
    70                 // -- decode color code to receive id 
     80                //-- decode color code to receive id 
    7181                int id = buf[idx] << 16; 
    7282                id += buf[idx + 1] << 8; 
    7383                id += buf[idx + 2]; 
    7484 
    75                 // if valid id <= add visibility (id values start at 1 
     85                std::stringstream d; d << "myid: " << (int)buf[idx] << " " << (int)buf[idx + 1] << " " << (int)buf[idx + 2]; 
     86                LogManager::getSingleton().logMessage(d.str()); 
     87 
     88                // if valid id <= add visibility (id values start at 1) 
    7689                if ((id > 0) && (id < n)) 
    7790                { 
    … …  
    144157                                 
    145158                        subEnt->setId(id); 
     159                        subEnt->setId((41 << 16) + (4 << 8) + 60); 
     160                        //subEnt->setId((2 << 16) + (4 << 8) + 60); 
    146161                } 
    147162                         

  • trunk/VUT/Ogre/src/OgrePlatformQueryManager.cpp

    r159 r164  
    4949         
    5050        // ---- capture visibility from all 6 directions 
    51         for (int i=0; i < 6; i++)        
     51        for (int dir=0; dir < 6; dir++)  
    5252        { 
    5353                sign *= -1; 
    … …  
    6060 
    6161                // prevent from initialising geometry / node array again 
    62                 if (i > 0) 
     62                if (dir > 0) 
    6363                { 
    6464                        mWasInitialised = true; 
    … …  
    7070 
    7171                // permute directions 
    72                 Vector3 dir(0,0,0); 
    73                 dir[i/2] = sign; 
     72                Vector3 direction(0,0,0); 
     73                direction[dir/2] = sign; 
    7474 
    75                 cam->setDirection(dir); 
     75                cam->setDirection(direction); 
    7676        } 
    7777         

  • trunk/VUT/Ogre/src/OgreTerrainContentGenerator.cpp

    r161 r164  
    1616RayQueryExecutor::~RayQueryExecutor() 
    1717{ 
    18         delete mRaySceneQuery; 
     18        OGRE_DELETE(mRaySceneQuery); 
    1919} 
    2020//----------------------------------------------------------------------- 

  • trunk/VUT/Ogre/src/OgreVisibilityOctreeSceneManager.cpp

    r159 r164  
    739739} 
    740740*/ 
    741 //----------------------------------------------------------------------- 
    742 /* 
     741/*//----------------------------------------------------------------------- 
    743742Entity* VisibilityTerrainSceneManager::createEntity(const String& entityName,  
    744743                                                                                                        const String& meshName) 

  • trunk/VUT/Ogre/src/OgreVisibilityTerrainSceneManager.cpp

    r160 r164  
    3737        mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem); 
    3838         
    39         //mDisplayNodes = true; 
    40         //mShowBoundingBoxes = true; 
    41         //mShowBoxes = true; 
     39        //mDisplayNodes = true;//mShowBoundingBoxes = true;//mShowBoxes = true; 
    4240 
    4341        // TODO: set maxdepth to reasonable value 
    … …  
    120118        if (mRenderNodesForViz || mRenderNodesContentForViz) 
    121119        { 
    122                 // change node material so it is better suited for visualization 
     120                // HACK: change node material so it is better suited for visualization 
    123121                MaterialPtr nodeMat = MaterialManager::getSingleton().getByName("Core/NodeMaterial"); 
    124122                nodeMat->setAmbient(1, 1, 0); 
    … …  
    130128                        if (mRenderNodesForViz) 
    131129                        { 
    132                                 if (((*it)->numAttachedObjects() > 0) && ((*it)->numChildren() == 0) 
    133                                         && (*it)->getAttachedObject(0)->getMovableType() == "Entity") 
    134                                 getRenderQueue()->addRenderable((*it)); 
     130                                // render the leaf nodes 
     131                                if (((*it)->numAttachedObjects() > 0) && ((*it)->numChildren() == 0) &&  
     132                                         (*it)->getAttachedObject(0)->getMovableType() == "Entity") 
     133                                { 
     134                                        getRenderQueue()->addRenderable((*it)); 
     135                                } 
    135136 
    136137                                // addbounding boxes instead of node itself 
    … …  
    508509        } 
    509510 
    510         // --- item buffer 
     511        //-- item buffer 
    511512 
    512513    // Iterate through priorities 
    … …  
    743744*/ 
    744745//----------------------------------------------------------------------- 
    745 /* 
    746746Entity* VisibilityTerrainSceneManager::createEntity(const String& entityName,  
    747747                                                                                                        const String& meshName) 
    … …  
    752752        { 
    753753                ent->getSubEntity(i)->setId(mCurrentEntityId); 
     754                ent->getSubEntity(i)->setId((41 << 16) + (4 << 8) + 60); 
     755                //ent->getSubEntity(i)->setId((2 << 16) + (4 << 8) + 60); 
    754756        } 
    755757 
    … …  
    759761        return ent; 
    760762} 
    761 */ 
    762763} // namespace Ogre 

  • trunk/VUT/work/TestCullingTerrain/TerrainFrameListener.cpp

    r161 r164  
    120120mCurrentObjectType(0), 
    121121mApplication(app), 
    122 mUseAnimation(false) 
     122mUseAnimation(false), 
     123mDeleteObjects(false) 
    123124{ 
    124125        //mInputDevice = PlatformManager::getSingleton().createInputReader(); 
    … …  
    206207                  
    207208                 Real val = Math::RangeRandom(0, 360); // random rotation 
     209 
    208210                 // get results, create a node/entity on the position 
    209211                 mCurrentObject = mTerrainContentGenerator->GenerateSceneObject( 
    … …  
    301303        } 
    302304         
     305        if (mDeleteObjects) 
     306        { 
     307                mApplication->deleteEntityStates(); 
     308                mTerrainContentGenerator->RemoveGeneratedObjects(); 
     309                mDeleteObjects = false; 
     310        } 
     311 
    303312        if (mUseAnimation) // update animations 
    304313        { 
    … …  
    10341043                break; 
    10351044        case KC_F9: 
    1036                 toggleUseAnimation(); 
     1045                mUseAnimation = !mUseAnimation; 
    10371046                break; 
    10381047        case KC_F11: 
    1039                 takeScreenShot(); 
     1048                takeScreenshot(); 
    10401049                break; 
    10411050        case KC_F12: 
    … …  
    10531062                break; 
    10541063        case KC_DELETE: 
    1055                 mApplication->deleteEntityStates(); 
    1056                 mTerrainContentGenerator->RemoveGeneratedObjects(); 
     1064                mDeleteObjects = true; 
    10571065                break; 
    10581066        //KEY_PRESSED(KC_F3, 0.3, writeFrames()); 
    … …  
    12231231} 
    12241232//----------------------------------------------------------------------- 
    1225 void TerrainFrameListener::takeScreenShot() 
     1233void TerrainFrameListener::takeScreenshot() 
    12261234{ 
    12271235        char tmp[20]; 
    … …  
    14151423        queryPanel->setHeight(top + border_height); 
    14161424} 
    1417 //----------------------------------------------------------------------- 
    1418 void TerrainFrameListener::toggleUseAnimation() 
    1419 { 
    1420         mUseAnimation = !mUseAnimation; 
    1421 } 

  • trunk/VUT/work/TestCullingTerrain/TerrainFrameListener.h

    r161 r164  
    112112        void toggleShowShadows(); 
    113113        void toggleDisplayCameraDetails(); 
    114         void takeScreenShot(); 
     114        void takeScreenshot(); 
    115115        void nextSceneDetailLevel(); 
    116116        void nextFilter(); 
    … …  
    125125        void toggleShowViz(); 
    126126        void toggleRecord(); 
    127         void toggleUseAnimation(); 
    128127 
    129128        /** Applies visibility query. Collects the visible objects  
    … …  
    241240        float mMoveScale; 
    242241    Degree mRotScale; 
     242 
    243243    // just to stop toggles flipping too fast 
    244244    Real mTimeDelay; 
    … …  
    272272        int mCurrentObjectType; 
    273273 
     274        bool mDeleteObjects; 
     275 
    274276        TestCullingTerrainApplication *mApplication; 
    275277}; 

  • trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.cpp

    r161 r164  
    2424}; 
    2525 
     26const float walk_duration = 10.0f; 
     27const float wait_duration = 2.0f; 
     28const float rotate_factor = 0.7f; 
     29const float move_factor = 0.03; 
     30 
    2631/***************************************/ 
    2732/*      EntityState implementation     */ 
    2833/***************************************/ 
     34Vector3 EntityState::msMinPos = Vector3::ZERO; 
     35Vector3 EntityState::msMaxPos = Vector3::ZERO; 
     36 
    2937EntityState::EntityState(Entity *ent, State entityState, Real speed): 
    3038mEntity(ent), mState(entityState), mAnimationSpeed(speed) 
    … …  
    5361} 
    5462//----------------------------------------------------------------------- 
     63EntityState::~EntityState() 
     64{ 
     65        mAnimationState = NULL; 
     66        mEntity = NULL; 
     67} 
     68//----------------------------------------------------------------------- 
    5569Entity *EntityState::GetEntity() 
    5670{ 
    … …  
    6680{ 
    6781        mTimeElapsed -= timeSinceLastFrame * mAnimationSpeed; 
     82 
     83        if (!mEntity || !mAnimationState) 
     84                return; 
    6885         
    6986        if (mState == MOVING) // toggle between moving (longer) and waiting (short) 
    7087        { 
    7188                SceneNode *parent = mEntity->getParentSceneNode(); 
     89                 
     90                if (!parent) 
     91                        return; 
    7292 
    7393                if (mTimeElapsed <= 0) // toggle animation state 
    … …  
    7696                        { 
    7797                                SetAnimationState("Walk", true); 
    78                                 mTimeElapsed = 10; // walk for mTimeElapsed units 
    79  
    80                                 // choose random direction between zero and two pi 
    81                                 Radian rnd = Radian(Math::UnitRandom() * Math::HALF_PI); 
     98                                 
     99                                mTimeElapsed = walk_duration; // walk for mTimeElapsed units 
     100 
     101                                // choose random rotation 
     102                                Radian rnd = Radian(Math::UnitRandom() * Math::PI * rotate_factor); 
    82103 
    83104                                //mEntity->getParentSceneNode()->rotate(); 
    … …  
    87108                        { 
    88109                                SetAnimationState("Idle", true); 
    89                                 mTimeElapsed = 2; // wait for mTimeElapsed seconds 
     110                                mTimeElapsed = wait_duration; // wait for mTimeElapsed seconds 
    90111                        } 
    91112                } 
    92113 
    93                 if (mAnimationState->getAnimationName() == "Walk") 
     114                if (mAnimationState->getAnimationName() == "Walk") // move forward 
    94115                { 
     116                        // store old position, just in case we get out of bounds 
    95117                        Vector3 oldPos = parent->getPosition(); 
    96  
    97                         parent->translate(parent->getLocalAxes(), Vector3(0.03 * mAnimationSpeed, 0, 0)); 
    98  
    99                         // HACK: if out of bounds => go back to idle 
     118                        parent->translate(parent->getLocalAxes(), Vector3(move_factor * mAnimationSpeed, 0, 0)); 
     119 
     120                        // HACK: if out of bounds => reset to old position and set animationstate to idle 
    100121                        if (OutOfBounds(parent))  
    101122                        { 
    102123                                parent->setPosition(oldPos); 
    103                                 SetAnimationState("Idle); 
     124                                SetAnimationState("Idle", true); 
    104125                                 
    105                                 mTimeElapsed = 2; 
     126                                mTimeElapsed = wait_duration; 
    106127                        } 
    107128                } 
    108129        } 
    109130                 
    110         if (mAnimationState) // add time to drive animation 
    111         { 
    112                 mAnimationState->addTime(timeSinceLastFrame * mAnimationSpeed); 
    113         } 
     131        // add time to drive animation 
     132        mAnimationState->addTime(timeSinceLastFrame * mAnimationSpeed); 
    114133} 
    115134//----------------------------------------------------------------------- 
    116135void EntityState::SetAnimationState(String stateStr, bool loop) 
    117136{ 
     137        if (!mEntity) 
     138                return; 
     139 
    118140        mAnimationState = mEntity->getAnimationState(stateStr); 
    119141        mAnimationState->setLoop(loop); 
    … …  
    126148 
    127149        if ((pos > msMinPos) && (pos < msMaxPos)) 
    128                 return true; 
    129  
    130         return false; 
    131 } 
     150                return false; 
     151 
     152        return true; 
     153} 
     154 
     155 
     156 
    132157/*********************************************************/ 
    133158/*      TestCullingTerrainApplication implementation     */ 
    … …  
    136161 
    137162TestCullingTerrainApplication::TestCullingTerrainApplication(): 
    138 mTerrainContentGenerator(NULL) 
     163mTerrainContentGenerator(NULL), mRayQueryExecutor(NULL) 
    139164{ 
    140165} 
    … …  
    144169        OGRE_DELETE(mTerrainContentGenerator); 
    145170        OGRE_DELETE(mRayQueryExecutor); 
     171 
    146172        deleteEntityStates(); 
    147173} 
    … …  
    151177        for (int i = 0; i < (int)mEntityStates.size(); ++i) 
    152178        { 
    153                 delete mEntityStates[i]; 
    154                 mEntityStates[i] = NULL; 
    155         } 
     179                OGRE_DELETE(mEntityStates[i]); 
     180        } 
     181 
    156182        mEntityStates.clear(); 
    157183} 
    … …  
    248274        mSceneMgr->setWorldGeometry(terrain_cfg); 
    249275         
    250         // ray query executor 
    251         mRayQueryExecutor = new RayQueryExecutor(mSceneMgr); 
    252276 
    253277        //-- CEGUI setup 
    … …  
    274298        mSceneMgr->_renderScene(mCamera, mWindow->getViewport(0), true); 
    275299 
     300        // ray query executor: needed to clamp to terrain 
     301        mRayQueryExecutor = new RayQueryExecutor(mSceneMgr); 
     302 
     303        mTerrainMinPos = EntityState::msMinPos = Vector3(0, 0, 0); 
     304        mTerrainMaxPos = EntityState::msMaxPos = Vector3(3000, 5000, 3000); 
     305 
    276306        mTerrainContentGenerator = new TerrainContentGenerator(mSceneMgr); 
    277307         
    … …  
    280310        { 
    281311                // to provide much occlusion, 
    282                 // height is restricted to 50 => no objects appear on peaks 
    283                 mTerrainContentGenerator->SetMaxPos(Vector3(3000.0f, 50.0f, 3000.0f)); 
     312                // height is restricted to 50 => no objects are created on peaks 
     313                mTerrainContentGenerator->SetMinPos(Vector3(mTerrainMinPos)); 
     314                mTerrainContentGenerator->SetMaxPos(Vector3(mTerrainMaxPos.x, 50.0f, mTerrainMaxPos.z)); 
    284315                mTerrainContentGenerator->SetOffset(0); 
    285316 
    … …  
    288319        } 
    289320 
    290         // no limitations needed anymore: the user can set  
    291         // objects also on peaks of terrain 
    292         mTerrainContentGenerator->SetMaxPos(Vector3(3000.0f, 5000.0f, 3000.0f)); 
     321        // no limitations anymore => it is possible for the user to put single  
     322        // objects on peaks of the terrain (only few, not relevant for occlusion) 
     323        mTerrainContentGenerator->SetMaxPos(mTerrainMaxPos); 
    293324} 
    294325//----------------------------------------------------------------------- 
    … …  
    314345        for (int i = 0; i < (int)mEntityStates.size(); ++i) 
    315346        { 
    316                 SceneNode *sm = mEntityStates[i]->GetEntity()->getParentSceneNode(); 
     347                SceneNode *sn = mEntityStates[i]->GetEntity()->getParentSceneNode(); 
    317348 
    318349                mEntityStates[i]->update(timeSinceLastFrame); 
    … …  
    320351                if (mEntityStates[i]->GetState() == EntityState::MOVING) 
    321352                { 
    322                         Clamp2Terrain(sn, 0); 
    323                         //sm->setNodeVisible(false); 
     353                        Clamp2Terrain(sn, 0); //sn->setNodeVisible(false); 
    324354                } 
    325355        } 

  • trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.h

    r161 r164  
    3434 
    3535        EntityState(Entity *ent, State entityState, Real speed); 
    36  
     36        ~EntityState(); 
    3737        /** Update the entity state. 
    3838        */ 
    … …  
    4646        */ 
    4747        EntityState::State GetState(); 
     48 
     49        static bool OutOfBounds(SceneNode *node); 
     50 
     51        static Vector3 msMinPos; 
     52        static Vector3 msMaxPos; 
    4853 
    4954protected: 
    … …  
    136141        RayQueryExecutor *mRayQueryExecutor; 
    137142 
     143        Vector3 mTerrainMinPos; 
     144        Vector3 mTerrainMaxPos; 
    138145private: 
    139146        void chooseSceneManager(void); 
Note: See TracChangeset for help on using the changeset viewer.