Changeset 100 for trunk/VUT


Ignore:
Timestamp:
05/16/05 20:22:32 (20 years ago)
Author:
mattausch
Message:

added visualization for octree culling
camera in terrainexample is now attached to camera node => can see correct camera
in visualization

Location:
trunk/VUT
Files:
4 added
20 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/GtpVisibility/src/StopAndWaitCullingManager.cpp

    r96 r100  
    3939                        unsigned int visiblePixels = 0; 
    4040 
    41                         mHierarchyInterface->IssueOcclusionQuery(node)->GetQueryResult(visiblePixels, true); 
     41                        mHierarchyInterface->IssueOcclusionQuery(node)-> 
     42                                GetQueryResult(visiblePixels, true); 
    4243                         
    4344                        // node visible 

  • trunk/VUT/GtpVisibility/src/VisibilityEnvironment.cpp

    r74 r100  
    22 
    33namespace GtpVisibility { 
     4 
    45//----------------------------------------------------------------------- 
    56VisibilityEnvironment::VisibilityEnvironment() 

  • trunk/VUT/GtpVisibility/src/VisibilityManager.cpp

    r99 r100  
    1010//----------------------------------------------------------------------- 
    1111VisibilityManager::VisibilityManager(VisibilityEnvironment *visEnvironment): 
    12 mVisibilityThreshold(0), mCullingManager(NULL)  
     12mVisibilityThreshold(0), mCullingManager(NULL), 
     13mQueryManager(new DummyQueryManager(NULL)), 
     14mPreprocessingManager(new DummyPreprocessingManager(NULL)), 
     15mVisibilityEnvironment(visEnvironment) 
    1316{ 
    14         mVisibilityEnvironment = visEnvironment; 
    15          
    16         //SetCullingManager(VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING); 
    17         SetCullingManager(VisibilityEnvironment::FRUSTUM_CULLING); 
    18  
    19         mQueryManager = new DummyQueryManager(0); 
    20         mPreprocessingManager = new DummyPreprocessingManager(0); 
     17        SetCullingManager(VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING); 
     18        //SetCullingManager(VisibilityEnvironment::FRUSTUM_CULLING); 
    2119} 
    2220//----------------------------------------------------------------------- 
    … …  
    3331        { 
    3432                // delete old culling manager 
    35                 if(mCullingManager) 
     33                if (mCullingManager) 
    3634                        delete mCullingManager; 
    3735 
    … …  
    7371        mCullingManager->RenderScene(); 
    7472} 
     73//----------------------------------------------------------------------- 
    7574VisibilityEnvironment::CullingManagerType VisibilityManager::GetCullingManagerType() 
    7675{ 
    7776        return mCullingManagerType; 
    7877} 
    79 //----------------------------------------------------------------------- 
     78 
    8079} // namespace GtpVisibility 

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

    r99 r100  
    5757        OctreeHierarchyInterface *mHierarchyInterface; 
    5858        GtpVisibility::VisibilityManager *mVisibilityManager; 
     59         
    5960        bool mUseVisibilityCulling; 
     61        bool mShowVisualization; 
    6062}; 
    6163 

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

    r99 r100  
    5656        void WriteLog(); 
    5757        void SetShowVisualization(bool showViz); 
    58          
     58 
     59/*      void SetSkyBoxEnabled(bool enabled); 
     60        void SetSkyPlaneEnabled(bool enabled); 
     61        void SetSkyDomeEnabled(bool enabled);*/ 
     62 
    5963protected: 
    6064         

  • trunk/VUT/Ogre/scripts/Plugin_VisibilitySceneManager.vcproj

    r92 r100  
    8888                                OptimizeForProcessor="2" 
    8989                                AdditionalIncludeDirectories=""$(OGRE_PATH)\PlugIns\OctreeSceneManager\include";"$(OGRE_ADDONS_PATH)\dotsceneoctree\PlugIns\DotSceneManager\include";"$(OGRE_PATH)\Samples\Common\include";"$(OGRE_PATH)\Dependencies\include\CEGUI";"$(OGRE_PATH)\Samples\Common\CEGUIRenderer\include";"$(OGRE_PATH)\OgreMain\include";"$(OGRE_PATH)\Dependencies\include";..\include;..\..\GtpVisibility\include" 
    90                                 PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;PLUGIN_OCCLUSIONCULLINGSCENEMANAGER_EXPORTS;GTP_VISIBILITY_MODIFIED_OGRE" 
     90                                PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;GTP_VISIBILITY_MODIFIED_OGRE" 
    9191                                StringPooling="TRUE" 
    9292                                RuntimeLibrary="2" 

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

    r94 r100  
    2020        DeleteQueries(); 
    2121 
    22         if(mSolidBoundingBox) 
     22        if (mSolidBoundingBox) 
    2323                delete mSolidBoundingBox; 
    2424} 
    … …  
    2626void PlatformHierarchyInterface::DeleteQueries() 
    2727{ 
    28         for(int i=0; i < (int)mOcclusionQueries.size(); ++i) 
     28        for (int i=0; i < (int)mOcclusionQueries.size(); ++i) 
    2929                delete mOcclusionQueries[i]; 
    3030 
    … …  
    7272GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::GetNextOcclusionQuery() 
    7373{ 
    74         if(mCurrentTestIdx == mOcclusionQueries.size()) 
     74        if (mCurrentTestIdx == mOcclusionQueries.size()) 
    7575        { 
    7676                mOcclusionQueries.push_back(new PlatformOcclusionQuery(mRenderSystem)); 
    … …  
    8787        SetCamera(cam); 
    8888 
    89         if(cullCam) 
     89        if (cullCam) 
    9090                SetCullCamera(cullCam); 
    9191        else 
    … …  
    143143SolidBoundingBox *PlatformHierarchyInterface::GetSolidBoundingBox() 
    144144{ 
    145         if(!mSolidBoundingBox) 
     145        if (!mSolidBoundingBox) 
    146146                mSolidBoundingBox = new SolidBoundingBox; 
    147147 

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

    r94 r100  
    6262        SceneNode *sceneNode = static_cast<SceneNode *>(node); 
    6363 
    64         while(sceneNode && !sceneNode->isNodeVisible()) 
     64        while (sceneNode && !sceneNode->isNodeVisible()) 
    6565        { 
    6666                sceneNode->setNodeVisible(true); 
    … …  
    115115AxisAlignedBox *SceneNodeHierarchyInterface::GetBoundingBox(GtpVisibility::HierarchyNode *node) 
    116116{ 
    117         if(node != mPreviousNode) 
     117        if (node != mPreviousNode) 
    118118        { 
    119119                mPreviousNode = node; 
    120  
    121120                mBox = static_cast<SceneNode *>(node)->_getWorldAABB(); 
    122121        } 

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

    r97 r100  
    121121        m_pMaterial = MaterialManager::getSingleton().getByName("QueryMaterial"); 
    122122 
    123         if(m_pMaterial.isNull()) 
     123        if (m_pMaterial.isNull()) 
    124124        { 
    125125                m_pMaterial = MaterialManager::getSingleton(). 

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

    r97 r100  
    4242 
    4343        // fan 1 
    44         if(isFirstHalf) 
     44        if (isFirstHalf) 
    4545        { 
    4646                *pPos++ = min.x; *pPos++ = max.y; *pPos++ = max.z; //011 
    … …  
    8989        m_pMaterial = MaterialManager::getSingleton().getByName("QueryMaterial"); 
    9090 
    91         if(m_pMaterial.isNull()) 
     91        if (m_pMaterial.isNull()) 
    9292        { 
    9393                m_pMaterial = MaterialManager::getSingleton(). 

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

    r99 r100  
    1212VisibilityOctreeSceneManager::VisibilityOctreeSceneManager( 
    1313        GtpVisibility::VisibilityManager *visManager) 
    14 : mVisibilityManager(visManager), mUseVisibilityCulling(true) 
     14: mVisibilityManager(visManager), mUseVisibilityCulling(true), 
     15mShowVisualization(false) 
    1516{ 
    1617        mHierarchyInterface =  
    … …  
    3536        mHierarchyInterface->InitFrame(mOctree, mCameraInProgress,  
    3637                                                        mCullCamera ? getCamera("CullCamera") : NULL); 
    37         mVisibilityManager->GetCullingManager()->InitFrame(); 
     38        //mVisibilityManager->GetCullingManager()->InitFrame(); 
    3839 
    3940        // standard scenemanager rendering without hierarchical culling 
    … …  
    6566        setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE); 
    6667 
    67         //-- the hierarchical culling algorithm 
     68 
     69        /**  
     70        * the hierarchical culling algorithm 
     71        **/ 
    6872        mVisibilityManager->ApplyVisibilityCulling(); 
     73 
    6974 
    7075#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    … …  
    8489        // we interleave identification and rendering of objects  
    8590        // in _renderVisibibleObjects  
     91        if (!mUseVisibilityCulling) 
     92        { 
     93                OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters); 
     94                return;  
     95        } 
     96         
     97        if (mShowVisualization) 
     98    { 
     99                 
     100                for ( BoxList::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it ) 
     101                { 
     102                        getRenderQueue()->addRenderable(*it); 
     103                } 
     104        } 
     105 
    86106        getRenderQueue()->clear(); 
    87107    mBoxes.clear(); 
    88108    mVisible.clear(); 
    89  
    90         if(!mUseVisibilityCulling) 
    91         { 
    92                 OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters); 
    93         } 
    94109} 
    95110//----------------------------------------------------------------------- 
    … …  
    112127                return true; 
    113128        } 
    114          
     129        if (key == "ShowVisualization") 
     130        { 
     131                mShowVisualization = (*static_cast<const bool *>(val)); 
     132                return true; 
     133        } 
    115134        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface). 
    116135                setOption(key, val) || OctreeSceneManager::setOption(key, val); 

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

    r87 r100  
    33namespace Ogre { 
    44//----------------------------------------------------------------------- 
    5 VisibilityOptionsManager::VisibilityOptionsManager(GtpVisibility::VisibilityManager *visManager,  
    6                                                                                 GtpVisibility::HierarchyInterface *hierarchyInterface): 
    7 mVisibilityManager(visManager), mHierarchyInterface(hierarchyInterface) 
     5VisibilityOptionsManager::VisibilityOptionsManager( 
     6        GtpVisibility::VisibilityManager *visManager,  
     7        GtpVisibility::HierarchyInterface *hierarchyInterface): 
     8mVisibilityManager(visManager),  
     9mHierarchyInterface(hierarchyInterface) 
    810{ 
    911} 
    … …  
    1113bool VisibilityOptionsManager::setOption( const String & key, const void * val ) 
    1214{ 
    13         if( key == "Algorithm" ) 
     15        if (key == "Algorithm") 
    1416        { 
    1517                mVisibilityManager->SetCullingManager(*static_cast<const  
    … …  
    1719                return true; 
    1820        } 
    19         if(key == "Threshold") 
     21        if (key == "Threshold") 
    2022        { 
    2123                mVisibilityManager->SetVisibilityCullingThreshold(*static_cast<const int *>(val)); 
    … …  
    6769} 
    6870//----------------------------------------------------------------------- 
    69 bool VisibilityOptionsManager::getOptionKeys( StringVector & refKeys ) 
     71bool VisibilityOptionsManager::getOptionKeys(StringVector & refKeys) 
    7072{ 
    71         refKeys.push_back( "NumRenderedNodes" ); 
    72         refKeys.push_back( "NumTraversedNodes" ); 
    73         refKeys.push_back( "NumQueryCulledNodes" ); 
    74         refKeys.push_back( "NumFrustumCulledNodes" ); 
     73        refKeys.push_back("NumRenderedNodes"); 
     74        refKeys.push_back("NumTraversedNodes"); 
     75        refKeys.push_back("NumQueryCulledNodes"); 
     76        refKeys.push_back("NumFrustumCulledNodes"); 
    7577         
    7678        return true; 

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

    r99 r100  
    2727        // we interleave identification and rendering of objects  
    2828        // in _renderVisibibleObjects  
    29         if(!mUseVisibilityCulling) 
     29        if (!mUseVisibilityCulling) 
    3030        { 
    3131                SceneManager::_findVisibleObjects(cam, onlyShadowCasters); 
    … …  
    3838        mVisibilityManager->GetCullingManager()->InitFrame(); 
    3939 
    40         if(!mUseVisibilityCulling) 
     40        if (!mUseVisibilityCulling) 
    4141        {        
    4242                SceneManager::_renderVisibleObjects(); 

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

    r94 r100  
    2828//#include <OgreVisibilityDotSceneManager.h> 
    2929#include <OgreHeightmapTerrainPageSource.h> 
     30#include <OgreRoot.h> 
     31 
    3032#include "VisibilityManager.h" 
    3133#include "StopAndWaitCullingManager.h" 
    3234#include "VisibilityEnvironment.h" 
    33  
    34 #include <OgreRoot.h> 
    3535 
    3636GtpVisibility::VisibilityEnvironment *visEnv; 

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

    r99 r100  
    77#include <OgreCamera.h> 
    88#include <OgreLogManager.h> 
     9#include <OgreStringConverter.h> 
    910 
    1011#include <windows.h> 
    … …  
    3637        mHierarchyInterface->InitFrame(mOctree, mCameraInProgress,  
    3738                                                        mCullCamera ? getCamera("CullCamera") : NULL); 
    38         mVisibilityManager->GetCullingManager()->InitFrame(); 
     39        //mVisibilityManager->GetCullingManager()->InitFrame(); 
    3940         
    4041        // standard scenemanager rendering without hierarchical culling 
    … …  
    5657        setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE); 
    5758        SceneManager::_renderVisibleObjects(); 
     59 
    5860#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    5961        _deleteRenderedQueueGroups(); 
    … …  
    6567        setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE); 
    6668 
    67         //-- the hierarchical culling algorithm 
     69 
     70        /**  
     71        * the hierarchical culling algorithm 
     72        **/ 
    6873        mVisibilityManager->ApplyVisibilityCulling(); 
     74 
    6975 
    7076#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    … …  
    8389        // does nothing if hierarchical culling is used => 
    8490        // we interleave identification and rendering of objects  
    85         // in _renderVisibibleObjects  
     91        // in _renderVisibibleObjects 
     92        getRenderQueue()->clear(); 
     93         
     94        if (!mUseVisibilityCulling) 
     95        { 
     96                OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters); 
     97                return;  
     98        } 
     99         
     100        //-- show visibile scene nodes and octree bounding boxes from last frame 
    86101        if (mShowVisualization) 
    87102    { 
    88                 for ( BoxList::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it ) 
     103                // add cull camera for visualization purpose 
     104                if (mCullCamera) 
     105                { 
     106                        Camera *c; 
     107                        if ((c = getCamera("CullCamera")) != NULL) 
     108                        { 
     109                                getRenderQueue()->addRenderable(c); 
     110                        } 
     111                } 
     112 
     113                for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it) 
    89114                { 
    90115                        getRenderQueue()->addRenderable(*it); 
    91116                } 
    92         } 
    93  
    94         getRenderQueue()->clear(); 
     117                for (BoxList::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it) 
     118                { 
     119                        getRenderQueue()->addRenderable(*it); 
     120                } 
     121        } 
     122         
     123        mVisible.clear(); 
    95124    mBoxes.clear(); 
    96     mVisible.clear(); 
    97  
    98         if(!mUseVisibilityCulling) 
    99         { 
    100                 OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters); 
    101         } 
    102125} 
    103126//----------------------------------------------------------------------- 
    … …  
    126149                return true; 
    127150        } 
    128  
     151        if (key == "SkyBoxEnabled") 
     152        { 
     153                mSkyBoxEnabled = (*static_cast<const bool *>(val)); 
     154                return true; 
     155        } 
     156        if (key == "SkyPlaneEnabled") 
     157        { 
     158                mSkyPlaneEnabled = (*static_cast<const bool *>(val)); 
     159                return true; 
     160        } 
     161        if (key == "SkyDomeEnabled") 
     162        { 
     163                mSkyDomeEnabled = (*static_cast<const bool *>(val)); 
     164                return true; 
     165        } 
    129166        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface). 
    130167                setOption(key, val) || TerrainSceneManager::setOption(key, val); 
    … …  
    139176        } 
    140177         
    141  
    142178        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface). 
    143179                getOption(key, val) && TerrainSceneManager::getOption(key, val); 
    … …  
    169205        mShowVisualization = showViz; 
    170206} 
     207/* 
     208//----------------------------------------------------------------------- 
     209void SetSkyBoxEnabled(bool enabled) 
     210{ 
     211        mSkyBoxEnabled = enabled; 
     212} 
     213//----------------------------------------------------------------------- 
     214void SetSkyPlaneEnabled(bool enabled) 
     215{ 
     216        mSkyPlaneEnabled = enabled; 
     217} 
     218//----------------------------------------------------------------------- 
     219void SetSkyDomeEnabled(bool enabled) 
     220{ 
     221        mSkyDomeEnabled = enabled; 
     222} */ 
    171223//----------------------------------------------------------------------- 
    172224void VisibilityTerrainSceneManager::WriteLog() 

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

    r99 r100  
    292292        mShowVisualization = !mShowVisualization; 
    293293 
    294         mSceneMgr->setOption("CullCamera", &mShowVisualization); 
     294        mSceneMgr->setOption("ShowVisualization", &mShowVisualization); 
    295295} 
    296296//----------------------------------------------------------------------- 

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

    r99 r100  
    9797        bool mShowVisualization; 
    9898 
    99         Camera *mVisualizationCamera; 
     99        Camera *mVizCamera; 
    100100}; 
    101101 

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

    r83 r100  
    7272                        <Tool 
    7373                                Name="VCCLCompilerTool" 
    74                                 AdditionalIncludeDirectories="&quot;$(OGRE_PATH)\Dependencies\include&quot;;&quot;$(OGRE_PATH)\OgreMain\include&quot;;&quot;$(OGRE_PATH)\Samples\Common\include&quot;;&quot;$(OGRE_PATH)\Dependencies\include\CEGUI&quot;;&quot;$(OGRE_PATH)\PlugIns\OctreeSceneManager\include&quot;;&quot;$(OGRE_ADDONS_PATH)\dotsceneoctree\PlugIns\DotSceneManager\include&quot;;&quot;$(OGRE_PATH)\Samples\Common\CEGUIRenderer\include&quot;;..\..\GtpVisibility\include;..\include;..\TestCulling" 
     74                                AdditionalIncludeDirectories="&quot;$(OGRE_PATH)\Dependencies\include&quot;;&quot;$(OGRE_PATH)\OgreMain\include&quot;;&quot;$(OGRE_PATH)\Samples\Common\include&quot;;&quot;$(OGRE_PATH)\Dependencies\include\CEGUI&quot;;&quot;$(OGRE_PATH)\ReferenceApplication\ReferenceAppLayer\include&quot;;&quot;$(OGRE_PATH)\PlugIns\OctreeSceneManager\include&quot;;&quot;$(OGRE_ADDONS_PATH)\dotsceneoctree\PlugIns\DotSceneManager\include&quot;;&quot;$(OGRE_PATH)\Samples\Common\CEGUIRenderer\include&quot;;..\..\GtpVisibility\include;..\include;..\TestCulling" 
    7575                                PreprocessorDefinitions="_WINDOWS;_STLP_USE_DYNAMIC_LIB;OGRE_LIBRARY_IMPORTS;_RELEASE;WIN32;_STLP_RELEASE;GTP_VISIBILITY_MODIFIED_OGRE" 
    7676                                RuntimeLibrary="2" 

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

    r99 r100  
    1313#include <OgreMemoryMacros.h> 
    1414 
    15 #include "Ogre.h" 
     15#include <Ogre.h> 
     16#include "OgreReferenceAppLayer.h" 
     17//#include "OgreRefAppWorld.h" 
    1618#include "TestCullingTerrainApplication.h" 
    1719 
    … …  
    1921#include <windows.h> 
    2022 
     23#define VIZ_VIEWPORT_Z_ORDER 10 
    2124 
    2225/*******************************************************/ 
    2326/*     TestCullingTerrainApplication implementation    */ 
    2427/*******************************************************/ 
     28 
     29//----------------------------------------------------------------------- 
    2530TestCullingTerrainApplication::~TestCullingTerrainApplication() 
    2631{ 
    … …  
    3338{ 
    3439        // create the camera 
    35         mCamera = mSceneMgr->createCamera("PlayerCam"); 
    36          
    37         // set a nice viewpoint 
    38         mCamera->setPosition(707, 2500, 528); 
    39         mCamera->setOrientation(Quaternion(-0.3486, 0.0122, 0.9365, 0.0329)); 
    40          
    41         //--create visualization camera 
    42         mVisualizationCamera = mSceneMgr->createCamera("VizCam"); 
    43         mVisualizationCamera->setPosition(mCamera->getPosition()); 
    44         mVisualizationCamera->setOrientation(mCamera->getOrientation()); 
    45  
    46         mVisualizationCamera->setNearClipDistance(1); 
     40        mCamera = mSceneMgr->createCamera("CullCamera"); 
     41         
     42        /** set a nice viewpoint 
     43        *       we use a camera node here and apply all transformations on it instead 
     44        *       of applying all transformations directly to the camera 
     45        *       because then the camera is displayed correctly in the visualization 
     46        */ 
     47         
     48        mCamNode = mSceneMgr->getRootSceneNode()->createChildSceneNode( 
     49                "CamNode1", Vector3(707, 5000, 528)); 
     50        //mCamera->setPosition(707, 5000, 528); 
     51        mCamNode->setOrientation(Quaternion(-0.3486, 0.0122, 0.9365, 0.0329)); 
     52         
     53        mCamNode->attachObject(mCamera); 
     54 
     55        //-- create visualization camera 
     56        mVizCamera = mSceneMgr->createCamera("VizCam"); 
     57        mVizCamera->setPosition(mCamNode->getPosition()); 
     58 
     59        mVizCamera->setNearClipDistance(1); 
    4760        mCamera->setNearClipDistance(1); 
    4861 
    … …  
    5063        if (mRoot->getRenderSystem()->getCapabilities()->hasCapability(RSC_INFINITE_FAR_PLANE)) 
    5164        { 
    52                 mVisualizationCamera->setFarClipDistance(0); 
     65                mVizCamera->setFarClipDistance(0); 
    5366                mCamera->setFarClipDistance(0); 
    5467        } 
    5568        else 
    5669        { 
    57                  mVisualizationCamera->setFarClipDistance(1000); 
     70                 mVizCamera->setFarClipDistance(1000); 
    5871                 mCamera->setFarClipDistance(1000); 
    5972        }        
    … …  
    8497        // Accept default settings: point light, white diffuse, just set position 
    8598        // NB I could attach the light to a SceneNode if I wanted it to move automatically with 
    86         //  other objects, but I don't 
     99        // other objects, but I don't 
    87100        l->setPosition(20,80,50); 
    88101 
    … …  
    95108         
    96109        // Create a skybox 
    97     mSceneMgr->setSkyBox(true, "Examples/SpaceSkyBox", 3500, false); 
     110        mSceneMgr->setSkyBox(true, "Examples/SpaceSkyBox", 7000, false); 
    98111        //mSceneMgr->setSkyDome( true, "Examples/CloudySky", 5, 8, 500, false ); 
    99112 
    … …  
    104117        mSceneMgr->setWorldGeometry(terrain_cfg); 
    105118         
    106         // CEGUI setup 
     119        //-- CEGUI setup 
    107120        setupGui(); 
     121 
     122        //-- terrain content setup 
     123 
    108124        // HACK: necessary to call once before the content creation for 
    109125        // terrain initialisation 
    … …  
    138154{ 
    139155        mFrameListener= new MouseQueryListener(mWindow, mCamera, mSceneMgr,  
    140                 mGUIRenderer, mTerrainContentGenerator, mVisualizationCamera); 
     156                mGUIRenderer, mTerrainContentGenerator, mVizCamera, mCamNode); 
    141157        mFrameListener->showDebugOverlay(true); 
    142158        mRoot->addFrameListener(mFrameListener); 
    … …  
    155171                                                                           CEGUI::Renderer *renderer, 
    156172                                                                           TerrainContentGenerator *sceneGenerator, 
    157                                                                            Camera *vizCamera):  
     173                                                                           Camera *vizCamera, 
     174                                                                           SceneNode *camNode):  
    158175ExampleFrameListener(win, cam, false, true),  
    159176mGUIRenderer(renderer),  
    … …  
    169186mUseVisibilityCulling(true), 
    170187mUseOptimization(true), 
    171 mVisualizationCamera(vizCamera) 
     188mVizCamera(vizCamera), 
     189mShowVisualization(false), 
     190mVizCameraHeight(Real(2500.0)), 
     191mCamNode(camNode), 
     192mCullCamera(true) 
    172193{ 
    173194        // Reduce move speed 
    … …  
    213234        mSceneMgr->setOption("UseVisibilityCulling", &mUseVisibilityCulling); 
    214235        mSceneMgr->setOption("ShowOctree", &mShowOctree); 
     236        mSceneMgr->setOption("CullCamera", &mCullCamera); 
    215237         
    216238    pOver->show(); 
    217239}  
    218240//----------------------------------------------------------------------- 
    219 MouseQueryListener::~MouseQueryListener( ) 
     241MouseQueryListener::~MouseQueryListener() 
    220242{ 
    221243        delete mRayQueryExecutor; 
    222244} 
    223245//----------------------------------------------------------------------- 
    224 void MouseQueryListener::mouseMoved (MouseEvent *e) 
     246void MouseQueryListener::mouseMoved(MouseEvent *e) 
    225247{ 
    226248        // Update CEGUI with the mouse motion 
    227     CEGUI::System::getSingleton().injectMouseMove(e->getRelX() * mGUIRenderer->getWidth(),  
    228                 e->getRelY() * mGUIRenderer->getHeight()); 
     249    CEGUI::System::getSingleton().injectMouseMove(e->getRelX() *  
     250                mGUIRenderer->getWidth(), e->getRelY() * mGUIRenderer->getHeight()); 
    229251} 
    230252//----------------------------------------------------------------------- 
    … …  
    252274         CEGUI::MouseCursor::getSingleton().hide(); 
    253275         mRMouseDown = true; 
    254      } // else if 
     276     } 
    255277} // mousePressed 
    256278//----------------------------------------------------------------------- 
    … …  
    279301                 Ray mouseRay = mCamera->getCameraToViewportRay(e->getX(), e->getY()); 
    280302 
    281                  if(mRayQueryExecutor->executeRayQuery(&queryResult, mouseRay)) 
     303                 if (mRayQueryExecutor->executeRayQuery(&queryResult, mouseRay)) 
    282304                 { 
    283                          if(mCurrentObject) 
     305                         if (mCurrentObject) 
     306                         { 
    284307                                 mCurrentObject->setPosition(queryResult); 
     308                         } 
    285309                 } 
    286310     } 
    … …  
    288312         if (mRMouseDown) 
    289313         { 
    290                  mCamera->yaw( -e->getRelX() * mRotateSpeed ); 
    291                  mCamera->pitch( -e->getRelY() * mRotateSpeed ); 
     314                 //mCamera->yaw(-e->getRelX() * mRotateSpeed); 
     315                 //mCamera->pitch(-e->getRelY() * mRotateSpeed); 
     316                 mCamNode->yaw(-e->getRelX() * mRotateSpeed); 
     317                 mCamNode->pitch(-e->getRelY() * mRotateSpeed); 
    292318         } 
    293319} 
    … …  
    295321bool MouseQueryListener::frameStarted(const FrameEvent &evt) 
    296322{ 
    297         clamp2Terrain(mCamera); 
    298         clamp2Terrain(mVisualizationCamera); 
     323        clamp2Terrain(); 
     324 
     325        if (mShowVisualization) 
     326        { 
     327                // important for visualization => draw octree bounding boxes 
     328                mSceneMgr->setOption("ShowOctree", &mShowVisualization); 
     329 
     330                // -- setup visualization camera 
     331                mVizCamera->setPosition(0, 0, 0); 
     332                mVizCamera->setOrientation(Quaternion::IDENTITY); 
     333 
     334                Vector3 camPos = mCamNode->getPosition(); 
     335                mVizCamera->setPosition(camPos.x, mVizCameraHeight, camPos.z); 
     336 
     337                // Point down -Z axis 
     338                mVizCamera->pitch(Radian(Degree(270.0))); 
     339         
     340                // Rotation arounnd X axis 
     341                mVizCamera->yaw(Math::ATan2(-mCamera->getDerivedDirection().x,  
     342                        -mCamera->getDerivedDirection().z)); 
     343        } 
    299344 
    300345        return ExampleFrameListener::frameStarted(evt); 
    301346} 
    302 void MouseQueryListener::clamp2Terrain(Camera *cam) 
     347//----------------------------------------------------------------------- 
     348void MouseQueryListener::clamp2Terrain() 
    303349{ 
    304350        // clamp to terrain 
    305         Vector3 camPos = cam->getPosition(); 
     351        Vector3 camPos = mCamNode->getPosition(); 
    306352        Vector3 queryResult; 
    307353 
    308         if(mRayQueryExecutor->executeRayQuery(&queryResult,  
     354        if (mRayQueryExecutor->executeRayQuery(&queryResult,  
    309355                        Vector3(camPos.x, 5000.0f, camPos.z), Vector3::NEGATIVE_UNIT_Y)) 
    310356        { 
    311                 cam->setPosition(cam->getPosition().x, queryResult.y + 10,  
    312                         cam->getPosition().z); 
     357                mCamNode->setPosition(camPos.x, queryResult.y + 10, camPos.z); 
    313358        } 
    314359} 
    … …  
    324369    KEY_PRESSED(KC_SPACE, 0.3, nextAlgorithm()); 
    325370 
    326         KEY_PRESSED(KC_SUBTRACT, 0, changeThreshold(-10)); 
    327         KEY_PRESSED(KC_ADD, 0, changeThreshold(10)); 
    328371        KEY_PRESSED(KC_O, 0.3, toggleUseOptimization()); 
    329         KEY_PRESSED(KC_Y, 0.3, toggleShowOctree()); 
     372        KEY_PRESSED(KC_E, 0.3, toggleShowOctree()); 
    330373        KEY_PRESSED(KC_C, 0.3, toggleUseVisibilityCulling()); 
    331374        KEY_PRESSED(KC_V, 0.3, toggleShowViz()); 
    332         KEY_PRESSED(KC_X, 0.3, FixVizCamera()); 
     375 
     376        if (!mShowVisualization) 
     377        { 
     378                KEY_PRESSED(KC_SUBTRACT, 0, changeThreshold(-10)); 
     379                KEY_PRESSED(KC_ADD, 0, changeThreshold(10)); 
     380        } 
     381        else 
     382        { 
     383                KEY_PRESSED(KC_SUBTRACT, 0, zoomVizCamera(50)); 
     384                KEY_PRESSED(KC_ADD, 0, zoomVizCamera(-50)); 
     385        } 
    333386 
    334387        updateStats(); 
    335         //if(mWindow->getViewport(1))   mWindow->getViewport(1)->update(); 
    336  
    337     return ExampleFrameListener::frameStarted(evt) && ExampleFrameListener::frameEnded(evt);         
     388 
     389        return ExampleFrameListener::frameStarted(evt) && ExampleFrameListener::frameEnded(evt); 
     390} 
     391void MouseQueryListener::moveCamera() 
     392{ 
     393        mCamNode->yaw(mRotX); 
     394        mCamNode->pitch(mRotY); 
     395        mCamNode->translate(mCamNode->getLocalAxes(), mTranslateVector); 
    338396} 
    339397//----------------------------------------------------------------------- 
    … …  
    349407} 
    350408//----------------------------------------------------------------------- 
     409bool MouseQueryListener::processUnbufferedKeyInput(const FrameEvent& evt) 
     410{     
     411        if (mInputDevice->isKeyDown(KC_RIGHT)) 
     412        { 
     413                mCamNode->yaw(-mRotScale); 
     414                return true; 
     415        } 
     416        if (mInputDevice->isKeyDown(KC_LEFT)) 
     417        { 
     418                mCamNode->yaw(mRotScale); 
     419                return true; 
     420        } 
     421 
     422        return ExampleFrameListener::processUnbufferedKeyInput(evt); 
     423} 
     424//----------------------------------------------------------------------- 
     425void MouseQueryListener::zoomVizCamera(int zoom) 
     426{ 
     427        mVizCameraHeight += zoom;  
     428        if(mVizCameraHeight < 0) mVizCameraHeight = 0; 
     429} 
     430//----------------------------------------------------------------------- 
    351431void MouseQueryListener::nextAlgorithm() 
    352432{ 
    … …  
    396476        mSceneMgr->setOption("UseOptimization", &mUseOptimization); 
    397477 
    398         if(mUseOptimization) 
     478        if (mUseOptimization) 
    399479                mUseOptimizationInfo->setCaption(": true"); 
    400480        else 
    … …  
    420500        mShowVisualization = !mShowVisualization; 
    421501 
    422         // create viewport with priority 10: will be rendered over standard viewport 
    423         if(mShowVisualization) 
     502        // create viewport with priority VIZ_VIEWPORT_Z_ORDER:  
     503        // will be rendered over standard viewport 
     504        if (mShowVisualization) 
    424505        {        
    425                 mWindow->addViewport(mVisualizationCamera, 10, 0.5, 0.5, 1, 1); 
    426                 mWindow->getViewport(1)->setClearEveryFrame(true); 
     506                Viewport *vizvp = mWindow->addViewport(mVizCamera,  
     507                        VIZ_VIEWPORT_Z_ORDER, 0.6, 0, 0.4, 0.4); 
     508                                 
     509                vizvp->setBackgroundColour(ColourValue(0.0, 0.3, 0.2, 1)); 
     510 
     511                vizvp->setOverlaysEnabled(false); 
     512                // Alter the camera aspect ratio to match the viewport 
     513        mVizCamera->setAspectRatio(Real(vizvp->getActualWidth()) /  
     514                        Real(vizvp->getActualHeight())); 
     515 
     516                //vizvp->setClearEveryFrame(false); 
     517 
     518                // Create a skyplane (for visualization) 
     519                /*Plane plane; 
     520                plane.d = 1000; 
     521                plane.normal = Vector3::UNIT_Y; 
     522                mSceneMgr->setSkyPlane( true, plane, "Examples/MyTransparentTest", 4000, 75, true);*/ 
     523                 
    427524        } 
    428525        else 
    429526        { 
    430                 mWindow->removeViewport(10); 
    431         } 
    432 } 
    433 //----------------------------------------------------------------------- 
    434 void MouseQueryListener::FixVizCamera() 
    435 { 
    436         mVisualizationCamera->setPosition(mCamera->getPosition()); 
    437         mVisualizationCamera->setOrientation(mCamera->getOrientation()); 
    438         clamp2Terrain(mVisualizationCamera); 
    439 } 
    440  
     527                mWindow->removeViewport(VIZ_VIEWPORT_Z_ORDER); 
     528                // if octree was enabled for visualization purpose 
     529                mSceneMgr->setOption("ShowOctree", &mShowOctree); 
     530        } 
     531} 
    441532//----------------------------------------------------------------------- 
    442533void MouseQueryListener::keyPressed(KeyEvent* e) 
    … …  
    475566void VisualizationRenderTargetListener::preViewportUpdate(const RenderTargetViewportEvent &evt) 
    476567{ 
    477         const bool b = evt.source->getZOrder() == 10; // visualization viewport 
    478                          
    479         mSceneMgr->setOption("ShowVisualization", &b); 
     568        const bool showViz = evt.source->getZOrder() == VIZ_VIEWPORT_Z_ORDER; // visualization viewport 
     569        const bool nShowViz = !showViz; 
     570 
     571    mSceneMgr->setOption("ShowVisualization", &showViz); 
     572        mSceneMgr->setOption("SkyBoxEnabled", &nShowViz); 
     573        //mSceneMgr->setOption("SkyPlaneEnabled", &showViz); 
    480574         
    481575        RenderTargetListener::preViewportUpdate(evt); 

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

    r99 r100  
    88#include "VisibilityEnvironment.h" 
    99#include <OgreRenderTargetListener.h> 
     10 
    1011 
    1112Real timeDelay = 0; 
    … …  
    4344 
    4445    MouseQueryListener(RenderWindow* win, Camera* cam, SceneManager *sceneManager,  
    45                 CEGUI::Renderer *renderer, TerrainContentGenerator *contentGenerator, Camera *vizCamera); 
     46                CEGUI::Renderer *renderer, TerrainContentGenerator *contentGenerator, Camera *vizCamera, 
     47                SceneNode *camNode); 
    4648 
    4749    ~MouseQueryListener(); 
    … …  
    4951        bool frameStarted(const FrameEvent& evt); 
    5052        bool frameEnded(const FrameEvent& evt); 
     53        bool processUnbufferedKeyInput(const FrameEvent& evt); 
     54     
    5155 
    5256    /* MouseListener callbacks. */ 
    … …  
    8084        void toggleUseVisibilityCulling(); 
    8185        void toggleShowViz(); 
    82         void FixVizCamera(); 
     86        void zoomVizCamera(int zoom); 
     87        void moveCamera(); 
    8388 
    8489protected: 
    85         void clamp2Terrain(Camera *cam); 
     90        void clamp2Terrain(); 
    8691 
    8792    bool mLMouseDown, mRMouseDown;     // True if the mouse buttons are down 
    … …  
    115120        bool mUseVisibilityCulling; 
    116121        bool mShowVisualization; 
     122        bool mCullCamera; 
    117123 
    118         Camera *mVisualizationCamera; 
     124        Real mVizCameraHeight; 
     125 
     126        Camera *mVizCamera; 
     127        SceneNode *mCamNode; 
     128 
    119129}; 
    120130 
    … …  
    149159        TerrainContentGenerator *mTerrainContentGenerator; 
    150160         
    151         Camera *mVisualizationCamera; 
     161        Camera *mVizCamera; 
     162        SceneNode *mCamNode; 
    152163        VisualizationRenderTargetListener *mRenderTargetListener; 
    153164 
Note: See TracChangeset for help on using the changeset viewer.