Ignore:
Timestamp:
06/15/05 01:18:51 (19 years ago)
Author:
mattausch
Message:

fixed some bugs

Location:
trunk/VUT/work/TestCullingTerrain
Files:
3 edited
2 moved

Legend:

Unmodified
Added
Removed

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

    r130 r133  
    55#include <../CEGUIRenderer/include/OgreCEGUITexture.h> 
    66#include <OgreMemoryMacros.h> 
    7 #include "TerrainMouseQueryListener.h" 
     7#include "TerrainFrameListener.h" 
    88#include "OgrePlatformQueryManager.h" 
    99#include "OgreVisibilityTerrainSceneManager.h" 
    … …  
    1616 
    1717 
    18 #define KEY_PRESSED(_key, _timeDelay, _macro) \ 
    19 { \ 
    20     if (mInputDevice->isKeyDown(_key) && mTimeDelay <= 0) \ 
    21 { \ 
    22     mTimeDelay = _timeDelay; \ 
    23     _macro ; \ 
    24 } \ 
    25 } 
    26  
    27  
    2818String mCurrentAlgorithmCaptions[GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS] =  
    2919{ 
    … …  
    3525 
    3626//----------------------------------------------------------------------- 
    37 TerrainMouseQueryListener::TerrainMouseQueryListener(RenderWindow* win, Camera* cam,  
     27TerrainFrameListener::TerrainFrameListener(RenderWindow* win, Camera* cam,  
    3828                                                                           SceneManager *sceneManager,  
    3929                                                                           CEGUI::Renderer *renderer, 
    … …  
    8272mDisplayCameraDetails(false), 
    8373mVisualizeCulledNodes(false), 
    84 mSunLight(sunLight) 
     74mSunLight(sunLight), 
     75mShiftPressed(false) 
    8576{ 
    8677        //mInputDevice = PlatformManager::getSingleton().createInputReader(); 
    … …  
    9384        mEventProcessor->addMouseListener(this); 
    9485        mEventProcessor->addMouseMotionListener(this); 
    95  
    96         //mEventProcessor->addKeyListener(this); 
     86        mEventProcessor->addKeyListener(this); 
     87 
    9788        mInputDevice = mEventProcessor->getInputReader(); 
    9889         
    … …  
    154145        mSceneMgr->setOption("ShowVisualization", &mShowVisualization); 
    155146 
    156         mVisibilityManager =  
    157                 dynamic_cast<VisibilityTerrainSceneManager *>(mSceneMgr)->GetVisibilityManager(); 
     147        // TODO: change this 
     148        mVisibilityManager = dynamic_cast<VisibilityTerrainSceneManager *>(mSceneMgr)-> 
     149                GetVisibilityManager(); 
    158150 
    159151        dynamic_cast<PlatformQueryManager *>(mVisibilityManager->GetQueryManager())-> 
    … …  
    161153}  
    162154//----------------------------------------------------------------------- 
    163 TerrainMouseQueryListener::~TerrainMouseQueryListener() 
     155TerrainFrameListener::~TerrainFrameListener() 
    164156{ 
    165157        //PlatformManager::getSingleton().destroyInputReader(mInputDevice); 
    … …  
    169161} 
    170162//----------------------------------------------------------------------- 
    171 void TerrainMouseQueryListener::mouseMoved(MouseEvent *e) 
     163void TerrainFrameListener::mouseMoved(MouseEvent *e) 
    172164{ 
    173165        // Update CEGUI with the mouse motion 
    … …  
    176168} 
    177169//----------------------------------------------------------------------- 
    178 void TerrainMouseQueryListener::mousePressed(MouseEvent* e) 
     170void TerrainFrameListener::mousePressed(MouseEvent* e) 
    179171{ 
    180172     // Left mouse button down 
    … …  
    200192         mRMouseDown = true; 
    201193     } 
    202 } // mousePressed 
    203 //----------------------------------------------------------------------- 
    204 void TerrainMouseQueryListener::mouseReleased(MouseEvent* e) 
     194}  
     195//----------------------------------------------------------------------- 
     196void TerrainFrameListener::mouseReleased(MouseEvent* e) 
    205197{ 
    206198    // Left mouse button up 
    … …  
    218210}  
    219211//----------------------------------------------------------------------- 
    220 void TerrainMouseQueryListener::mouseDragged(MouseEvent *e) 
     212void TerrainFrameListener::mouseDragged(MouseEvent *e) 
    221213 { 
    222214         // If we are dragging the left mouse button.             
    … …  
    244236} 
    245237//----------------------------------------------------------------------- 
    246 bool TerrainMouseQueryListener::frameStarted(const FrameEvent &evt) 
     238bool TerrainFrameListener::frameStarted(const FrameEvent &evt) 
    247239{ 
    248240        if (mWindow->isClosed()) 
    … …  
    287279        } 
    288280/*      if (!processUnbufferedMouseInput(evt)) 
    289         { 
    290                 return false; 
    291         }*/ 
     281        {       return false;   }*/ 
     282 
    292283        // --- set parameters for visualization 
    293284        if (mShowVisualization) 
    … …  
    330321                                StringConverter::toString(mFrameInfo.size() - 1)); 
    331322                }        
    332  
     323                // move camera according to input 
    333324                moveCamera(); 
     325                // clamp camera so we always walk along the terrain 
    334326                Clamp2Terrain(); 
    335  
    336                 break; 
     327                break; 
     328 
    337329        default: 
    338330                break; 
    … …  
    342334} 
    343335//----------------------------------------------------------------------- 
    344 void TerrainMouseQueryListener::ApplyVisibilityQuery() 
     336void TerrainFrameListener::ApplyVisibilityQuery(bool fromPoint, bool relativeVisibility) 
    345337{ 
    346338        InfoContainer<GtpVisibility::NodeInfo> visibleNodes; 
    347339        InfoContainer<GtpVisibility::MeshInfo> visibleGeometry; 
    348340 
    349     mVisibilityManager->GetQueryManager()->ComputeCameraVisibility(*mCamera, 
    350                             &visibleNodes, &visibleGeometry, false); 
     341        if (fromPoint) 
     342        { 
     343        } 
     344        else 
     345        { 
     346                mVisibilityManager->GetQueryManager()->ComputeCameraVisibility(*mCamera, 
     347                            &visibleNodes, &visibleGeometry, relativeVisibility); 
     348        } 
    351349 
    352350        for (int i=0; i < visibleGeometry.size(); ++i) 
    … …  
    363361} 
    364362//----------------------------------------------------------------------- 
    365 void TerrainMouseQueryListener::Clamp2Terrain() 
     363void TerrainFrameListener::Clamp2Terrain() 
    366364{ 
    367365        // clamp to terrain 
    … …  
    376374} 
    377375//----------------------------------------------------------------------- 
    378 bool TerrainMouseQueryListener::frameEnded(const FrameEvent& evt) 
     376bool TerrainFrameListener::frameEnded(const FrameEvent& evt) 
    379377{ 
    380378        if (mShutdownRequested) 
    … …  
    386384} 
    387385//----------------------------------------------------------------------- 
    388 void TerrainMouseQueryListener::moveCamera() 
     386void TerrainFrameListener::moveCamera() 
    389387{ 
    390388        // move node rather than camera so orientation is right in the visualization 
    … …  
    394392} 
    395393//----------------------------------------------------------------------- 
    396 void TerrainMouseQueryListener::writeFrames() 
     394void TerrainFrameListener::writeFrames() 
    397395{ 
    398396        std::ofstream ofstr(frames_out_filename); 
    … …  
    410408} 
    411409//----------------------------------------------------------------------- 
    412 void TerrainMouseQueryListener::loadFrames() 
     410void TerrainFrameListener::loadFrames() 
    413411{ 
    414412        std::ifstream ifstr(frames_out_filename); 
    … …  
    436434} 
    437435//----------------------------------------------------------------------- 
    438 void TerrainMouseQueryListener::nextAppState() 
     436void TerrainFrameListener::nextAppState() 
    439437{ 
    440438        mCurrentFrame = 0; 
    … …  
    496494} 
    497495//----------------------------------------------------------------------- 
    498 void TerrainMouseQueryListener::toggleRecord() 
     496void TerrainFrameListener::toggleRecord() 
    499497{ 
    500498        mRecord = !mRecord; 
    … …  
    507505} 
    508506//----------------------------------------------------------------------- 
    509 void TerrainMouseQueryListener::changeThreshold(int incr) 
     507void TerrainFrameListener::changeThreshold(int incr) 
    510508{ 
    511509        mVisibilityThreshold += incr;  
    … …  
    518516} 
    519517//----------------------------------------------------------------------- 
    520 void TerrainMouseQueryListener::zoomVizCamera(int zoom) 
     518void TerrainFrameListener::zoomVizCamera(int zoom) 
    521519{ 
    522520        mVizCameraHeight += zoom;  
    … …  
    524522} 
    525523//----------------------------------------------------------------------- 
    526 void TerrainMouseQueryListener::nextAlgorithm() 
     524void TerrainFrameListener::nextAlgorithm() 
    527525{ 
    528526        mCurrentAlgorithm = (mCurrentAlgorithm + 1) %  
    … …  
    532530} 
    533531//----------------------------------------------------------------------- 
    534 void TerrainMouseQueryListener::setAlgorithm(int algorithm) 
     532void TerrainFrameListener::setAlgorithm(int algorithm) 
    535533{ 
    536534        mAlgorithmInfo->setCaption(": " + mCurrentAlgorithmCaptions[mCurrentAlgorithm]); 
    … …  
    538536} 
    539537//----------------------------------------------------------------------- 
    540 void TerrainMouseQueryListener::updateStats() 
     538void TerrainFrameListener::updateStats() 
    541539{ 
    542540        unsigned int opt = 0; 
    … …  
    599597} 
    600598//----------------------------------------------------------------------- 
    601 void TerrainMouseQueryListener::toggleUseOptimization() 
     599void TerrainFrameListener::toggleUseOptimization() 
    602600{ 
    603601        mUseOptimization = !mUseOptimization; 
    604  
    605602        mSceneMgr->setOption("UseOptimization", &mUseOptimization); 
    606         // delayed rendering (i.e., render transparents afterwards) allows  
    607         // no optimization which tests geometry instead of aabb 
     603         
     604        // disable optimization which tests geometry instead of aabb 
     605        // for delayed rendering (i.e., render transparents after all the solids) 
     606        // because otherwise visible transparents could be skipped 
    608607        bool delayedRendering = !mUseOptimization; 
    609608        mSceneMgr->setOption("DelayRenderTransparents", &delayedRendering); 
    610609 
    611610        if (mUseOptimization) 
     611        { 
    612612                mUseOptimizationInfo->setCaption(": true"); 
     613        } 
    613614        else 
     615        { 
    614616                mUseOptimizationInfo->setCaption(": false"); 
    615 } 
    616 //----------------------------------------------------------------------- 
    617 void TerrainMouseQueryListener::toggleShowOctree() 
     617        } 
     618} 
     619//----------------------------------------------------------------------- 
     620void TerrainFrameListener::toggleShowOctree() 
    618621{ 
    619622        mShowOctree = !mShowOctree; 
    … …  
    622625} 
    623626//----------------------------------------------------------------------- 
    624 void TerrainMouseQueryListener::toggleUseDepthPass() 
     627void TerrainFrameListener::toggleUseDepthPass() 
    625628{ 
    626629        mUseDepthPass = !mUseDepthPass; 
    … …  
    638641} 
    639642//----------------------------------------------------------------------- 
    640 void TerrainMouseQueryListener::toggleShowViz() 
     643void TerrainFrameListener::toggleShowViz() 
    641644{ 
    642645        mShowVisualization = !mShowVisualization; 
    … …  
    677680} 
    678681//----------------------------------------------------------------------- 
    679 void TerrainMouseQueryListener::toggleUseShadows() 
     682void TerrainFrameListener::toggleUseShadows() 
    680683{ 
    681684        mUseShadows = !mUseShadows; 
    … …  
    694697} 
    695698//----------------------------------------------------------------------- 
    696 void TerrainMouseQueryListener::nextNodeVizMode() 
     699void TerrainFrameListener::nextNodeVizMode() 
    697700{ 
    698701        mNodeVizMode = (mNodeVizMode + 1) % NODEVIZ_MODES_NUM; 
    … …  
    707710} 
    708711//----------------------------------------------------------------------- 
    709 void TerrainMouseQueryListener::keyPressed(KeyEvent* e) 
    710 { 
    711         if(e->getKey() == KC_ESCAPE) 
    712     { 
     712void TerrainFrameListener::keyPressed(KeyEvent* e) 
     713{ 
     714        switch(e->getKey()) 
     715        { 
     716        case KC_ESCAPE: 
    713717                mShutdownRequested = true; 
    714718                e->consume(); 
    715719                return; 
    716         } 
    717  
    718         CEGUI::System::getSingleton().injectKeyDown(e->getKey()); 
    719         CEGUI::System::getSingleton().injectChar(e->getKeyChar()); 
    720         e->consume(); 
    721 } 
    722 //----------------------------------------------------------------------- 
    723 void TerrainMouseQueryListener::keyReleased(KeyEvent* e) 
    724 { 
    725         CEGUI::System::getSingleton().injectKeyUp(e->getKey()); 
    726         e->consume(); 
    727 } 
    728 //----------------------------------------------------------------------- 
    729 void TerrainMouseQueryListener::keyClicked(KeyEvent* e)  
    730 { 
    731         // Do nothing 
    732         e->consume(); 
    733 } 
    734 //----------------------------------------------------------------------- 
    735 void TerrainMouseQueryListener::addFrameInfo(SceneNode *camNode, Real timeElapsed) 
    736 { 
    737         frame_info info; 
    738         info.orientation = mCamNode->getOrientation(); 
    739         info.position = mCamNode->getPosition(); 
    740         info.timeElapsed = timeElapsed; 
    741  
    742         mFrameInfo.push_back(info); 
    743 } 
    744 //----------------------------------------------------------------------- 
    745 void TerrainMouseQueryListener::setCurrentFrameInfo(Real timeElapsed) 
    746 { 
    747         //-- find current frame relative to elapsed frame time           
    748         mTimeElapsed -= timeElapsed; 
    749  
    750         while ((mTimeElapsed <= 0) && (mCurrentFrame < (int)mFrameInfo.size() - 1)) 
    751         { 
    752                 mTimeElapsed += mFrameInfo[mCurrentFrame ++].timeElapsed; 
    753         } 
    754  
    755         frame_info new_frame = mFrameInfo[mCurrentFrame]; 
    756         frame_info old_frame = mFrameInfo[mCurrentFrame - 1]; 
    757                  
    758         //-- interpolate frames 
    759         Real factor = 1; 
    760  
    761         if (old_frame.timeElapsed > 0) 
    762                 factor = mTimeElapsed / old_frame.timeElapsed; 
    763  
    764         Vector3 camPos = old_frame.position + factor * (new_frame.position - old_frame.position); 
    765         Quaternion camOrienation = Quaternion::Slerp(factor, old_frame.orientation,  
    766                 new_frame.orientation, true); 
    767  
    768         mCamNode->setPosition(camPos); 
    769         mCamNode->setOrientation(camOrienation); 
    770          
    771         // stop replay after a full walkthrough 
    772         if (mCurrentFrame == (int)mFrameInfo.size() - 1) 
    773         { 
     720 
     721        case KC_SPACE: 
     722                nextAlgorithm(); 
     723                break; 
     724         
     725        case KC_F: 
     726                nextFilter(); 
     727                break; 
     728        case KC_R: 
     729                nextSceneDetailLevel(); 
     730                break; 
     731        case KC_P: 
     732                toggleDisplayCameraDetails(); 
     733                break; 
     734        case KC_O: 
     735                toggleUseOptimization(); 
     736                break; 
     737        case KC_T: 
     738                toggleShowOctree(); 
     739                break; 
     740        case KC_X: 
     741                toggleUseDepthPass(); 
     742                break; 
     743        case KC_S: 
     744                toggleUseShadows(); 
     745                break; 
     746 
     747        case KC_SUBTRACT: 
     748                changeThreshold(-10); 
     749                break; 
     750        case KC_ADD: 
     751                changeThreshold(10); 
     752                break; 
     753 
     754        //-- visualization 
     755        case KC_1: 
     756                toggleShowViz(); 
     757                break; 
     758        case KC_2: 
     759                nextNodeVizMode(); 
     760                break; 
     761 
     762        case KC_F1: 
     763                toggleShowHelp(); 
     764                break; 
     765        case KC_F2: 
     766                toggleShowStats(); 
     767                break; 
     768        case KC_F3: 
    774769                nextAppState(); 
    775         } 
    776 } 
    777 //-----------------------------------------------------------------------     
    778 bool TerrainMouseQueryListener::processUnbufferedKeyInput(const FrameEvent& evt) 
    779 { 
    780         if (mInputDevice->isKeyDown(KC_ESCAPE)) 
    781     {             
    782         return false; 
    783     } 
    784  
    785         /* Move camera forward by keypress. */ 
    786     if (mInputDevice->isKeyDown(KC_UP)) 
    787         { 
    788                 mTranslateVector.z = -mMoveScale; 
    789         } 
    790  
    791     /* Move camera backward by keypress. */ 
    792     if (mInputDevice->isKeyDown(KC_DOWN)) 
    793     { 
    794                 mTranslateVector.z = mMoveScale; 
    795     } 
    796  
    797     if (mInputDevice->isKeyDown(KC_RIGHT)) 
    798     { 
    799         mCamNode->yaw(-mRotScale); 
    800     } 
    801          
    802     if (mInputDevice->isKeyDown(KC_LEFT)) 
    803     { 
    804         mCamNode->yaw(mRotScale); 
    805     } 
    806  
    807         KEY_PRESSED(KC_SPACE, 0.3, nextAlgorithm()); 
    808         KEY_PRESSED(KC_F, 0.3, nextFilter()); 
    809         KEY_PRESSED(KC_R, 0.3, nextSceneDetailLevel()); 
    810  
    811         KEY_PRESSED(KC_P, 0.3, toggleDisplayCameraDetails()); 
    812         KEY_PRESSED(KC_O, 0.3, toggleUseOptimization()); 
    813         KEY_PRESSED(KC_T, 0.3, toggleShowOctree()); 
    814         KEY_PRESSED(KC_X, 0.3, toggleUseDepthPass()); 
    815         KEY_PRESSED(KC_S, 0.3, toggleUseShadows()); 
    816  
    817         KEY_PRESSED(KC_SUBTRACT, 0, changeThreshold(-10)); 
    818         KEY_PRESSED(KC_ADD, 0, changeThreshold(10)); 
    819          
    820         //-- visualization 
    821         KEY_PRESSED(KC_1, 0.3, toggleShowViz()); 
    822         KEY_PRESSED(KC_2, 0.3, nextNodeVizMode()); 
    823         KEY_PRESSED(KC_3, 0, zoomVizCamera(50)); 
    824         KEY_PRESSED(KC_4, 0, zoomVizCamera(-50)); 
    825  
    826         KEY_PRESSED(KC_F1, 0.3, toggleShowHelp()); 
    827         KEY_PRESSED(KC_F2, 0.3, toggleShowStats()); 
    828         KEY_PRESSED(KC_F3, 0.3, nextAppState()); 
    829         KEY_PRESSED(KC_F4, 0.3, toggleRecord()); 
    830         KEY_PRESSED(KC_F5, 0.3, ApplyVisibilityQuery()); 
    831  
    832         KEY_PRESSED(KC_F11, 0.3, takeScreenShot()); 
    833         KEY_PRESSED(KC_F12, 0.3, mTerrainContentGenerator->WriteObjects(objects_out_filename)); 
     770                break; 
     771        case KC_F4: 
     772                toggleRecord(); 
     773                break; 
     774        case KC_F5: 
     775                ApplyVisibilityQuery(false, mShiftPressed); 
     776                break; 
     777        case KC_F6: 
     778                ApplyVisibilityQuery(true, mShiftPressed); 
     779                break; 
     780 
     781        case KC_F11: 
     782                takeScreenShot(); 
     783                break; 
     784        case KC_F12: 
     785                mTerrainContentGenerator->WriteObjects(objects_out_filename); 
     786                break; 
     787 
     788        case KC_LSHIFT: 
     789                mShiftPressed = !mShiftPressed; 
     790                break; 
    834791        //KEY_PRESSED(KC_F3, 0.3, writeFrames()); 
    835792        //KEY_PRESSED(KC_F4, 0.3, loadFrames()); 
     793        default: 
     794                break; 
     795        } 
    836796 
    837797        if (mDisplayCameraDetails) 
    … …  
    842802    } 
    843803 
     804        CEGUI::System::getSingleton().injectKeyDown(e->getKey()); 
     805        CEGUI::System::getSingleton().injectChar(e->getKeyChar()); 
     806        e->consume(); 
     807} 
     808//----------------------------------------------------------------------- 
     809void TerrainFrameListener::keyReleased(KeyEvent* e) 
     810{ 
     811        CEGUI::System::getSingleton().injectKeyUp(e->getKey()); 
     812        e->consume(); 
     813} 
     814//----------------------------------------------------------------------- 
     815void TerrainFrameListener::keyClicked(KeyEvent* e)  
     816{ 
     817        // Do nothing 
     818        e->consume(); 
     819} 
     820//----------------------------------------------------------------------- 
     821void TerrainFrameListener::addFrameInfo(SceneNode *camNode, Real timeElapsed) 
     822{ 
     823        frame_info info; 
     824        info.orientation = mCamNode->getOrientation(); 
     825        info.position = mCamNode->getPosition(); 
     826        info.timeElapsed = timeElapsed; 
     827 
     828        mFrameInfo.push_back(info); 
     829} 
     830//----------------------------------------------------------------------- 
     831void TerrainFrameListener::setCurrentFrameInfo(Real timeElapsed) 
     832{ 
     833        //-- find current frame relative to elapsed frame time           
     834        mTimeElapsed -= timeElapsed; 
     835 
     836        while ((mTimeElapsed <= 0) && (mCurrentFrame < (int)mFrameInfo.size() - 1)) 
     837        { 
     838                mTimeElapsed += mFrameInfo[mCurrentFrame ++].timeElapsed; 
     839        } 
     840 
     841        frame_info new_frame = mFrameInfo[mCurrentFrame]; 
     842        frame_info old_frame = mFrameInfo[mCurrentFrame - 1]; 
     843                 
     844        //-- interpolate frames 
     845        Real factor = 1; 
     846 
     847        if (old_frame.timeElapsed > 0) 
     848        { 
     849                factor = mTimeElapsed / old_frame.timeElapsed; 
     850        } 
     851 
     852        Vector3 camPos = old_frame.position + factor  
     853                * (new_frame.position - old_frame.position); 
     854        Quaternion camOrienation = Quaternion::Slerp(factor, old_frame.orientation,  
     855                new_frame.orientation, true); 
     856 
     857        mCamNode->setPosition(camPos); 
     858        mCamNode->setOrientation(camOrienation); 
     859         
     860        // stop replay after a full walkthrough 
     861        if (mCurrentFrame == (int)mFrameInfo.size() - 1) 
     862        { 
     863                nextAppState(); 
     864        } 
     865} 
     866//-----------------------------------------------------------------------     
     867bool TerrainFrameListener::processUnbufferedKeyInput(const FrameEvent& evt) 
     868{ 
     869        /*if (mInputDevice->isKeyDown(KC_ESCAPE)) 
     870    {             
     871        return false; 
     872    }*/ 
     873 
     874        /* Move camera forward by keypress. */ 
     875    if (mInputDevice->isKeyDown(KC_UP)) 
     876        { 
     877                mTranslateVector.z = -mMoveScale; 
     878        } 
     879 
     880    /* Move camera backward by keypress. */ 
     881    if (mInputDevice->isKeyDown(KC_DOWN)) 
     882    { 
     883                mTranslateVector.z = mMoveScale; 
     884    } 
     885 
     886    if (mInputDevice->isKeyDown(KC_RIGHT)) 
     887    { 
     888        mCamNode->yaw(-mRotScale); 
     889    } 
     890         
     891    if (mInputDevice->isKeyDown(KC_LEFT)) 
     892    { 
     893        mCamNode->yaw(mRotScale); 
     894    } 
     895        // visualization camera 
     896        if (mInputDevice->isKeyDown(KC_3)) 
     897        { 
     898                zoomVizCamera(50); 
     899        } 
     900        if (mInputDevice->isKeyDown(KC_4)) 
     901        { 
     902                zoomVizCamera(-50); 
     903        } 
     904 
     905 
    844906    // Return true to continue rendering 
    845907    return true; 
    846908} 
    847909//----------------------------------------------------------------------- 
    848 void TerrainMouseQueryListener::nextFilter() 
    849 { 
    850         switch(mFiltering) 
     910void TerrainFrameListener::nextFilter() 
     911{ 
     912        switch (mFiltering) 
    851913        { 
    852914        case TFO_BILINEAR: 
    … …  
    869931    MaterialManager::getSingleton().setDefaultAnisotropy(mAniso); 
    870932 
     933        // reload stats 
    871934    showStats(mStatsOn); 
    872935} 
    873936//----------------------------------------------------------------------- 
    874 void TerrainMouseQueryListener::nextSceneDetailLevel() 
    875 { 
    876         mSceneDetailIndex = (mSceneDetailIndex+1)%3 ; 
    877         switch(mSceneDetailIndex)  
    878         { 
    879                 case 0 : mCamera->setDetailLevel(SDL_SOLID) ; break ; 
    880                 case 1 : mCamera->setDetailLevel(SDL_WIREFRAME) ; break ; 
    881                 case 2 : mCamera->setDetailLevel(SDL_POINTS) ; break ; 
    882         } 
    883 } 
    884 //----------------------------------------------------------------------- 
    885 void TerrainMouseQueryListener::takeScreenShot() 
     937void TerrainFrameListener::nextSceneDetailLevel() 
     938{ 
     939        mSceneDetailIndex = (mSceneDetailIndex + 1) % 3; 
     940        switch (mSceneDetailIndex)  
     941        { 
     942                case 0:  
     943                        mCamera->setDetailLevel(SDL_SOLID);  
     944                        break; 
     945                case 1:  
     946                        mCamera->setDetailLevel(SDL_WIREFRAME);  
     947                        break; 
     948                case 2:  
     949                        mCamera->setDetailLevel(SDL_POINTS);  
     950                        break; 
     951        } 
     952} 
     953//----------------------------------------------------------------------- 
     954void TerrainFrameListener::takeScreenShot() 
    886955{ 
    887956        char tmp[20]; 
    … …  
    891960} 
    892961//----------------------------------------------------------------------- 
    893 void TerrainMouseQueryListener::toggleDisplayCameraDetails() 
     962void TerrainFrameListener::toggleDisplayCameraDetails() 
    894963{ 
    895964        mDisplayCameraDetails = !mDisplayCameraDetails; 
    896965         
    897966    if (!mDisplayCameraDetails) 
     967        { 
    898968                mWindow->setDebugText(""); 
    899 } 
    900 //----------------------------------------------------------------------- 
    901 bool TerrainMouseQueryListener::processUnbufferedMouseInput(const FrameEvent& evt) 
    902 { 
    903         /* Rotation factors, may not be used if the second mouse button is pressed. */ 
    904  
    905         /* If the second mouse button is pressed, then the mouse movement results in  
    906         sliding the camera, otherwise we rotate. */ 
    907         if(mInputDevice->getMouseButton(1)) 
    908         { 
    909                 mTranslateVector.x += mInputDevice->getMouseRelativeX() * 0.13; 
    910                 mTranslateVector.y -= mInputDevice->getMouseRelativeY() * 0.13; 
    911         } 
    912     else 
    913     { 
    914                 mRotX = Degree(-mInputDevice->getMouseRelativeX() * 0.13); 
    915                 mRotY = Degree(-mInputDevice->getMouseRelativeY() * 0.13); 
    916     } 
    917  
    918  
    919         return true; 
    920 } 
    921 //----------------------------------------------------------------------- 
    922 void TerrainMouseQueryListener::showStats(bool show) 
     969        } 
     970} 
     971//----------------------------------------------------------------------- 
     972void TerrainFrameListener::showStats(bool show) 
    923973{ 
    924974        if (mDebugOverlay && mCullStatsOverlay) 
    … …  
    937987} 
    938988//----------------------------------------------------------------------- 
    939 void TerrainMouseQueryListener::toggleShowStats() 
     989void TerrainFrameListener::toggleShowStats() 
    940990{ 
    941991        mStatsOn = !mStatsOn; 
    … …  
    944994} 
    945995//----------------------------------------------------------------------- 
    946 void TerrainMouseQueryListener::toggleShowHelp() 
     996void TerrainFrameListener::toggleShowHelp() 
    947997{ 
    948998        mShowHelp = !mShowHelp; 
    … …  
    9571007        } 
    9581008} 
    959  
    960          

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

    r130 r133  
    1 #ifndef _TerrainMouseQueryListener_H__ 
    2 #define _TerrainMouseQueryListener_H__ 
     1#ifndef _TerrainFrameListener_H__ 
     2#define _TerrainFrameListener_H__ 
    33 
    44#include "CEGUIForwardRefs.h" 
    … …  
    2020/** Mouse query listener for terrain  
    2121*/ 
    22 class TerrainMouseQueryListener: public FrameListener, public MouseListener, public MouseMotionListener 
     22class TerrainFrameListener: public FrameListener, public MouseListener, public MouseMotionListener, public KeyListener 
    2323{ 
    2424public: 
    2525         
    26    TerrainMouseQueryListener(RenderWindow* win, Camera* cam, SceneManager *sceneManager,  
     26   TerrainFrameListener(RenderWindow* win, Camera* cam, SceneManager *sceneManager,  
    2727                CEGUI::Renderer *renderer, TerrainContentGenerator *contentGenerator, Camera *vizCamera, 
    2828                SceneNode *camNode, Light *sunLight); 
    2929 
    30    ~TerrainMouseQueryListener(); 
     30   ~TerrainFrameListener(); 
    3131 
    3232 
    … …  
    114114        void toggleRecord(); 
    115115 
    116         void ApplyVisibilityQuery(); 
    117  
    118         void switchMouseMode()  
    119         { 
    120         mUseBufferedInputMouse = !mUseBufferedInputMouse; 
    121                 mInputDevice->setBufferedInput(mUseBufferedInputKeys, mUseBufferedInputMouse); 
    122         } 
     116        /** Applies visibility query. Collects the visible objects  
     117                and their visibility information. 
     118                @param fromnPoint if query should be from point or from camera 
     119                @param relativeVisibility if query should return number of visible pixels or the ratio 
     120                visible pixels / projected pixels. 
     121        */ 
     122        void ApplyVisibilityQuery(bool fromPoint, bool relativeVisibility); 
     123 
    123124protected: 
    124125 
    … …  
    212213        EventProcessor* mEventProcessor; 
    213214         
    214         bool mUseBufferedInputKeys, mUseBufferedInputMouse, mInputTypeSwitchingOn; 
    215          
     215        bool mShiftPressed; 
     216        //bool mUseBufferedInputKeys, mUseBufferedInputMouse, mInputTypeSwitchingOn; 
    216217}; 
    217218 
    218219 
    219 #endif //_TerrainMouseQueryListener_H__ 
     220#endif //_TerrainFrameListener_H__ 

  • trunk/VUT/work/TestCullingTerrain/TestCullingTerrain.vcproj

    r130 r133  
    123123                        UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"> 
    124124                        <File 
    125                                 RelativePath=".\TerrainMouseQueryListener.cpp"> 
     125                                RelativePath=".\TerrainFrameListener.cpp"> 
    126126                        </File> 
    127127                        <File 
    … …  
    134134                        UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"> 
    135135                        <File 
    136                                 RelativePath=".\TerrainMouseQueryListener.h"> 
     136                                RelativePath=".\TerrainFrameListener.h"> 
    137137                        </File> 
    138138                        <File 

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

    r122 r133  
    187187     CEGUI::SchemeManager::getSingleton().loadScheme((CEGUI::utf8*)"TaharezLook.scheme"); 
    188188     CEGUI::MouseCursor::getSingleton().setImage("TaharezLook", "MouseArrow"); 
    189          mGUISystem->setDefaultMouseCursor( 
    190                 (CEGUI::utf8*)"TaharezLook", (CEGUI::utf8*)"MouseArrow"); 
     189         mGUISystem->setDefaultMouseCursor((CEGUI::utf8*)"TaharezLook",  
     190                                                                          (CEGUI::utf8*)"MouseArrow"); 
    191191 
    192192         CEGUI::MouseCursor::getSingleton().show(); 
    … …  
    195195void TestCullingTerrainApplication::createFrameListener() 
    196196{ 
    197         mTerrainFrameListener = new TerrainMouseQueryListener(mWindow, mCamera, mSceneMgr,  
     197        mTerrainFrameListener = new TerrainFrameListener(mWindow, mCamera, mSceneMgr,  
    198198                mGUIRenderer, mTerrainContentGenerator, mVizCamera, mCamNode, mSunLight); 
    199199         
    … …  
    218218void VisualizationRenderTargetListener::preViewportUpdate(const RenderTargetViewportEvent &evt) 
    219219{ 
    220         const bool showViz = evt.source->getZOrder() == VIZ_VIEWPORT_Z_ORDER; // visualization viewport 
     220        // visualization viewport 
     221        const bool showViz = evt.source->getZOrder() == VIZ_VIEWPORT_Z_ORDER; 
    221222        const bool nShowViz = !showViz; 
    222223 

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

    r130 r133  
    77 
    88#include <OgreRenderTargetListener.h> 
    9 #include "TerrainMouseQueryListener.h" 
     9#include "TerrainFrameListener.h" 
    1010 
    1111class VisualizationRenderTargetListener: public RenderTargetListener 
    … …  
    5656        VisualizationRenderTargetListener *mRenderTargetListener; 
    5757 
    58         TerrainMouseQueryListener *mTerrainFrameListener; 
     58        TerrainFrameListener *mTerrainFrameListener; 
    5959         
    6060private: 
Note: See TracChangeset for help on using the changeset viewer.