Changeset 100 for trunk/VUT/Ogre


Ignore:
Timestamp:
05/16/05 20:22:32 (19 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/Ogre
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • 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() 
Note: See TracChangeset for help on using the changeset viewer.