Changeset 2555 for GTP


Ignore:
Timestamp:
10/05/07 15:36:52 (17 years ago)
Author:
mattausch
Message:

added partial implementation of chc++. problem: bounding box rendering in Ogre is VERY slow

Location:
GTP/trunk
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/App/Demos/Vis/HillyTerrain/OGRE/TerrainFrameListener.cpp

    r2544 r2555  
    1717{ 
    1818        "Coherent Hierarchical Culling", 
     19        "Coherent Hierarchical Culling++",  
     20        "Stop and Wait Culling", 
    1921        "View Frustum Culling",  
    20         "Random Update Culling",  
    21         "Stop and Wait Culling", 
    2222        "Standard Rendering" 
    2323}; 
    … …  
    2828        "CHC", 
    2929        "VFC", 
    30         "RUC", 
     30        "CHC++", 
    3131        "SWC", 
    3232        "DEF", 
    … …  
    258258         
    259259        if (isNormalExecution) 
    260         { 
    261260                // no algorithm 
    262261                mCurrentAlgorithm = GtpVisibility::VisibilityEnvironment::NUM_CULLING_MANAGERS; 
    263         } 
    264262        else 
    265         { 
    266263                mSceneMgr->getOption("Algorithm", &mCurrentAlgorithm); 
    267         } 
    268264         
    269265        // apply the chosen culling algorithm 

  • GTP/trunk/App/Demos/Vis/HillyTerrain/OGRE/TestCullingTerrainApplication.cpp

    r2544 r2555  
    102102                                Radian rnd = Radian(Math::UnitRandom() * Math::PI * rotate_factor); 
    103103 
    104                                 //mEntity->getParentSceneNode()->rotate(); 
    105104                                parent->yaw(rnd);                                                
    106105                        } 
    … …  
    165164mIVReader(NULL), 
    166165mFilename("terrain"), 
    167 mViewCellsFilename(""), 
    168 mAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING) 
     166mViewCellsFilename("") 
     167//,mAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING) 
    169168{ 
    170169} 

  • GTP/trunk/App/Demos/Vis/HillyTerrain/OGRE/TestCullingTerrainApplication.h

    r1816 r2555  
    148148        String mEnvironmentFilename; 
    149149         
    150         int mAlgorithm; 
     150        //int mAlgorithm; 
    151151 
    152152        Vector3 mInitialPosition; 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreOctreeHierarchyInterface.h

    r2455 r2555  
    3333        */ 
    3434        void TraverseNode(GtpVisibility::HierarchyNode *node); 
     35        void TraverseNode2(GtpVisibility::HierarchyNode *node); 
    3536        /** @copydoc HierarchyInterface::RenderNode */ 
    3637        void RenderNode(GtpVisibility::HierarchyNode *node); 
    … …  
    8384        void RenderGeometryBounds(GtpVisibility::HierarchyNode *node); 
    8485 
     86        void AddToQueue(GtpVisibility::HierarchyNode *node); 
     87 
     88        void RenderQueue(); 
    8589 
    8690protected: 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgrePlatformHierarchyInterface.h

    r2455 r2555  
    140140        int GetTestGeometryBounds(); 
    141141 
    142  
     142        virtual void AddToQueue(GtpVisibility::HierarchyNode *node) {}; 
     143 
     144        virtual void RenderQueue() {}; 
     145 
     146        virtual void TraverseNode2(GtpVisibility::HierarchyNode *node) {}; 
     147         
    143148protected: 
    144149 
    … …  
    187192 
    188193        bool mTestGeometryBounds; 
     194 
     195        bool mTestMode; 
    189196}; 
    190197 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreBiHierarchySceneManager.cpp

    r2542 r2555  
    218218                { 
    219219                        mRenderMethod = rm; 
    220                         int cmt = GtpVisibility::VisibilityEnvironment::RANDOM_UPDATE_CULLING; 
     220                        int cmt = GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING_PLUSPLUS; 
    221221                        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface) 
    222222                                .setOption("Algorithm", &cmt); 
    … …  
    242242                        else if (val == GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING) 
    243243                                mRenderMethod = BiHierarchy::BIHRM_GTP_CHC; 
    244                         else if (val == GtpVisibility::VisibilityEnvironment::RANDOM_UPDATE_CULLING) 
     244                        else if (val == GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING_PLUSPLUS) 
    245245                                mRenderMethod = BiHierarchy::BIHRM_GTP_RU; 
    246246                        // default, should never happen 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp

    r2547 r2555  
    323323                         LogManager::getSingleton().logMessage("Using stop and wait algorithm"); 
    324324                 } 
    325                 else if (val == "RUC") 
     325                else if (val == "CHC++") 
    326326                { 
    327327                         algorithm =  
    328                                  GtpVisibility::VisibilityEnvironment::RANDOM_UPDATE_CULLING; 
    329  
    330                          LogManager::getSingleton().logMessage("Using random update culling"); 
     328                                 GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING_PLUSPLUS; 
     329 
     330                         LogManager::getSingleton().logMessage("Using chc ++"); 
    331331                 } 
    332332                 else if (val == "VFC") 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOctreeHierarchyInterface.cpp

    r2455 r2555  
    3232                Octree *nextChild; 
    3333 
    34                 for (int z = 0; z < 2; ++ z) 
    35                 {        
    36                         for (int y = 0; y < 2; ++ y) 
    37                         { 
    38                                 for (int x = 0; x < 2; ++ x) 
    39                                 { 
    40                                         nextChild = octree->mChildren[x][y][z]; 
    41          
    42                                         if (nextChild) 
    43                         GetQueue()->push(nextChild); 
    44                                 } 
    45             } 
    46         } 
     34                nextChild = octree->mChildren[0][0][0]; if (nextChild) GetQueue()->push(nextChild); 
     35                nextChild = octree->mChildren[1][0][0]; if (nextChild) GetQueue()->push(nextChild); 
     36                nextChild = octree->mChildren[0][1][0]; if (nextChild) GetQueue()->push(nextChild); 
     37                nextChild = octree->mChildren[1][1][0]; if (nextChild) GetQueue()->push(nextChild); 
     38                nextChild = octree->mChildren[0][0][1]; if (nextChild) GetQueue()->push(nextChild); 
     39                nextChild = octree->mChildren[1][0][1]; if (nextChild) GetQueue()->push(nextChild); 
     40                nextChild = octree->mChildren[0][1][1]; if (nextChild) GetQueue()->push(nextChild); 
     41                nextChild = octree->mChildren[1][1][1]; if (nextChild) GetQueue()->push(nextChild); 
     42        } 
     43} 
     44//----------------------------------------------------------------------- 
     45void OctreeHierarchyInterface::TraverseNode2(GtpVisibility::HierarchyNode *node) 
     46{ 
     47        ++ mNumTraversedNodes; 
     48 
     49        Octree *octree = static_cast<Octree *>(node); 
     50 
     51        // if we come across some renderable geometry => render it 
     52        if (!octree->mNodes.empty()) 
     53        { 
     54                AddToQueue(node); 
     55        } 
     56         
     57        // if not all subtrees are empty 
     58        if (!IsLeaf(node)) 
     59        { 
     60                Octree *nextChild; 
     61 
     62                nextChild = octree->mChildren[0][0][0]; if (nextChild) GetQueue()->push(nextChild); 
     63                nextChild = octree->mChildren[1][0][0]; if (nextChild) GetQueue()->push(nextChild); 
     64                nextChild = octree->mChildren[0][1][0]; if (nextChild) GetQueue()->push(nextChild); 
     65                nextChild = octree->mChildren[1][1][0]; if (nextChild) GetQueue()->push(nextChild); 
     66                nextChild = octree->mChildren[0][0][1]; if (nextChild) GetQueue()->push(nextChild); 
     67                nextChild = octree->mChildren[1][0][1]; if (nextChild) GetQueue()->push(nextChild); 
     68                nextChild = octree->mChildren[0][1][1]; if (nextChild) GetQueue()->push(nextChild); 
     69                nextChild = octree->mChildren[1][1][1]; if (nextChild) GetQueue()->push(nextChild); 
    4770        } 
    4871} 
    … …  
    195218        if (octant->lastRendered() != mFrameId) 
    196219        { 
     220                mTestMode = false; 
     221 
    197222                octant->setLastRendered(mFrameId); 
    198223                OctreeSceneManager *ocm =  
    199224                        static_cast<OctreeSceneManager *>(mSceneManager); 
    200225 
    201                 ocm->_renderOctant(mCamera,  
     226                ocm->_addOctantToQueue(mCamera,  
    202227                                                   octant,  
    203228                                                   mOnlyShadowCasters,  
    204229                                                   mLeavePassesInQueue); 
    205230 
     231                ocm->_renderOctant(mLeavePassesInQueue); 
     232 
    206233                mVisibleNodes.push_back(node); 
    207234        } 
     235#endif   
     236} 
     237//----------------------------------------------------------------------- 
     238void OctreeHierarchyInterface::AddToQueue(GtpVisibility::HierarchyNode *node) 
     239{ 
     240#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
     241        Octree *octant = static_cast<Octree *>(node); 
     242 
     243        if (octant->lastRendered() != mFrameId) 
     244        { 
     245                OctreeSceneManager *ocm =  
     246                        static_cast<OctreeSceneManager *>(mSceneManager); 
     247 
     248                octant->setLastRendered(mFrameId); 
     249 
     250                ocm->_addOctantToQueue(mCamera,  
     251                                                   octant,  
     252                                                   mOnlyShadowCasters,  
     253                                                   mLeavePassesInQueue); 
     254 
     255                mVisibleNodes.push_back(node); 
     256        } 
     257#endif   
     258} 
     259//----------------------------------------------------------------------- 
     260void OctreeHierarchyInterface::RenderQueue() 
     261{ 
     262#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
     263        mTestMode = false; 
     264 
     265        OctreeSceneManager *ocm =  
     266                        static_cast<OctreeSceneManager *>(mSceneManager); 
     267        ocm->_renderOctant(mLeavePassesInQueue); 
    208268#endif   
    209269} 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgrePlatformHierarchyInterface.cpp

    r2497 r2555  
    9898         
    9999        mRenderSystem->_setWorldMatrix(Ogre::Matrix4::IDENTITY); 
    100         mSceneManager->useRenderableViewProjModeWrapper(solidBox); 
     100        //mSceneManager->useRenderableViewProjModeWrapper(solidBox); 
    101101         
    102102        // set no depth write, no color, no lighting material 
    103         mSceneManager->setPassWrapper(solidBox->getTechnique()->getPass(0)); 
     103        if (!mTestMode) 
     104        { 
     105                mTestMode = true; 
     106                mSceneManager->setPassWrapper(solidBox->getTechnique()->getPass(0)); 
     107        } 
     108 
    104109        solidBox->SetupBoundingBoxVertices(*box); 
    105110 
    … …  
    147152        // create materials for node visualization 
    148153        CreateNodeVizMaterials(); 
     154 
     155        mTestMode = false; 
    149156} 
    150157//----------------------------------------------------------------------- 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgrePlatformOcclusionQuery.cpp

    r944 r2555  
    2929                                                                                        const bool waitForResult) const 
    3030{ 
    31         // return mHardwareOcclusionQuery->pullOcclusionQuery(&visiblePixels, waitForResult); 
    32  
    33         bool isAvailable = true; 
    34  
    35         if (!waitForResult) 
     31        if (waitForResult || !mHardwareOcclusionQuery->isStillOutstanding()) 
    3632        { 
    37                 isAvailable = !mHardwareOcclusionQuery->isStillOutstanding(); 
     33                //return mHardwareOcclusionQuery->pullOcclusionQuery(&visiblePixels); 
     34                mHardwareOcclusionQuery->pullOcclusionQuery(&visiblePixels); 
     35                return true; 
    3836        } 
    3937 
    40 //std::stringstream d; d << mHardwareOcclusionQuery << ", available: " << isAvailable << ", waitforresult: " << waitForResult; 
    41 //              Ogre::LogManager::getSingleton().logMessage(d.str()); 
    42  
    43         if (isAvailable) 
    44                 return mHardwareOcclusionQuery->pullOcclusionQuery(&visiblePixels); 
    45          
    4638        return false; 
    4739} 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/include/CoherentHierarchicalCullingManager.h

    r2455 r2555  
    7070 
    7171        bool mTestGeometryForVisibleLeaves; 
     72 
     73        QueryQueue mQueryQueue; 
    7274}; 
    7375 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/include/CoherentHierarchicalCullingPlusPlusManager.h

    r2553 r2555  
    1 #ifndef _BatchedQueriesCullingManager_H__ 
    2 #define _BatchedQueriesCullingManager_H__ 
     1#ifndef _CoherentHierarchicalCullingPlusPlusManager_H__ 
     2#define _CoherentHierarchicalCullingPlusPlusManager_H__ 
    33 
    4 #include "CoherentHierarchicalCullingManager.h" 
     4#include "CullingManager.h" 
    55#include "HierarchyInterface.h" 
    66 
    … …  
    1111/** Renders the scene with the coherent hierarchical culling algorithm.  
    1212*/ 
    13 class BatchedQueriesCullingManager : public CoherentHierarchicalCullingManager 
     13class CoherentHierarchicalCullingPlusPlusManager: public CullingManager 
    1414{ 
    1515public: 
    16         BatchedQueriesCullingManager(); 
     16        CoherentHierarchicalCullingPlusPlusManager(); 
    1717        /** Constructor taking the assumed visibility into account, i.e., the estimation 
    1818                for how many frames the current visibility is considered to be valid 
    1919        */ 
    20         BatchedQueriesCullingManager(const unsigned int assumedVisibility); 
     20        CoherentHierarchicalCullingPlusPlusManager(const unsigned int assumedVisibility); 
    2121 
    2222        void RenderScene(); 
    2323         
    24         void SetMaxPending(int maxPending); 
     24        /** Sets assumed visibility (i.e., an estimation for  
     25                how many frames the visibility is considered to be valid). 
     26                @param assumedVisibility indicates for how many frames the  
     27                same visibility is be assumed. 
     28                if 0, the visibility is tested deterministically for each frame. 
     29        */ 
     30        void SetAssumedVisibility(const unsigned int assumedVisibility);         
     31        /** This is an optimization when issuing the occlusion test.  
     32                The test is done with actual geometry rather than the bounding  
     33                box of leave nodes previously marked as visible. 
     34 
     35                @param testGeometry if this optimization should be used 
     36                @remark this option is only useful for the coherent hierarchical culling algorithm 
     37        */ 
     38        void SetTestGeometryForVisibleLeaves(const bool testGeometry); 
     39        /** See TestGeometryForVisibleLeaves 
     40        */ 
     41        bool GetTestGeometryForVisibleLeaves(); 
     42 
    2543 
    2644protected: 
    2745 
    28         void IssueMultipleQueries(PendingQueue &pendingQueue, QueryQueue &queryQueue); 
     46        /** Decides if node is considered to be visible depeding on the  
     47                assumed visibility factor. 
     48                @returns if node is considered to be visible 
     49        */ 
     50        bool DecideVisible(HierarchyNode *node) const; 
    2951 
    30         /** maximal pending nodes. 
     52        /** Skip query for this node. 
    3153        */ 
    32         int mMaxPending; 
     54        void SkipQuery(HierarchyNode *node) const; 
     55 
     56        /** If this node is still valid for traversal in this frame. 
     57                It is possible that the parent was tested invisible before 
     58                so this node can be skipped. 
     59        */ 
     60        bool NodeInvalid(HierarchyNode *node) const; 
     61 
     62        void AssignAssumedVisibility(GtpVisibility::HierarchyNode *node); 
     63 
     64        void IssueBatchedQuery(HierarchyNodeContainer &nodes); 
     65 
     66        inline void IssueQuery(HierarchyNode *node, const bool testGeometry); 
     67 
     68 
     69        ////////////////////// 
     70 
     71        /** number of steps the visibility is assumed to be valid. 
     72        */ 
     73        unsigned int mAssumedVisibility; 
     74 
     75        bool mTestGeometryForVisibleLeaves; 
     76 
     77        QueryQueue mQueryQueue; 
     78 
     79        std::queue<HierarchyNode *> mVisibleNodes; 
     80        HierarchyNodeContainer mInvisibleNodes; 
     81 
     82        int mMaxInvisibleNodesSize; 
    3383}; 
    3484 
    3585} // namespace GtpVisibility 
    3686 
    37 #endif // BatchedQueriesCullingManager_H 
     87#endif // CoherentHierarchicalCullingPlusPlusManager_H 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/include/HierarchyInterface.h

    r2543 r2555  
    164164        */ 
    165165        virtual void DecNodeAssumedVisible(HierarchyNode *node) = 0; 
     166         
     167        virtual void AddToQueue(GtpVisibility::HierarchyNode *node) = 0; 
     168 
     169        virtual void RenderQueue() = 0; 
     170 
     171        virtual void TraverseNode2(GtpVisibility::HierarchyNode *node) = 0; 
    166172 
    167173protected: 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/include/VisibilityEnvironment.h

    r2289 r2555  
    2222        */ 
    2323        enum CullingManagerType {COHERENT_HIERARCHICAL_CULLING,  
     24                                                         COHERENT_HIERARCHICAL_CULLING_PLUSPLUS, 
     25                                                         STOP_AND_WAIT_CULLING,  
    2426                                                         FRUSTUM_CULLING,  
    25                                                          RANDOM_UPDATE_CULLING, 
    26                                                          STOP_AND_WAIT_CULLING,  
    27                                                          NUM_CULLING_MANAGERS}; 
     27                             NUM_CULLING_MANAGERS}; 
    2828 
    2929         

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/scripts/terrainCulling.cfg

    r2497 r2555  
    33# 
    44 
    5 OnlineCullingAlgorithm=RUC 
     5OnlineCullingAlgorithm=CHC++ 
    66#OnlineCullingAlgorithm=CHC 
    77#OnlineCullingAlgorithm=SWC 
    … …  
    8787 
    8888#Scene=../../../../../resources/media/house_test1.iv 
    89 #Scene=../../../../../resources/media/city1500_flat_1.iv;../../../../../resources/media/roofs_1500.iv;../../../../../resources/media/CityRoads60.iv;../../../../../resources/media/CityPlane60.iv 
     89Scene=../../../../../resources/media/city1500_flat_1.iv;../../../../../resources/media/roofs_1500.iv;../../../../../resources/media/CityRoads60.iv;../../../../../resources/media/CityPlane60.iv 
    9090#Scene=../../../../../resources/media/city1.iv;../../../../../resources/media/roofs_1500.iv;../../../../../resources/media/CityRoads60.iv;../../../../../resources/media/CityPlane60.iv 
    9191 
    … …  
    9696# 
    9797 
    98 Scene=terrain 
     98#Scene=terrain 
    9999 
    100100 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/CoherentHierarchicalCullingManager.cpp

    r2455 r2555  
    99 
    1010 
    11 static int batchSize = 5; 
    1211 
    1312//----------------------------------------------------------------------- 
    … …  
    3635{ 
    3736        if (0) CullingLogManager::GetSingleton()->LogMessage("chc"); 
    38         QueryQueue queryQueue; 
    3937        unsigned int visiblePixels = 0; 
    4038         
    … …  
    4240        //-- PART 1: process finished occlusion queries 
    4341 
    44         while (!mHierarchyInterface->GetQueue()->empty() || !queryQueue.empty()) 
     42        while (!mHierarchyInterface->GetQueue()->empty() || !mQueryQueue.empty()) 
    4543        { 
    4644                ////////// 
    4745                //-- only wait for result if there are no nodes to process 
    4846 
    49                 while (!queryQueue.empty() &&  
    50                            (NodeInvalid(queryQueue.front().first) || 
    51                             queryQueue.front().second->GetQueryResult( 
     47                while (!mQueryQueue.empty() &&  
     48                           (NodeInvalid(mQueryQueue.front().first) || 
     49                            mQueryQueue.front().second->GetQueryResult( 
    5250                                             visiblePixels, mHierarchyInterface->GetQueue()->empty()))) 
    5351                { 
    54                         HierarchyNode *node = queryQueue.front().first; 
    55                         queryQueue.pop(); 
     52                        HierarchyNode *node = mQueryQueue.front().first; 
     53                        mQueryQueue.pop(); 
    5654 
    5755                        // "invalid nodes" happen for hierarchies that have geometry 
    … …  
    145143                                        ++ mNumQueriesIssued; 
    146144                                         
    147                                         const bool testGeometry = wasVisible && mHierarchyInterface->IsLeaf(node) && mTestGeometryForVisibleLeaves; 
    148  
    149                                         queryQueue.push(QueryPair(node, mHierarchyInterface-> 
     145                                        const bool testGeometry =  
     146                                                wasVisible && mHierarchyInterface->IsLeaf(node) && mTestGeometryForVisibleLeaves; 
     147 
     148                                        mQueryQueue.push(QueryPair(node, mHierarchyInterface-> 
    150149                                                IssueNodeOcclusionQuery(node, testGeometry))); 
    151150                                } 
    … …  
    192191{ 
    193192        // parent was tested invisible in this frame 
    194         HierarchyNode *parent = mHierarchyInterface->GetParent(node); 
    195     return  
    196                 parent &&  
    197                 (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId()) &&  
    198                 !mHierarchyInterface->IsNodeVisible(parent); 
     193    return (  
     194                    mHierarchyInterface->GetParent(node) &&  
     195                    (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId()) &&  
     196                    !mHierarchyInterface->IsNodeVisible(mHierarchyInterface->GetParent(node)) 
     197           ); 
    199198} 
    200199//----------------------------------------------------------------------- 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/CoherentHierarchicalCullingPlusPlusManager.cpp

    r2553 r2555  
    1 #include "BatchedQueriesCullingManager.h" 
     1#include "CoherentHierarchicalCullingPlusPlusManager.h" 
     2#include "CullingLogManager.h" 
     3 
     4#include <time.h> 
     5#include <sstream> 
     6 
    27 
    38 
    49namespace GtpVisibility { 
    510 
    6 //----------------------------------------------------------------------- 
    7 BatchedQueriesCullingManager::BatchedQueriesCullingManager(): 
    8 mMaxPending(5) 
    9 { 
    10 } 
    11 //----------------------------------------------------------------------- 
    12 BatchedQueriesCullingManager::BatchedQueriesCullingManager(const unsigned int  
    13                                                                                                                    assumedVisibility): 
    14 CoherentHierarchicalCullingManager(assumedVisibility), mMaxPending(5) 
    15 { 
    16 } 
    17  
    18 //----------------------------------------------------------------------- 
    19 void BatchedQueriesCullingManager::RenderScene() 
    20 { 
    21         QueryQueue queryQueue; 
     11 
     12static const bool CULL_INVALID_NODES = false; 
     13 
     14//----------------------------------------------------------------------- 
     15CoherentHierarchicalCullingPlusPlusManager::CoherentHierarchicalCullingPlusPlusManager(): 
     16mAssumedVisibility(0), mMaxInvisibleNodesSize(50) 
     17{ 
     18} 
     19//----------------------------------------------------------------------- 
     20CoherentHierarchicalCullingPlusPlusManager::CoherentHierarchicalCullingPlusPlusManager( 
     21                                                                                                                const unsigned int assumedVisibility): 
     22mAssumedVisibility(assumedVisibility), mMaxInvisibleNodesSize(50) 
     23{ 
     24} 
     25//----------------------------------------------------------------------- 
     26void CoherentHierarchicalCullingPlusPlusManager::AssignAssumedVisibility(GtpVisibility::HierarchyNode *node) 
     27{ 
     28        if (!mHierarchyInterface->IsNodeVisible(node)) 
     29                // previously invisible nodes: give random offset just for the first test after 
     30                // becoming visible to avoid that all nodes are tested in the same frame 
     31                mHierarchyInterface->SetNodeAssumedVisible(node, rand() * mAssumedVisibility / RAND_MAX); 
     32        else 
     33                mHierarchyInterface->SetNodeAssumedVisible(node, mAssumedVisibility); 
     34} 
     35//----------------------------------------------------------------------- 
     36void CoherentHierarchicalCullingPlusPlusManager::RenderScene() 
     37{ 
     38        if (0) CullingLogManager::GetSingleton()->LogMessage("chc++"); 
     39         
    2240        unsigned int visiblePixels = 0; 
    2341 
    24         PendingQueue pendingQueue; 
    25  
     42        ///////////// 
    2643        //-- PART 1: process finished occlusion queries 
    27         while (!mHierarchyInterface->GetQueue()->empty() || !queryQueue.empty() ||!pendingQueue.empty()) 
     44 
     45        while (!mHierarchyInterface->GetQueue()->empty() || !mQueryQueue.empty() || 
     46                   !mInvisibleNodes.empty() || !mVisibleNodes.empty()) 
    2847        { 
    29                 while (!queryQueue.empty() &&  
    30                            queryQueue.front().second->GetQueryResult(visiblePixels,  
    31                                                                         mHierarchyInterface->GetQueue()->empty())) 
     48                ////////// 
     49                //-- only wait for result if there are no nodes to process 
     50 
     51                bool resultAvailable = false; 
     52                while ( 
     53                           !mQueryQueue.empty() &&  
     54                           (NodeInvalid(mQueryQueue.front().first) || 
     55                           mHierarchyInterface->GetQueue()->empty() || 
     56                           (resultAvailable = mQueryQueue.front().second->GetQueryResult(visiblePixels, false))) 
     57                           ) 
    3258                { 
    33                 HierarchyNode *node = queryQueue.front().first; 
    34                          
    35                         queryQueue.pop(); 
    36  
     59                        HierarchyNode *node = mQueryQueue.front().first; 
     60 
     61                        // "invalid nodes" happen for hierarchies that store geometry in the interiors 
     62                        // parent was tested invisible => remove children from queue 
     63                        if (NodeInvalid(node)) {mQueryQueue.pop(); continue;} 
     64 
     65                        // during the wait time issue nodes from visible queue 
     66                        while (!mVisibleNodes.empty() && !resultAvailable) 
     67                        { 
     68                                HierarchyNode *vn = mVisibleNodes.front(); 
     69                                mVisibleNodes.pop(); 
     70                                IssueQuery(vn, false); 
     71 
     72                                // check if result is already availalbe 
     73                                resultAvailable = mQueryQueue.front().second->GetQueryResult(visiblePixels, false); 
     74                        } 
     75 
     76                        if (!resultAvailable) 
     77                                mQueryQueue.front().second->GetQueryResult(visiblePixels, true); 
     78 
     79                        resultAvailable = false; 
     80                mQueryQueue.pop(); 
     81 
     82                        // tested visible 
    3783                        if (visiblePixels > mVisibilityThreshold) 
    3884                        { 
    39                                 // ensure that we only traverse once if geometry in node 
     85                                // assing the #frames the node is assumed to stay visible 
     86                                AssignAssumedVisibility(node); 
     87 
     88                                // for previously visible interior node which contains geometry:  
     89                                // ensure that we did not already traverse this node  
     90                                // (which means that the visibility flag is set) 
    4091                                if (!mHierarchyInterface->IsNodeVisible(node)) 
    41                                         mHierarchyInterface->TraverseNode(node); 
     92                                        mHierarchyInterface->TraverseNode2(node); 
    4293 
    4394                                mHierarchyInterface->PullUpVisibility(node); 
    … …  
    50101                                 
    51102                                if (mVisualizeCulledNodes) 
    52                                 { 
    53103                                        mHierarchyInterface->VisualizeCulledNode(node, QUERY_CULLED); 
    54104                                } 
    55                         } 
     105                         
     106                        // update node's visited flag 
     107                        mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId());    
    56108                } 
    57109                 
     110                //////////////// 
    58111                //-- PART 2: hierarchical traversal 
     112 
    59113                if (!mHierarchyInterface->GetQueue()->empty()) 
    60114                { 
    … …  
    62116                        mHierarchyInterface->GetQueue()->pop(); 
    63117                                 
     118                        // parent was tested invisible => remove children from queue 
     119                        if (NodeInvalid(node)) continue; 
     120 
    64121                        bool intersects = false; 
    65122 
    … …  
    69126                                 
    70127                                if (mVisualizeCulledNodes) 
    71                                 { 
    72128                                        mHierarchyInterface->VisualizeCulledNode(node, FRUSTUM_CULLED); 
    73                                 } 
    74                         } 
    75                         // -- if node intersects near plane, skip query because wrong results possible 
     129                        } 
    76130                        else if (intersects) 
    77131                        { 
     132                                //-- if node intersects near plane, skip query because wrong results possible 
    78133                                SkipQuery(node); 
    79134                        } 
    … …  
    85140                                 
    86141                                // if we assume node to be visible in this frame => skip query  
    87                                 bool skipQuery = wasVisible && (mAssumedVisibility > 0) &&  
    88                                         DecideVisible(node) && mHierarchyInterface->HasGeometry(node); 
     142                                const bool skipQuery = wasVisible && 
     143                                                                           DecideVisible(node) &&  
     144                                                                           mHierarchyInterface->HasGeometry(node); 
    89145 
    90146                                if (skipQuery) 
    … …  
    96152                // identify nodes that we cannot skip queries for 
    97153                                // geometry not only in leaves => test for renderable geometry 
    98                                 bool issueQuery = !wasVisible || mHierarchyInterface->HasGeometry(node); 
     154                                const bool issueQuery = !wasVisible || mHierarchyInterface->HasGeometry(node); 
    99155                                                         
    100                                 // reset node's visibility classification 
    101                                 // set visible if geometry in node so we only traverse once 
     156                                // set node's visibility classification 
     157                                // we identify previously visible / invisible nodes in the query queue 
    102158                                mHierarchyInterface->SetNodeVisible(node, wasVisible && issueQuery); 
    103159 
    104                                 // update node's visited flag 
    105                                 mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId()); 
    106  
    107                                 // skip testing previously visible nodes without geometry 
    108160                                if (issueQuery) 
    109161                                { 
    110162                                        ++ mNumQueriesIssued; 
    111                                         // add to the pending queue instead of immediate query 
    112                                         if ((int)pendingQueue.size() < mMaxPending) 
    113                                                 pendingQueue.push(PendingQuery(node, wasVisible)); 
     163 
     164                                        if (!wasVisible) 
     165                                        { 
     166                                                mInvisibleNodes.push_back(node); 
     167 
     168                                                if ((int)mInvisibleNodes.size() >= mMaxInvisibleNodesSize) 
     169                                                { 
     170                                                        mHierarchyInterface->RenderQueue(); 
     171                                                        // issue the batched queries 
     172                                                        IssueBatchedQuery(mInvisibleNodes); 
     173                                                } 
     174                                        } 
    114175                                        else 
    115176                                        { 
    116                                                 IssueMultipleQueries(pendingQueue, queryQueue);  
     177                                                mVisibleNodes.push(node); 
     178                                                //IssueQuery(node, false); 
    117179                                        } 
     180                                } 
     181                                else 
     182                                { 
     183                                        // skip testing previously visible nodes without geometry 
     184                    // just update node's visited flag 
     185                                        mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId()); 
    118186                                } 
    119187                                 
    … …  
    121189                                if (wasVisible) 
    122190                                { 
    123                                         mHierarchyInterface->TraverseNode(node); 
     191                                        mHierarchyInterface->TraverseNode2(node); 
    124192                                } 
    125193                        } 
    126194                } 
    127195 
    128                 // issue rest of queries 
    129                 IssueMultipleQueries(pendingQueue, queryQueue); 
     196                 
     197                if (mHierarchyInterface->GetQueue()->empty() && !mInvisibleNodes.empty()) 
     198                { 
     199                        if (0) 
     200                        { 
     201                                std::stringstream d; 
     202                                d << "inv nodes: " << (int)mInvisibleNodes.size(); 
     203                                CullingLogManager::GetSingleton()->LogMessage(d.str()); 
     204                        } 
     205                         
     206                        mHierarchyInterface->RenderQueue(); 
     207                        IssueBatchedQuery(mInvisibleNodes); 
     208                } 
     209 
     210        // issue rest of nodes from nodes from visible queue 
     211                if (mHierarchyInterface->GetQueue()->empty() && mQueryQueue.empty() && !mVisibleNodes.empty()) 
     212                { 
     213                        if (0) 
     214                        { 
     215                                std::stringstream d; 
     216                                d << "vis nodes: " << (int)mVisibleNodes.size(); 
     217                                CullingLogManager::GetSingleton()->LogMessage(d.str()); 
     218                        } 
     219 
     220                        while (!mVisibleNodes.empty()) 
     221                        { 
     222                                IssueQuery(mVisibleNodes.front(), false); 
     223                                mVisibleNodes.pop(); 
     224                        } 
     225                } 
    130226        } 
    131 } 
    132  
    133 void BatchedQueriesCullingManager::IssueMultipleQueries(PendingQueue &pendingQueue,  
    134                                                                                                                 QueryQueue &queryQueue) 
    135 { 
    136         while (!pendingQueue.empty()) 
     227 
     228 
     229        if (0) 
    137230        { 
    138                 HierarchyNode *node = pendingQueue.front().first; 
    139                 const bool wasVisible = pendingQueue.front().second; 
    140  
    141                 pendingQueue.pop(); 
    142  
    143                 queryQueue.push(QueryPair(node, mHierarchyInterface-> 
    144                                         IssueNodeOcclusionQuery(node, wasVisible))); 
     231                std::stringstream d; 
     232                d << "queries: " << (int)mQueryQueue.size() << " vis: " << (int)mVisibleNodes.size() << " inv: " << (int)mInvisibleNodes.size(); 
     233                CullingLogManager::GetSingleton()->LogMessage(d.str()); 
    145234        } 
    146 } 
    147  
    148 void BatchedQueriesCullingManager::SetMaxPending(int maxPending) 
    149 { 
    150         mMaxPending = maxPending; 
    151 } 
    152  
    153 } // namespace GtpVisibility 
     235         
     236        // render rest 
     237        mHierarchyInterface->RenderQueue(); 
     238} 
     239//----------------------------------------------------------------------- 
     240void CoherentHierarchicalCullingPlusPlusManager::SetAssumedVisibility(const unsigned int assumedVisibility) 
     241{ 
     242        mAssumedVisibility = assumedVisibility; 
     243} 
     244//----------------------------------------------------------------------- 
     245inline bool CoherentHierarchicalCullingPlusPlusManager::DecideVisible(HierarchyNode *node) const 
     246{ 
     247        mHierarchyInterface->DecNodeAssumedVisible(node); 
     248        //std::stringstream d; d << "node visible: " << mHierarchyInterface->GetNodeAssumedVisible(node); 
     249        //CullingLogManager::GetSingleton()->LogMessage(d.str()); 
     250        return mHierarchyInterface->GetNodeAssumedVisible(node) > 0; 
     251} 
     252//----------------------------------------------------------------------- 
     253inline void CoherentHierarchicalCullingPlusPlusManager::SkipQuery(HierarchyNode *node) const 
     254{ 
     255        //-- set node to be visible in this frame, then traverse it 
     256        mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId()); 
     257 
     258        mHierarchyInterface->PullUpVisibility(node);                     
     259        mHierarchyInterface->TraverseNode2(node); 
     260} 
     261//----------------------------------------------------------------------- 
     262inline bool CoherentHierarchicalCullingPlusPlusManager::NodeInvalid(HierarchyNode *node) const 
     263{ 
     264        if (!CULL_INVALID_NODES) return false; 
     265 
     266        // parent was tested invisible in this frame 
     267    return (  
     268                    mHierarchyInterface->GetParent(node) &&  
     269                    (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId()) &&  
     270                    !mHierarchyInterface->IsNodeVisible(mHierarchyInterface->GetParent(node)) 
     271           ); 
     272} 
     273//----------------------------------------------------------------------- 
     274void CoherentHierarchicalCullingPlusPlusManager::SetTestGeometryForVisibleLeaves(const bool testGeometry) 
     275{ 
     276        mTestGeometryForVisibleLeaves = testGeometry; 
     277} 
     278//----------------------------------------------------------------------- 
     279bool CoherentHierarchicalCullingPlusPlusManager::GetTestGeometryForVisibleLeaves() 
     280{ 
     281        return mTestGeometryForVisibleLeaves; 
     282} 
     283//----------------------------------------------------------------------- 
     284inline void CoherentHierarchicalCullingPlusPlusManager::IssueQuery(HierarchyNode *node,  
     285                                                                                                                                   const bool queryGeometry) 
     286{ 
     287        mQueryQueue.push(QueryPair(node, mHierarchyInterface-> 
     288                IssueNodeOcclusionQuery(node, queryGeometry))); 
     289} 
     290//----------------------------------------------------------------------- 
     291void CoherentHierarchicalCullingPlusPlusManager::IssueBatchedQuery(HierarchyNodeContainer &nodes) 
     292{ 
     293        HierarchyNodeContainer::const_iterator nit, nit_end = nodes.end(); 
     294 
     295        for (nit = nodes.begin(); nit != nit_end; ++ nit) 
     296                IssueQuery(*nit, false); 
     297 
     298        nodes.clear(); 
     299} 
     300                 
     301} 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/FrustumCullingManager.cpp

    r2292 r2555  
    3131                { 
    3232                        mHierarchyInterface->SetNodeVisible(node, true); 
    33                         mHierarchyInterface->TraverseNode(node); 
     33                        mHierarchyInterface->TraverseNode2(node); 
    3434                } 
    3535        } 
     36        mHierarchyInterface->RenderQueue(); 
    3637} 
    3738} // namespace GtpVisibility 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/GtpVisibility.vcproj

    r2542 r2555  
    253253                        UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"> 
    254254                        <File 
    255                                 RelativePath="..\src\BatchedQueriesCullingManager.cpp"> 
    256                         </File> 
    257                         <File 
    258255                                RelativePath="..\src\CoherentHierarchicalCullingManager.cpp"> 
     256                        </File> 
     257                        <File 
     258                                RelativePath=".\CoherentHierarchicalCullingPlusPlusManager.cpp"> 
    259259                        </File> 
    260260                        <File 
    … …  
    297297                        UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"> 
    298298                        <File 
    299                                 RelativePath="..\include\BatchedQueriesCullingManager.h"> 
    300                         </File> 
    301                         <File 
    302299                                RelativePath="..\include\CoherentHierarchicalCullingManager.h"> 
    303300                        </File> 
    304301                        <File 
    305                                 RelativePath="..\include\CoherentHierarchicalCullingManager2.h"> 
     302                                RelativePath="..\include\CoherentHierarchicalCullingPlusPlusManager.h"> 
    306303                        </File> 
    307304                        <File 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/VisibilityManager.cpp

    r2455 r2555  
    55#include "DummyPreprocessingManager.h" 
    66#include "RandomUpdateCullingManager.h" 
     7#include "CoherentHierarchicalCullingPlusPlusManager.h" 
    78#include "CullingLogManager.h" 
    89 
    … …  
    1920mAssumedVisibilityForChc(0) 
    2021{ 
    21 #if 1 
    2222        SetCullingManager(VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING); 
    23 #endif 
    24 #if 0    
    25         SetCullingManager(VisibilityEnvironment::STOP_AND_WAIT_CULLING); 
    26 #endif 
    27 #if 0 
    28         SetCullingManager(VisibilityEnvironment::FRUSTUM_CULLING); 
    29 #endif 
    3023} 
    3124//----------------------------------------------------------------------- 
    … …  
    6154                        mCullingManager = new FrustumCullingManager(); 
    6255                        break; 
    63                 case VisibilityEnvironment::RANDOM_UPDATE_CULLING: 
     56                case VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING_PLUSPLUS: 
    6457                        { 
    65                                 RandomUpdateCullingManager *rum = new RandomUpdateCullingManager(mRandomCandidatesForRuc); 
    66                                 rum->SetTestGeometryForVisibleLeaves(mTestGeometryForVisibleLeaves); 
    67                                 mCullingManager = rum; 
     58                                CoherentHierarchicalCullingPlusPlusManager *chcm =  
     59                                        new CoherentHierarchicalCullingPlusPlusManager(mAssumedVisibilityForChc); 
     60                                mCullingManager = chcm; 
    6861                        } 
    6962                        break; 
    … …  
    118111        mAssumedVisibilityForChc = assumedVisibility; 
    119112 
    120         if (mCullingManagerType == VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING) 
     113        switch (mCullingManagerType) 
    121114        { 
     115        case VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING: 
    122116                static_cast<CoherentHierarchicalCullingManager *>(mCullingManager)-> 
    123117                                SetAssumedVisibility(mAssumedVisibilityForChc); 
     118                break; 
     119        case VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING_PLUSPLUS: 
     120                static_cast<CoherentHierarchicalCullingPlusPlusManager *>(mCullingManager)-> 
     121                                SetAssumedVisibility(mAssumedVisibilityForChc); 
     122                break; 
    124123        } 
    125124} 
    … …  
    129128        mRandomCandidatesForRuc = randomCandidates; 
    130129 
    131         if (mCullingManagerType == VisibilityEnvironment::RANDOM_UPDATE_CULLING) 
     130        if (mCullingManagerType == VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING_PLUSPLUS) 
    132131        { 
    133132                static_cast<RandomUpdateCullingManager *>(mCullingManager)-> 
    … …  
    160159                                SetTestGeometryForVisibleLeaves(mTestGeometryForVisibleLeaves); 
    161160        } 
    162         else if (mCullingManagerType == VisibilityEnvironment::RANDOM_UPDATE_CULLING) 
     161        /*else if (mCullingManagerType == VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING_PLUSPLUS) 
    163162        { 
    164163                static_cast<RandomUpdateCullingManager *>(mCullingManager)-> 
    165164                                SetTestGeometryForVisibleLeaves(mTestGeometryForVisibleLeaves); 
    166         } 
     165        }*/ 
    167166} 
    168167//----------------------------------------------------------------------- 
Note: See TracChangeset for help on using the changeset viewer.