Changeset 160 for trunk/VUT/work


Ignore:
Timestamp:
07/08/05 01:53:01 (20 years ago)
Author:
mattausch
Message:

added animation

Location:
trunk/VUT/work
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/work/TestCulling/TestCullingApplication.cpp

    r155 r160  
    3131 
    3232        // Position it at 500 in Z direction 
    33         mCamera->setPosition(Vector3(128,25,128)); 
     33        mCamera->setPosition(Vector3(128, 25, 128)); 
    3434 
    3535        // Look back along -Z 
    36     mCamera->lookAt(Vector3(0,0,-300)); 
    37     mCamera->setNearClipDistance( 1 ); 
    38     mCamera->setFarClipDistance( 1000 ); 
     36    mCamera->lookAt(Vector3(0, 0, -300)); 
     37    mCamera->setNearClipDistance(1); 
     38    mCamera->setFarClipDistance(1000); 
    3939}*/ 
    4040//----------------------------------------------------------------------- 
    … …  
    6767void TestCullingApplication::setupGui() 
    6868{ 
    69          mGUIRenderer = new CEGUI::OgreCEGUIRenderer(mWindow, Ogre::RENDER_QUEUE_OVERLAY, false, 3000, ST_EXTERIOR_CLOSE); 
     69         mGUIRenderer = new CEGUI::OgreCEGUIRenderer(mWindow,  
     70                 Ogre::RENDER_QUEUE_OVERLAY, false, 3000, ST_EXTERIOR_CLOSE); 
    7071     mGUISystem = new CEGUI::System(mGUIRenderer); 
    7172 
    … …  
    9394 
    9495 
    95 /***********************************************/ 
    96 /* TerrainFrameListener implementation         */ 
    97 /***********************************************/ 
     96/*****************************************************/ 
     97/*       TerrainFrameListener implementation         */ 
     98/*****************************************************/ 
    9899//----------------------------------------------------------------------- 
    99100TerrainFrameListener::TerrainFrameListener(RenderWindow* win, Camera* cam,  
    100101                                                                           SceneManager *sceneManager,  
    101102                                                                           CEGUI::Renderer *renderer, 
    102                                                                            SceneContentGenerator *sceneContentGenerator) 
    103 : ExampleFrameListener(win, cam, false, true), 
     103                                                                           SceneContentGenerator *sceneContentGenerator): 
     104ExampleFrameListener(win, cam, false, true), 
    104105mSceneMgr(sceneManager), 
    105106mGUIRenderer(renderer),  
    … …  
    136137        mHierarchyNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/HierarchyNodesInfo"); 
    137138        mRenderedNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/RenderedNodesInfo"); 
    138         mObjectsInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/ObjectsInfo"); 
     139        mObjectsCountInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/ObjectsInfo"); 
    139140        mTestGeometryForVisibleLeavesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/TestGeometryForVisibleLeavesInfo"); 
    140141        mQueriesIssuedInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/QueriesIssuedInfo"); 
    … …  
    148149        mHierarchyNodesInfo->setCaption(": 0"); 
    149150        mRenderedNodesInfo->setCaption(": 0"); 
    150         mObjectsInfo->setCaption(": 0"); 
     151        mObjectsCountInfo->setCaption(": 0"); 
    151152        mTestGeometryForVisibleLeavesInfo->setCaption(": true"); 
    152153        mQueriesIssuedInfo->setCaption(": 0"); 
    … …  
    330331 
    331332        sprintf(str,": %d", mSceneContentGenerator->GetObjectCount());  
    332         mObjectsInfo->setCaption(str); 
     333        mObjectsCountInfo->setCaption(str); 
    333334} 
    334335//----------------------------------------------------------------------- 

  • trunk/VUT/work/TestCulling/TestCullingApplication.h

    r155 r160  
    1 /** 
    2     \file  
    3         TestCullingApplication.h 
    4 */ 
     1#ifndef _TerrainFrameListener_H__ 
     2#define _TerrainFrameListener_H__ 
     3 
    54#include "CEGUIForwardRefs.h" 
    65#include "ExampleApplication.h" 
    … …  
    2928public: 
    3029 
    31     TerrainFrameListener(RenderWindow* win, Camera* cam, SceneManager *sceneManager,  
    32                         CEGUI::Renderer *renderer, SceneContentGenerator *sceneContentGenerator); 
     30    TerrainFrameListener(RenderWindow* win,  
     31                                                 Camera* cam,  
     32                                                 SceneManager *sceneManager,  
     33                                                 CEGUI::Renderer *renderer,  
     34                                                 SceneContentGenerator *sceneContentGenerator); 
    3335 
    3436 
    35     ~TerrainFrameListener( ); 
     37    ~TerrainFrameListener(); 
    3638 
    3739        bool frameStarted(const FrameEvent& evt); 
    … …  
    8688        OverlayElement *mHierarchyNodesInfo; 
    8789        OverlayElement *mRenderedNodesInfo; 
    88         OverlayElement *mObjectsInfo; 
     90        OverlayElement *mObjectsCountInfo; 
    8991        OverlayElement *mTestGeometryForVisibleLeavesInfo; 
    9092        OverlayElement *mQueriesIssuedInfo; 
    … …  
    130132}; 
    131133 
     134#endif // _TerrainFrameListener_H__ 

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

    r159 r160  
    1111#include "OgreItemBufferQueryManager.h" 
    1212#include "OgreOcclusionQueriesQueryManager.h" 
    13  
    14  
    15  
     13#include "TestCullingTerrainApplication.h" 
    1614 
    1715// output file for frame info 
    … …  
    4846}; 
    4947 
     48Real currentObjectTerrainOffsets[] =  
     49{ 
     50        0, 
     51        7, 
     52        0 
     53}; 
     54Real currentObjectScales[] =  
     55{ 
     56        0.1, 
     57        0.1, 
     58        0.07 
     59}; 
    5060//----------------------------------------------------------------------- 
    5161TerrainFrameListener::TerrainFrameListener(RenderWindow* win, Camera* cam,  
    … …  
    5565                                                                           Camera *vizCamera, 
    5666                                                                           SceneNode *camNode, 
    57                                                                            Light *sunLight):  
     67                                                                           Light *sunLight, 
     68                                                                           TestCullingTerrainApplication *app):  
    5869mCamera(cam), 
    5970mWindow(win), 
    … …  
    7990mAppState(WALKTHROUGH), 
    8091mCurrentFrame(0), 
    81 mTimeElapsed(0), 
     92mReplayTimeElapsed(0), 
    8293mRotateSpeed(72), 
    8394mMoveSpeed(50), 
    … …  
    105116mDelayedTraversedNodes(0.0), 
    106117mUseItemBuffer(false), 
    107 mRenderPatchesForItemBuffer(false) 
     118mRenderPatchesForItemBuffer(false), 
     119mCurrentObjectType(0), 
     120mApplication(app) 
    108121{ 
    109122        //mInputDevice = PlatformManager::getSingleton().createInputReader(); 
    … …  
    118131        mEventProcessor->addKeyListener(this); 
    119132 
    120         mInputDevice = mEventProcessor->getInputReader(); 
    121          
     133        mInputDevice = mEventProcessor->getInputReader();        
    122134 
    123135        // create ray query executor, used to place objects in terrain 
    124136        mRayQueryExecutor = new RayQueryExecutor(mSceneMgr); 
    125137         
     138        //-- overlays 
     139        mDebugOverlay = OverlayManager::getSingleton().getByName("Core/DebugOverlay"); 
    126140        mHelpOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/HelpOverlay");  
    127         mDebugOverlay = OverlayManager::getSingleton().getByName("Core/DebugOverlay"); 
    128141        mQueryOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/QueryOverlay");  
    129  
    130         //-- visibility culling stats overlay 
    131         mCullStatsOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/DemoOverlay");  
    132          
    133         mAlgorithmInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/AlgorithmInfo"); 
    134         mThresholdInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/ThresholdInfo"); 
    135         mTestGeometryForVisibleLeavesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/TestGeometryForVisibleLeavesInfo"); 
    136         mUseDepthPassInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/UseDepthPassInfo"); 
    137         mAssumedVisibilityInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/AssumedVisibilityInfo"); 
    138  
    139         mFrustumCulledNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/FrustumCulledNodesInfo"); 
    140         mQueryCulledNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/QueryCulledNodesInfo"); 
    141     mTraversedNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/TraversedNodesInfo"); 
    142         mHierarchyNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/HierarchyNodesInfo"); 
    143         mRenderedNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/RenderedNodesInfo"); 
    144         mObjectsInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/ObjectsInfo"); 
    145         mQueriesIssuedInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/QueriesIssuedInfo"); 
    146         mDelayedQueriesIssuedInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/DelayedQueriesIssuedInfo"); 
    147         mDelayedTraversedNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/DelayedTraversedNodesInfo"); 
    148  
    149         mAlgorithmInfo->setCaption(": " + currentAlgorithmCaptions[mCurrentAlgorithm]); 
    150         mThresholdInfo->setCaption(": 0"); 
    151         mFrustumCulledNodesInfo->setCaption(": 0"); 
    152         mQueryCulledNodesInfo->setCaption(": 0"); 
    153         mTraversedNodesInfo->setCaption(": 0"); 
    154         mHierarchyNodesInfo->setCaption(": 0"); 
    155         mRenderedNodesInfo->setCaption(": 0"); 
    156         mObjectsInfo->setCaption(": 0"); 
    157         mTestGeometryForVisibleLeavesInfo->setCaption(": true"); 
    158         mUseDepthPassInfo->setCaption(": false"); 
    159         mQueriesIssuedInfo->setCaption(": 0"); 
    160         mAssumedVisibilityInfo->setCaption(": 0"); 
    161         mDelayedQueriesIssuedInfo->setCaption(": 0"); 
    162         mDelayedTraversedNodesInfo->setCaption(": 0"); 
    163  
    164         //-- visibility query stats overlay 
    165         mQueryTypeInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/Query/QueryTypeInfo"); 
    166          
    167         mQueryVisibleNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/Query/VisibleNodesInfo"); 
    168     mQueryVisibleGeometryInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/Query/VisibleGeometryInfo"); 
    169         mQueryVisiblePatchInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/Query/VisiblePatchInfo"); 
    170          
    171         mQueryNodeVisibilityInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/Query/NodeVisibilityInfo"); 
    172         mQueryGeometryVisibilityInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/Query/GeometryVisibilityInfo"); 
    173         mQueryPatchVisibilityInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/Query/PatchVisibilityInfo"); 
     142        mCullStatsOverlay = OverlayManager::getSingleton().getByName("Example/Visibility/CullStatsOverlay");  
     143 
     144        initVisStatsOverlay(); // visibility stats overlay 
     145        initHelpOverlay(); // help overlay 
     146        initQueryOverlay(); // visibility query stats overlay 
    174147 
    175148        // show stats overlays 
    176149        showStats(true); 
    177         //mHelpOverlay->show(); 
    178  
     150         
    179151        // set culling algorithm type 
    180152        setAlgorithm(mCurrentAlgorithm); 
    … …  
    193165        mSceneMgr->setOption("CullCamera", &mCullCamera); 
    194166        mSceneMgr->setOption("PrepareVisualization", &mShowVisualization); 
     167 
     168        setObjectType(mCurrentObjectType); 
    195169 
    196170        // reset statistics 
    … …  
    229203                 //Vector3 queryResult; mRayQueryExecutor->executeRayQuery(&queryResult, mouseRay); 
    230204                  
    231                  // Get results, create a node/entity on the position 
     205                 // get results, create a node/entity on the position 
    232206                 mCurrentObject = mTerrainContentGenerator->GenerateSceneObject( 
    233                          mouseRay.getOrigin()/*queryResult*/, Vector3::ZERO, "robot"); 
     207                         mouseRay.getOrigin()/*queryResult*/, Vector3::ZERO,  
     208                         mApplication->getCurrentObjectCaption(mCurrentObjectType)); 
    234209                 
     210                 if (mCurrentObjectType == 0) // only robot has animation phases 
     211                 { 
     212                         Entity *ent = mTerrainContentGenerator->GetGeneratedEntities()->back(); 
     213                         AnimationState *st = ent->getAnimationState("Walk"); 
     214 
     215                         st->setLoop(true); 
     216                         st->setEnabled(true); 
     217                                         
     218                         mApplication->getAnimationStates().push_back(st); 
     219                         mApplication->getAnimationSpeed().push_back(Math::RangeRandom(0.5, 1.5)); 
     220                 } 
     221 
    235222         mLMouseDown = true;  
    236223     } 
    … …  
    271258                         if (mCurrentObject) 
    272259                         { 
     260                                 // apply offset so object is ON terrain 
     261                                 queryResult.y += currentObjectTerrainOffsets[mCurrentObjectType]; 
     262 
    273263                                 mCurrentObject->setPosition(queryResult); 
    274264                         } 
    … …  
    292282        } 
    293283 
     284        for (int i = 0; i < (int)mApplication->getAnimationStates().size(); ++i) 
     285    { 
     286                mApplication->getAnimationStates()[i]->addTime(evt.timeSinceLastFrame *  
     287                         mApplication->getAnimationSpeed()[i]); 
     288    } 
     289 
    294290        if (mDisplayCameraDetails) 
    295291    { 
    … …  
    299295    } 
    300296 
    301         //-- IMPORTANT: must be set, otherwise terrain is not rendered correctly 
    302         mSceneMgr->endFrame(); 
    303  
    304297        //-- setup what is needed for immediate mouse/key movement 
    305298        if (mTimeDelay >= 0)  
    … …  
    307300                mTimeDelay -= evt.timeSinceLastFrame; 
    308301        } 
    309  
     302         
    310303        // If this is the first frame, pick a speed 
    311304        if (evt.timeSinceLastFrame == 0) 
    … …  
    387380} 
    388381//----------------------------------------------------------------------- 
    389 void TerrainFrameListener::ApplyVisibilityQuery(bool fromPoint, bool relativeVisibility,  
     382void TerrainFrameListener::applyVisibilityQuery(bool fromPoint, bool relativeVisibility,  
    390383                                                                                                bool useItemBuffer) 
    391384{ 
    … …  
    523516 
    524517        // show the results 
    525         if (!mShowQueryStats) 
     518        if (!mShowQueryStats && !mShowHelp) 
    526519        { 
    527520                mQueryOverlay->show(); 
    … …  
    552545 
    553546    updateStats(); 
     547 
     548        //-- IMPORTANT: must be set, otherwise terrain is not rendered correctly 
     549        mSceneMgr->endFrame(); 
     550 
     551        if (mTimeDelay <= 0) // approx. one second 
     552                mTimeDelay = 1.0; 
    554553 
    555554        return true; 
    … …  
    660659 
    661660                        //-- initialise frame data 
    662                         mTimeElapsed = 0; 
     661                        mReplayTimeElapsed = 0; 
    663662 
    664663                        mCamNode->setPosition(mFrameInfo[0].position); 
    … …  
    716715} 
    717716//----------------------------------------------------------------------- 
     717void TerrainFrameListener::setObjectType(int objectType) 
     718{ 
     719        if (mCurrentObjectType >= 3) 
     720                mCurrentObjectType = 0; 
     721 
     722        // parameters for new object 
     723        mTerrainContentGenerator->SetOffset(currentObjectTerrainOffsets[mCurrentObjectType]); 
     724        Real scale = currentObjectScales[mCurrentObjectType]; 
     725        mTerrainContentGenerator->SetScale(Vector3(scale, scale, scale)); 
     726 
     727        mCurrentObjectTypeInfo->setCaption(": " +  
     728                mApplication->getCurrentObjectCaption(mCurrentObjectType)); 
     729} 
     730//----------------------------------------------------------------------- 
    718731void TerrainFrameListener::setAlgorithm(int algorithm) 
    719732{ 
    … …  
    739752        static String trisString = "Triangle Count: "; 
    740753 
     754        // HACK: compute average fps ourselfs, because ogre avg. fps is wrong 
     755        // TODO: update only once per second 
    741756        mAvgFps += mWindow->getStatistics().lastFPS; 
    742757        ++ mFrameCount; 
    … …  
    755770 
    756771                //guiAvg->setCaption(avgFps + StringConverter::toString(stats.avgFPS)); 
    757                 guiAvg->setCaption(avgFpsString + StringConverter::toString(avgFps)); 
     772                if (mTimeDelay < 0) // only update once per second 
     773                        guiAvg->setCaption(avgFpsString + StringConverter::toString(avgFps) + " ms"); 
    758774                guiCurr->setCaption(currFpsString + StringConverter::toString(stats.lastFPS)); 
    759775                guiBest->setCaption(bestFpsString + StringConverter::toString(stats.bestFPS) 
    760                         +" "+StringConverter::toString(stats.bestFrameTime)+" ms"); 
     776                        +" "+StringConverter::toString(stats.bestFrameTime) + " ms"); 
    761777                guiWorst->setCaption(worstFpsString + StringConverter::toString(stats.worstFPS) 
    762                         +" "+StringConverter::toString(stats.worstFrameTime)+" ms"); 
     778                        +" "+StringConverter::toString(stats.worstFrameTime) + " ms"); 
    763779 
    764780                OverlayElement* guiTris = OverlayManager::getSingleton().getOverlayElement("Core/NumTris"); 
    … …  
    772788                mFrustumCulledNodesInfo->setCaption(str); 
    773789 
    774                 // delay so there is no jump 
    775                 mSceneMgr->getOption("NumQueriesIssued", &opt);  
    776                 sprintf(str,": %d", (int)opt);  
    777                 mQueriesIssuedInfo->setCaption(str); 
    778  
    779790                mSceneMgr->getOption("NumQueryCulledNodes", &opt); sprintf(str,": %d", opt);  
    780791                mQueryCulledNodesInfo->setCaption(str); 
    781792         
    782                 mSceneMgr->getOption("NumTraversedNodes", &opt); sprintf(str,": %d", opt);  
    783                 mTraversedNodesInfo->setCaption(str); 
    784  
    785793                mSceneMgr->getOption("NumHierarchyNodes", &opt); sprintf(str,": %d", opt);  
    786794                mHierarchyNodesInfo->setCaption(str); 
    … …  
    790798 
    791799                sprintf(str,": %d", mTerrainContentGenerator->GetObjectCount());  
    792                 mObjectsInfo->setCaption(str); 
    793  
    794                 // delay so there is no jump 
     800                mObjectsCountInfo->setCaption(str); 
     801 
     802                // take old value into account in order to create no sudden changes 
    795803                mSceneMgr->getOption("NumQueriesIssued", &opt);  
    796804                mDelayedQueriesIssued = mDelayedQueriesIssued * 0.8 + (float)opt * 0.2; 
    797805                sprintf(str,": %d", (int)mDelayedQueriesIssued);  
    798                 mDelayedQueriesIssuedInfo->setCaption(str); 
     806                mQueriesIssuedInfo->setCaption(str); 
    799807 
    800808                mSceneMgr->getOption("NumTraversedNodes", &opt);  
    801809                mDelayedTraversedNodes = mDelayedTraversedNodes * 0.8 + (float)opt * 0.2; 
    802810                sprintf(str,": %d", (int)mDelayedTraversedNodes);  
    803                 mDelayedTraversedNodesInfo->setCaption(str); 
     811                mTraversedNodesInfo->setCaption(str); 
    804812 
    805813        } 
    … …  
    815823        mSceneMgr->setOption("TestGeometryForVisibleLeaves", &mTestGeometryForVisibleLeaves); 
    816824         
    817         // disable optimization which tests geometry instead of aabb 
    818         // for delayed rendering (i.e., render transparents after all the solids) 
    819         // because otherwise visible transparents could be skipped 
     825        /* disable optimization which tests geometry instead of aabb 
     826         * for "delayed" rendering of transparents (i.e., render transparents after all the solids) 
     827         * because otherwise visible transparents could be skipped 
     828         */ 
    820829        bool delayedRendering = !mTestGeometryForVisibleLeaves; 
    821830 
    … …  
    928937void TerrainFrameListener::keyPressed(KeyEvent* e) 
    929938{ 
     939        // hide exact visibility query overlay 
     940        if (mShowQueryStats) 
     941        { 
     942                mQueryOverlay->hide(); 
     943                mShowQueryStats = false; 
     944        } 
     945 
    930946        switch(e->getKey()) 
    931947        { 
    … …  
    9971013                break; 
    9981014        case KC_F5: 
    999                 ApplyVisibilityQuery(false, mShiftPressed, mUseItemBuffer); 
     1015                applyVisibilityQuery(false, mShiftPressed, mUseItemBuffer); 
    10001016                break; 
    10011017        case KC_F6: 
    1002                 ApplyVisibilityQuery(true, mShiftPressed, mUseItemBuffer); 
     1018                applyVisibilityQuery(true, mShiftPressed, mUseItemBuffer); 
     1019                break; 
     1020         
     1021        case KC_F7: 
     1022                setObjectType(++mCurrentObjectType); 
     1023                break; 
     1024        case KC_F8: 
     1025                mApplication->generateScene(500, mCurrentObjectType); 
    10031026                break; 
    10041027         
    … …  
    10181041        case KC_LSHIFT: 
    10191042                mShiftPressed = true; 
     1043                break; 
     1044        case KC_DELETE: 
     1045                mTerrainContentGenerator->RemoveGeneratedObjects(); 
     1046                mApplication->getAnimationStates().clear(); 
     1047                mApplication->getAnimationSpeed().clear(); 
    10201048                break; 
    10211049        //KEY_PRESSED(KC_F3, 0.3, writeFrames()); 
    … …  
    10601088{ 
    10611089        //-- find current frame relative to elapsed frame time           
    1062         mTimeElapsed -= timeElapsed; 
    1063  
    1064         while ((mTimeElapsed <= 0) && (mCurrentFrame < (int)mFrameInfo.size() - 1)) 
    1065         { 
    1066                 mTimeElapsed += mFrameInfo[mCurrentFrame ++].timeElapsed; 
     1090        mReplayTimeElapsed -= timeElapsed; 
     1091 
     1092        while ((mReplayTimeElapsed <= 0) && (mCurrentFrame < (int)mFrameInfo.size() - 1)) 
     1093        { 
     1094                mReplayTimeElapsed += mFrameInfo[mCurrentFrame ++].timeElapsed; 
    10671095        } 
    10681096 
    … …  
    10751103        if (old_frame.timeElapsed > 0) 
    10761104        { 
    1077                 factor = mTimeElapsed / old_frame.timeElapsed; 
     1105                factor = mReplayTimeElapsed / old_frame.timeElapsed; 
    10781106        } 
    10791107 
    … …  
    12411269        } 
    12421270} 
     1271//----------------------------------------------------------------------- 
     1272void TerrainFrameListener::initOverlayElement(OverlayElement **elInfo, String ext,  
     1273                                                                                          String name, int top, String caption) 
     1274{ 
     1275        OverlayElement *el =  
     1276                OverlayManager::getSingleton().getOverlayElement(ext + name); 
     1277 
     1278        (*elInfo) = OverlayManager::getSingleton().getOverlayElement(ext + name + "Info"); 
     1279        (*elInfo)->setCaption(caption); 
     1280 
     1281        el->setTop(top); 
     1282        (*elInfo)->setTop(top); 
     1283} 
     1284//----------------------------------------------------------------------- 
     1285void TerrainFrameListener::initHelpOverlayElement(String name, int top) 
     1286{ 
     1287        OverlayElement *el = OverlayManager::getSingleton().getOverlayElement( 
     1288                "Example/Visibility/Help/" + name); 
     1289 
     1290        el->setTop(top); 
     1291} 
     1292//----------------------------------------------------------------------- 
     1293void TerrainFrameListener::initHelpOverlay() 
     1294{ 
     1295        const int vert_space = 15; 
     1296        int top = 30; 
     1297 
     1298        initHelpOverlayElement("ShowHelp", top); top += vert_space; 
     1299        initHelpOverlayElement("Stats", top); top += vert_space; 
     1300        initHelpOverlayElement("AppState", top); top += vert_space; 
     1301        initHelpOverlayElement("Recorded", top); top += vert_space; 
     1302        initHelpOverlayElement("Screenshots", top); top += vert_space; 
     1303        initHelpOverlayElement("WriteOut", top); top += vert_space; 
     1304 
     1305        top +=vert_space; 
     1306        initHelpOverlayElement("SceneDetail", top); top += vert_space; 
     1307        initHelpOverlayElement("DisplayCameraDetails", top); top += vert_space; 
     1308        initHelpOverlayElement("DisplayOctree", top); top += vert_space; 
     1309        initHelpOverlayElement("UseShadows", top); top += vert_space; 
     1310        initHelpOverlayElement("Filter", top); top += vert_space; 
     1311 
     1312        //-- visualization 
     1313        top += vert_space; 
     1314        initHelpOverlayElement("VizSection", top); top += vert_space; 
     1315        initHelpOverlayElement("Viz", top); top += vert_space; 
     1316        initHelpOverlayElement("NextVizMode", top); top += vert_space; 
     1317        initHelpOverlayElement("ZoomViz", top); top += vert_space; 
     1318 
     1319 
     1320        //-- visibility queries 
     1321        top += vert_space; 
     1322        initHelpOverlayElement("VisQuery", top); top += vert_space; 
     1323        initHelpOverlayElement("FromCameraQuery", top); top += vert_space; 
     1324        initHelpOverlayElement("FromPointQuery", top); top += vert_space; 
     1325        initHelpOverlayElement("QueryType", top); top += vert_space; 
     1326        initHelpOverlayElement("QueryTarget", top); top += vert_space; 
     1327 
     1328        //-- object generation 
     1329        top += vert_space; 
     1330        initHelpOverlayElement("SceneObjects", top); top += vert_space; 
     1331        initHelpOverlayElement("GenerateObjects", top); top += vert_space; 
     1332        initHelpOverlayElement("RemoveObjects", top); top += vert_space; 
     1333        initHelpOverlayElement("DropObject", top); top += vert_space; 
     1334 
     1335        OverlayElement *helpPanel = OverlayManager::getSingleton().getOverlayElement( 
     1336                "Example/Visibility/Help/HelpPanel"); 
     1337 
     1338        helpPanel->setHeight(top + 10); 
     1339} 
     1340//----------------------------------------------------------------------- 
     1341void TerrainFrameListener::initVisStatsOverlay() 
     1342{ 
     1343        const int border_height = 10; 
     1344        const int vert_space = 15; 
     1345 
     1346        //-- visibility culling stats overlay 
     1347        int top = border_height; 
     1348 
     1349        String ext = "Example/Visibility/"; 
     1350         
     1351        initOverlayElement(&mAlgorithmInfo, ext, "Algorithm", top, 
     1352                ": " + currentAlgorithmCaptions[mCurrentAlgorithm]); top += vert_space; 
     1353 
     1354        initOverlayElement(&mThresholdInfo, ext, "Threshold", top, ": 0"); top += vert_space; 
     1355        initOverlayElement(&mTestGeometryForVisibleLeavesInfo, ext,  
     1356                "TestGeometryForVisibleLeaves", top, ": true"); top += vert_space; 
     1357        initOverlayElement(&mUseDepthPassInfo, ext, "UseDepthPass", top, ": false"); top += vert_space; 
     1358        initOverlayElement(&mAssumedVisibilityInfo, ext, "AssumedVisibility", top, ": 0"); top += vert_space; 
     1359        initOverlayElement(&mCurrentObjectTypeInfo, ext, "CurrentObjectType", top, ": "); top += vert_space; 
     1360 
     1361        OverlayElement *optionsPanel = OverlayManager::getSingleton(). 
     1362                getOverlayElement("Example/Visibility/VisibilityPanel"); 
     1363 
     1364        optionsPanel->setHeight(top + border_height); 
     1365 
     1366        top = border_height; 
     1367        //ext = "Example/Visibility/"; 
     1368        initOverlayElement(&mFrustumCulledNodesInfo, ext, "FrustumCulledNodes", top, ": 0"); top += vert_space; 
     1369        initOverlayElement(&mQueryCulledNodesInfo, ext, "QueryCulledNodes", top, ": 0"); top += vert_space; 
     1370        initOverlayElement(&mTraversedNodesInfo, ext, "TraversedNodes", top, ": 0"); top += vert_space; 
     1371        initOverlayElement(&mHierarchyNodesInfo, ext, "HierarchyNodes", top, ": 0"); top += vert_space; 
     1372        initOverlayElement(&mRenderedNodesInfo, ext, "RenderedNodes", top, ": 0"); top += vert_space; 
     1373        initOverlayElement(&mObjectsCountInfo, ext, "ObjectsCount", top, ": 0"); top += vert_space; 
     1374        initOverlayElement(&mQueriesIssuedInfo, ext, "QueriesIssued", top, ": 0"); top += vert_space; 
     1375 
     1376        OverlayElement *visPanel = OverlayManager::getSingleton(). 
     1377                getOverlayElement("Example/Visibility/VisibilityStatsPanel"); 
     1378 
     1379        visPanel->setHeight(top + border_height); 
     1380} 
     1381//----------------------------------------------------------------------- 
     1382void TerrainFrameListener::initQueryOverlay() 
     1383{ 
     1384        const int border_height = 10; 
     1385        const int vert_space = 15; 
     1386 
     1387        //-- visibility culling stats overlay 
     1388        int top = border_height + 25; 
     1389 
     1390        String ext = "Example/Visibility/Query/"; 
     1391             
     1392        initOverlayElement(&mQueryTypeInfo , ext, "QueryType", top,     ": 0"); top += vert_space; 
     1393        initOverlayElement(&mQueryVisibleGeometryInfo , ext, "VisibleGeometry", top,    ": 0"); top += vert_space; 
     1394        initOverlayElement(&mQueryVisibleNodesInfo , ext, "VisibleNodes", top,  ": 0"); top += vert_space; 
     1395        initOverlayElement(&mQueryVisiblePatchInfo , ext, "VisiblePatches", top,        ": 0"); top += vert_space; 
     1396        initOverlayElement(&mQueryNodeVisibilityInfo , ext, "NodeVisibility", top,      ": 0"); top += vert_space; 
     1397        initOverlayElement(&mQueryGeometryVisibilityInfo , ext, "GeometryVisibility", top,      ": 0"); top += vert_space; 
     1398        initOverlayElement(&mQueryPatchVisibilityInfo , ext, "PatchVisibility", top,    ": 0"); top += vert_space; 
     1399 
     1400 
     1401        OverlayElement *queryPanel = OverlayManager::getSingleton(). 
     1402                getOverlayElement("Example/Visibility/Query/QueryPanel"); 
     1403 
     1404        queryPanel->setHeight(top + border_height); 
     1405} 

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

    r159 r160  
    1313#include "OgrePlatformQueryManager.h" 
    1414 
     15class TestCullingTerrainApplication; 
     16 
     17 
    1518using namespace Ogre; 
    1619 
    … …  
    2528public: 
    2629         
    27    TerrainFrameListener(RenderWindow* win, Camera* cam, SceneManager *sceneManager,  
    28                 CEGUI::Renderer *renderer, TerrainContentGenerator *contentGenerator, Camera *vizCamera, 
    29                 SceneNode *camNode, Light *sunLight); 
     30   TerrainFrameListener(RenderWindow* win,  
     31                                                Camera* cam,  
     32                                                SceneManager *sceneManager,  
     33                                                CEGUI::Renderer *renderer,  
     34                                                TerrainContentGenerator *contentGenerator,  
     35                                                Camera *vizCamera, 
     36                                                SceneNode *camNode,  
     37                                                Light *sunLight, 
     38                                                TestCullingTerrainApplication *app); 
    3039 
    3140   ~TerrainFrameListener(); 
    … …  
    122131                @param useItemBuffer if item buffer should be used or occlusion queries 
    123132        */ 
    124         void ApplyVisibilityQuery(bool fromPoint, bool relativeVisibility, bool useItemBuffer); 
     133        void applyVisibilityQuery(bool fromPoint, bool relativeVisibility, bool useItemBuffer); 
    125134 
    126135        void toggleShowQueryStats(); 
    127136 
     137        /** Sets the type of the objects generated in the scene. 
     138        */ 
     139        void setObjectType(int objectType); 
     140 
    128141protected: 
     142 
     143        void initHelpOverlayElement(String name, int top); 
     144        void initOverlayElement(OverlayElement **elInfo, String ext, String name, int top, String caption); 
     145 
     146        //-- initialise overlays 
     147        void initHelpOverlay(); 
     148        void initVisStatsOverlay(); 
     149        void initQueryOverlay(); 
    129150 
    130151        void resetStats(); 
    … …  
    162183        OverlayElement *mUseDepthPassInfo; 
    163184        OverlayElement *mRenderedNodesInfo; 
    164         OverlayElement *mObjectsInfo; 
     185        OverlayElement *mObjectsCountInfo; 
    165186        OverlayElement *mQueriesIssuedInfo; 
    166187        OverlayElement *mDelayedQueriesIssuedInfo; 
    167188        OverlayElement *mDelayedTraversedNodesInfo; 
     189        OverlayElement *mCurrentObjectTypeInfo; 
    168190 
    169191        OverlayElement *mQueryTypeInfo; 
    … …  
    203225        std::vector<frame_info> mFrameInfo; 
    204226                 
    205         Real mTimeElapsed; 
     227        Real mReplayTimeElapsed; 
    206228        //EventProcessor* mEventProcessor; 
    207229    InputReader* mInputDevice; 
    … …  
    211233    RenderWindow* mWindow; 
    212234    
    213     //bool mUseBufferedInputKeys, mUseBufferedInputMouse, mInputTypeSwitchingOn; 
    214235        unsigned int mNumScreenShots; 
    215236    int mSceneDetailIndex; 
    … …  
    248269 
    249270        bool mRenderPatchesForItemBuffer; 
     271 
     272        int mCurrentObjectType; 
     273 
     274        TestCullingTerrainApplication *mApplication; 
    250275}; 
    251276 

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

    r159 r160  
    1515#include <windows.h> 
    1616 
    17 /*******************************************************/ 
    18 /*     TestCullingTerrainApplication implementation    */ 
    19 /*******************************************************/ 
     17String currentObjectCaptions[] = 
     18{ 
     19        "robot", 
     20        "athene", 
     21        "ninja" 
     22        //"ogrehead" 
     23}; 
     24 
     25/*********************************************************/ 
     26/*      TestCullingTerrainApplication implementation     */ 
     27/*********************************************************/ 
     28 
     29 
    2030TestCullingTerrainApplication::TestCullingTerrainApplication(): 
    2131mTerrainContentGenerator(NULL) 
    … …  
    3040                mTerrainContentGenerator = NULL; 
    3141        } 
    32         //if(mRenderTargetListener)     delete mRenderTargetListener; 
    3342} 
    3443//----------------------------------------------------------------------- 
    … …  
    127136        setupGui(); 
    128137 
    129          
    130138        /* // occluder plane to test visibility 
    131         Plane plane; 
    132         plane.normal = Vector3::UNIT_Y; 
    133         plane.d = -60; 
     139        Plane plane; plane.normal = Vector3::UNIT_Y;    plane.d = -60; 
    134140        MeshManager::getSingleton().createPlane("Myplane", 
    135141                ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, plane, 
    … …  
    152158        mTerrainContentGenerator = new TerrainContentGenerator(mSceneMgr); 
    153159         
    154         // if no objects file generate yourself 
     160        // if no objects in file, we generate new objects 
    155161        if (!mTerrainContentGenerator->LoadObjects("objects.out")) 
    156162        { 
    157163                // to provide much occlusion, 
    158                 // height is restricted to 50, so no objects appear on peaks 
     164                // height is restricted to 50 => no objects appear on peaks 
    159165                mTerrainContentGenerator->SetMaxPos(Vector3(3000.0f, 50.0f, 3000.0f)); 
    160166                mTerrainContentGenerator->SetOffset(0); 
    161167 
    162                 // the objects are generated on the whole terrain 
    163                 //mTerrainContentGenerator->GenerateScene(1500, "robot"); 
    164                 mTerrainContentGenerator->GenerateScene(1500, "athene"); 
    165                 //mTerrainContentGenerator->GenerateScene(500, "ninja"); 
     168                // the objects are generated randomly distributed over the terrain 
     169                generateScene(1500, 0); 
    166170        } 
    167171 
    … …  
    169173        // objects also on peaks of terrain 
    170174        mTerrainContentGenerator->SetMaxPos(Vector3(3000.0f, 5000.0f, 3000.0f)); 
     175} 
     176//----------------------------------------------------------------------- 
     177void  TestCullingTerrainApplication::generateScene(int num, int objectType) 
     178{ 
     179        mTerrainContentGenerator->GenerateScene(num, currentObjectCaptions[objectType]); 
     180 
     181        if (objectType != 0) // from our objects, only robot has animation phases 
     182                return; 
     183 
     184        EntityList *entList = mTerrainContentGenerator->GetGeneratedEntities(); 
     185 
     186        //-- add animation state for new robots (located at the end of the list) 
     187        for (int i = entList->size() - num; i < entList->size(); ++i) 
     188        { 
     189                Entity *ent = (*entList)[i]; 
     190                AnimationState *st = ent->getAnimationState("Idle"); 
     191                st->setEnabled(true); 
     192                st->setLoop(true); 
     193 
     194                mAnimationStates.push_back(st); 
     195                mAnimationSpeed.push_back(Math::RangeRandom(0.5, 1.5)); 
     196        } 
     197} 
     198//----------------------------------------------------------------------- 
     199std::vector<AnimationState *> &TestCullingTerrainApplication::getAnimationStates() 
     200{ 
     201        return mAnimationStates; 
     202} 
     203//----------------------------------------------------------------------- 
     204std::vector<Real> &TestCullingTerrainApplication::getAnimationSpeed() 
     205{ 
     206        return mAnimationSpeed; 
    171207} 
    172208//----------------------------------------------------------------------- 
    … …  
    189225{ 
    190226        mTerrainFrameListener = new TerrainFrameListener(mWindow, mCamera, mSceneMgr,  
    191                 mGUIRenderer, mTerrainContentGenerator, mVizCamera, mCamNode, mSunLight); 
     227                mGUIRenderer, mTerrainContentGenerator, mVizCamera, mCamNode, mSunLight, this); 
    192228         
    193229        mRoot->addFrameListener(mTerrainFrameListener); 
    194230} 
    195231//----------------------------------------------------------------------- 
     232String TestCullingTerrainApplication::getCurrentObjectCaption(int id) 
     233{ 
     234        return currentObjectCaptions[id]; 
     235} 
     236//----------------------------------------------------------------------- 
    196237void TestCullingTerrainApplication::chooseSceneManager() 
    197238{ 
    198239        mSceneMgr = mRoot->getSceneManager(ST_EXTERIOR_CLOSE); 
    199240} 
    200  
    201  
    202241/**************************************************************/ 
    203242/*      VisualizationRenderTargetListener implementation      */ 

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

    r145 r160  
    2525 
    2626 
    27 class TestCullingTerrainApplication : public ExampleApplication 
     27class TestCullingTerrainApplication: public ExampleApplication 
    2828{ 
    2929public: 
    … …  
    3131        ~TestCullingTerrainApplication(); 
    3232 
     33        void generateScene(int num, int objectType); 
     34 
     35        String getCurrentObjectCaption(int id); 
     36 
     37        std::vector<AnimationState *> &getAnimationStates(); 
     38        std::vector<Real> &getAnimationSpeed(); 
     39 
    3340protected: 
     41 
    3442        //-- inherited from ExampleApplication 
    3543        bool setup(); 
    … …  
    4048         
    4149        virtual void createRenderTargetListener(); 
     50 
     51        std::vector<AnimationState *> mAnimationStates; 
     52        std::vector<Real> mAnimationSpeed; 
    4253 
    4354        /** cegui setup */ 
    … …  
    6172        TerrainFrameListener *mTerrainFrameListener; 
    6273        ColourValue mAmbientLight; 
    63         //VisualizationRenderTargetListener *mVizRenderTargetListener; 
    6474         
    6575private: 

  • trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/src/OgreOctree.cpp

    r158 r160  
    262262        mWorldAABB = mWorldAABB.intersection(box);  
    263263         
    264         //std::stringstream d; d << "updating box: " << mWorldAABB << ", depth: " << mDepth << "null: " << mBox.isNull(); 
    265         //LogManager::getSingleton().logMessage(d.str()); 
    266  
    267264        // recursively update parent bounds 
    268265        if (mParent) 
Note: See TracChangeset for help on using the changeset viewer.