Ignore:
Timestamp:
06/14/07 17:24:08 (18 years ago)
Author:
mattausch
Message:
 
Location:
GTP/trunk/Lib/Vis/OnlineCullingCHC/src
Files:
1 deleted
6 edited

Legend:

Unmodified
Added
Removed

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

    r2452 r2455  
    33 
    44#include <time.h> 
     5#include <sstream> 
     6 
    57 
    68namespace GtpVisibility { 
    79 
    8 //----------------------------------------------------------------------- 
    9 CoherentHierarchicalCullingManager::CoherentHierarchicalCullingManager() 
    10 { 
    11         SetAssumedVisibility(0); 
    12         // initialise random generator in case we use assumed visibility 
    13         //srand(time(NULL)); 
     10 
     11static int batchSize = 5; 
     12 
     13//----------------------------------------------------------------------- 
     14CoherentHierarchicalCullingManager::CoherentHierarchicalCullingManager(): 
     15mAssumedVisibility(0) 
     16{ 
    1417} 
    1518//----------------------------------------------------------------------- 
    1619CoherentHierarchicalCullingManager::CoherentHierarchicalCullingManager( 
    17                                                                                                                 const unsigned int assumedVisibility) 
    18 { 
    19         SetAssumedVisibility(assumedVisibility); 
    20         // initialise random generator in case we use assumed visibility 
    21         //srand(time(NULL)); 
     20                                                                                                                const unsigned int assumedVisibility): 
     21mAssumedVisibility(assumedVisibility) 
     22{ 
     23} 
     24//----------------------------------------------------------------------- 
     25void CoherentHierarchicalCullingManager::AssignAssumedVisibility(GtpVisibility::HierarchyNode *node) 
     26{ 
     27        if (!mHierarchyInterface->IsNodeVisible(node)) 
     28                // previously invisible nodes: give random offset just for the first test after 
     29                // becoming visible to avoid that all nodes are tested in the same frame 
     30                mHierarchyInterface->SetNodeAssumedVisible(node, rand() * mAssumedVisibility / RAND_MAX); 
     31        else 
     32                mHierarchyInterface->SetNodeAssumedVisible(node, mAssumedVisibility); 
    2233} 
    2334//----------------------------------------------------------------------- 
    … …  
    3546                ////////// 
    3647                //-- only wait for result if there are no nodes to process 
     48 
    3749                while (!queryQueue.empty() &&  
    3850                           (NodeInvalid(queryQueue.front().first) || 
    … …  
    4355                        queryQueue.pop(); 
    4456 
     57                        // "invalid nodes" happen for hierarchies that have geometry 
     58                        // not neccessarily in the leaves: 
    4559                        // parent was tested invisible => remove children from queue 
    46                         if (NodeInvalid(node)) 
    47                         { 
    48                                 //CullingLogManager::GetSingleton()->LogMessage("skipping this node"); 
     60 
     61                        if (1 && NodeInvalid(node)) 
    4962                                continue; 
    50                         } 
     63 
    5164                        // tested visible 
    5265                        if (visiblePixels > mVisibilityThreshold) 
    5366                        { 
    54                                 // in case geometry is in interior node: ensure that we only traverse once 
     67                                // assing the #frames the node is assumed to stay visible 
     68                                AssignAssumedVisibility(node); 
     69 
     70                                // for previously visible interior node which contains geometry:  
     71                                // ensure that we did not already traverse this node  
     72                                // (which means that the visibility flag is set) 
    5573                                if (!mHierarchyInterface->IsNodeVisible(node)) 
    56                                 { 
    5774                                        mHierarchyInterface->TraverseNode(node); 
    58                                 } 
    5975 
    6076                                mHierarchyInterface->PullUpVisibility(node); 
    … …  
    6581 
    6682                ++ mNumQueryCulledNodes; 
    67                                  
     83 
    6884                                if (mVisualizeCulledNodes) 
    69                                 { 
    7085                                        mHierarchyInterface->VisualizeCulledNode(node, QUERY_CULLED); 
    71                                 } 
    7286                        } 
    7387                         
    … …  
    7690                } 
    7791                 
     92                //////////////// 
    7893                //-- PART 2: hierarchical traversal 
     94 
    7995                if (!mHierarchyInterface->GetQueue()->empty()) 
    8096                { 
    … …  
    8399                                 
    84100                        // parent was tested invisible => remove children from queue 
    85                         if (NodeInvalid(node)) 
    86                         { 
    87                                 //CullingLogManager::GetSingleton()->LogMessage("skipping this node"); 
     101                        if (1 && NodeInvalid(node)) 
    88102                                continue; 
    89                         } 
    90103 
    91104                        bool intersects = false; 
    … …  
    96109 
    97110                                if (mVisualizeCulledNodes) 
    98                                 { 
    99111                                        mHierarchyInterface->VisualizeCulledNode(node, FRUSTUM_CULLED); 
    100                                 } 
    101112                        } 
    102113                        //-- if node intersects near plane, skip query because wrong results possible 
    … …  
    112123                                 
    113124                                // if we assume node to be visible in this frame => skip query  
    114                                 const bool skipQuery = wasVisible &&  
    115                                                            (mAssumedVisibility > 0) &&  
     125                                const bool skipQuery = wasVisible && 
    116126                                                                           DecideVisible(node) &&  
    117127                                                                           mHierarchyInterface->HasGeometry(node); 
    … …  
    127137                                bool issueQuery = !wasVisible || mHierarchyInterface->HasGeometry(node); 
    128138                                                         
    129                                 // reset node's visibility classification 
    130                                 // set visible if geometry in node so we only traverse once 
     139                                // set node's visibility classification 
     140                                // we identify previously visible / invisible nodes in the query queue 
    131141                                mHierarchyInterface->SetNodeVisible(node, wasVisible && issueQuery); 
    132142 
    133                                 // skip testing previously visible nodes without geometry 
    134143                                if (issueQuery) 
    135144                                { 
    136145                                        ++ mNumQueriesIssued; 
    137146                                         
     147                                        const bool testGeometry = wasVisible && mHierarchyInterface->IsLeaf(node) && mTestGeometryForVisibleLeaves; 
     148 
    138149                                        queryQueue.push(QueryPair(node, mHierarchyInterface-> 
    139                                                 IssueNodeOcclusionQuery(node, wasVisible))); 
     150                                                IssueNodeOcclusionQuery(node, testGeometry))); 
    140151                                } 
    141152                                else 
    142153                                { 
    143                                         // update node's visited flag 
     154                                        // skip testing previously visible nodes without geometry 
     155                    // just update node's visited flag 
    144156                                        mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId()); 
    145157                                } 
    … …  
    158170{ 
    159171        mAssumedVisibility = assumedVisibility; 
    160          
    161         if (!mAssumedVisibility) 
    162         { 
    163                 mThreshold = 0; 
    164         } 
    165         else 
    166         { 
    167                 mThreshold = RAND_MAX - RAND_MAX / mAssumedVisibility; 
    168                  // fix visibility 
    169                 if (mAssumedVisibility > 100) 
    170                         mThreshold = RAND_MAX; 
    171         } 
    172          
    173172} 
    174173//----------------------------------------------------------------------- 
    175174inline bool CoherentHierarchicalCullingManager::DecideVisible(HierarchyNode *node) const 
    176175{ 
    177         return rand() < mThreshold; 
     176        mHierarchyInterface->DecNodeAssumedVisible(node); 
     177        //std::stringstream d; d << "node visible: " << mHierarchyInterface->GetNodeAssumedVisible(node); 
     178        //CullingLogManager::GetSingleton()->LogMessage(d.str()); 
     179        return mHierarchyInterface->GetNodeAssumedVisible(node) > 0; 
    178180} 
    179181//----------------------------------------------------------------------- 
    … …  
    196198                !mHierarchyInterface->IsNodeVisible(parent); 
    197199} 
    198 } // namespace GtpVisibility 
     200//----------------------------------------------------------------------- 
     201void CoherentHierarchicalCullingManager::SetTestGeometryForVisibleLeaves(const bool testGeometry) 
     202{ 
     203        mTestGeometryForVisibleLeaves = testGeometry; 
     204} 
     205//----------------------------------------------------------------------- 
     206bool CoherentHierarchicalCullingManager::GetTestGeometryForVisibleLeaves() 
     207{ 
     208        return mTestGeometryForVisibleLeaves; 
     209} 
     210 
     211} 

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

    r2360 r2455  
    259259                        </File> 
    260260                        <File 
    261                                 RelativePath=".\CoherentHierarchicalCullingManager2.cpp"> 
    262                         </File> 
    263                         <File 
    264261                                RelativePath=".\CullingLogManager.cpp"> 
    265262                        </File> 

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

    r2306 r2455  
    1010mNumTraversedNodes(0),  
    1111mHierarchyRoot(NULL),  
    12 mSavedNode(NULL),  
    13 mCurrentTestIdx(0),  
    14 mTestGeometryForVisibleLeaves(false) 
     12mOldNode(NULL),  
     13mCurrentTestIdx(0) 
    1514{        
    1615        mDistanceQueue = new DistanceQueue(GtDistance<HierarchyNode *>(this)); 
    … …  
    7271} 
    7372//----------------------------------------------------------------------- 
    74 void HierarchyInterface::TestGeometryForVisibleLeaves(bool testGeometry) 
    75 { 
    76         mTestGeometryForVisibleLeaves = testGeometry; 
    77 } 
    78 //----------------------------------------------------------------------- 
    7973std::vector<HierarchyNode *> *HierarchyInterface::GetVisibleNodes() 
    8074{ 

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

    r2332 r2455  
    1313 
    1414const static int R_CANDIDATES = 1; 
    15 //----------------------------------------------------------------------- 
    16 RandomUpdateCullingManager::RandomUpdateCullingManager() 
    17 { 
    18         SetAssumedVisibility(0); 
    19         // initialise random generator in case we use assumed visibility 
    20         //srand(time(NULL)); 
    21  
    22         mRandomCandidates = R_CANDIDATES; 
    23 } 
    24 //----------------------------------------------------------------------- 
    25 RandomUpdateCullingManager::RandomUpdateCullingManager( 
    26                         const unsigned int assumedVisibility) 
    27 { 
    28         SetAssumedVisibility(assumedVisibility); 
    29         // initialise random generator in case we use assumed visibility 
    30         //srand(time(NULL)); 
    31  
    32         mRandomCandidates = R_CANDIDATES; 
     15 
     16//----------------------------------------------------------------------- 
     17RandomUpdateCullingManager::RandomUpdateCullingManager(): mRandomCandidates(R_CANDIDATES) 
     18{ 
     19} 
     20//----------------------------------------------------------------------- 
     21RandomUpdateCullingManager::RandomUpdateCullingManager(const unsigned int randomCandidates) 
     22{        
     23        mRandomCandidates = std::max(randomCandidates, (unsigned int)1); 
     24} 
     25//----------------------------------------------------------------------- 
     26void RandomUpdateCullingManager::SetRandomCandidates(const unsigned int randomCandidates) 
     27{ 
     28        mRandomCandidates = std::max(randomCandidates, (unsigned int)1); 
    3329} 
    3430//----------------------------------------------------------------------- 
    … …  
    105101                        else 
    106102                        { 
    107                                  
     103                                // fully visible subtree => render all in one bathc 
    108104                                if (mHierarchyInterface->IsNodeFullyVisible(node)) 
    109105                                { 
    110 #if 1 
    111                                         // node fully visible => test only random leaves 
    112                                         for (int i = 0; i < mRandomCandidates; ++ i) 
    113                                         { 
    114                                                 HierarchyNode *randomLeaf = mHierarchyInterface->GetRandomLeaf(node); 
    115                                                  
    116                                                 if (!randomLeaf) 
    117                                                         continue; 
    118  
    119                                                 mHierarchyInterface->SetNodeVisible(randomLeaf, false); 
    120  
    121                                                 // update node's visited flag 
    122                                                 mHierarchyInterface->PullUpLastVisited(randomLeaf, mHierarchyInterface->GetFrameId()); 
    123  
    124                                                 queryQueue.push(QueryPair(randomLeaf,  
    125                                                         mHierarchyInterface->IssueNodeOcclusionQuery(node))); 
    126                                         } 
    127 #else 
    128                                         // test all leaves for visibility changes 
     106                                        // use different algorithm for finding random candidates 
    129107                                        HierarchyNodeContainer mynodes; 
    130108                                        mHierarchyInterface->CollectLeaves(node, mynodes); 
    131109 
     110                                        const int p = mRandomCandidates * RAND_MAX / (int)mynodes.size(); 
     111 
    132112                                        HierarchyNodeContainer::const_iterator nit, nit_end = mynodes.end(); 
    133113 
     114                                        int nodesTested = 0; 
    134115                                        for (nit = mynodes.begin(); nit != nit_end; ++ nit) 
    135116                                        { 
    136117                                                HierarchyNode *leaf = *nit; 
     118 
     119                                                if (rand() > p) 
     120                                                        continue; 
     121 
     122                                                ++ nodesTested; 
     123 
    137124                                                mHierarchyInterface->SetNodeVisible(leaf, false); 
    138125 
    … …  
    140127                                                mHierarchyInterface->PullUpLastVisited(leaf, mHierarchyInterface->GetFrameId()); 
    141128 
    142                                                 queryQueue.push(QueryPair(leaf,  
    143                                                         mHierarchyInterface->IssueNodeOcclusionQuery(node))); 
     129                                                const bool testGeometry =mTestGeometryForVisibleLeaves; 
     130 
     131                                                mHierarchyInterface->IssueNodeOcclusionQuery(node, mTestGeometryForVisibleLeaves); 
    144132                                        } 
    145 #endif 
     133                 
     134                                        //std::stringstream d; d << "rc: " << mRandomCandidates << " tested: " << nodesTested << " of " << (int)mynodes.size(); 
     135                                        //CullingLogManager::GetSingleton()->LogMessage(d.str()); 
     136 
    146137                                        mHierarchyInterface->RenderNodeRecursive(node); 
    147  
    148138                                        continue; 
    149139                                } 
    … …  
    153143                                        (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId() - 1); 
    154144                                         
    155  
    156145                                // if we assume node to be visible in this frame => skip query  
    157                                 const bool skipQuery = wasVisible && (mAssumedVisibility > 0) &&  
    158                                         DecideVisible(node) && mHierarchyInterface->HasGeometry(node); 
     146                                const bool skipQuery = false;//wasVisible && mHierarchyInterface->HasGeometry(node); 
    159147 
    160148                                if (skipQuery) 
    … …  
    181169                                        ++ mNumQueriesIssued; 
    182170                                         
     171                                        const bool testGeometry = wasVisible && mHierarchyInterface->IsLeaf(node) && mTestGeometryForVisibleLeaves; 
     172 
    183173                                        queryQueue.push(QueryPair(node, mHierarchyInterface-> 
    184                                                 IssueNodeOcclusionQuery(node, wasVisible))); 
     174                                                IssueNodeOcclusionQuery(node, testGeometry))); 
    185175                                } 
    186176                                 
    … …  
    196186        // update the fully visible classifications 
    197187        mHierarchyInterface->DetermineFullVisibility(mHierarchyInterface->GetHierarchyRoot()); 
    198         //mHierarchyInterface->DetermineVisibilityRatio(mHierarchyInterface->GetHierarchyRoot()); 
    199 } 
    200 //----------------------------------------------------------------------- 
    201 void RandomUpdateCullingManager::SetAssumedVisibility(const unsigned int assumedVisibility) 
    202 { 
    203         mAssumedVisibility = assumedVisibility; 
    204          
    205         mThreshold = 0; 
    206  
    207         if (mAssumedVisibility > 0) 
    208         { 
    209                 mThreshold = RAND_MAX - RAND_MAX / mAssumedVisibility; 
    210                 if (mAssumedVisibility > 100) // no random decicion 
    211                         mThreshold = RAND_MAX; 
    212         } 
    213  
    214 } 
    215 //----------------------------------------------------------------------- 
    216 inline bool RandomUpdateCullingManager::DecideVisible(HierarchyNode *node) const 
    217 { 
    218         return rand() < mThreshold; 
    219188} 
    220189//----------------------------------------------------------------------- 
    … …  
    227196        mHierarchyInterface->TraverseNode(node); 
    228197} 
     198//----------------------------------------------------------------------- 
     199void RandomUpdateCullingManager::SetTestGeometryForVisibleLeaves(const bool testGeometry) 
     200{ 
     201        mTestGeometryForVisibleLeaves = testGeometry; 
     202} 
     203//----------------------------------------------------------------------- 
     204bool RandomUpdateCullingManager::GetTestGeometryForVisibleLeaves() 
     205{ 
     206        return mTestGeometryForVisibleLeaves; 
     207} 
    229208 
    230209} // namespace GtpVisibility 

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

    r2292 r2455  
    4545                {        
    4646                        ++ mNumQueriesIssued; 
    47  
    4847                        unsigned int visiblePixels = 0; 
    49  
    50                         mHierarchyInterface->IssueNodeOcclusionQuery(node)->GetQueryResult(visiblePixels, true); 
     48                        const bool waitForResult = true; 
     49                        mHierarchyInterface->IssueNodeOcclusionQuery(node)->GetQueryResult(visiblePixels, waitForResult); 
    5150                 
    5251                        // node visible 

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

    r2289 r2455  
    4545                // delete old culling manager 
    4646                if (mCullingManager) 
    47                 { 
    4847                        delete mCullingManager; 
    49                 } 
    5048 
    5149                mCullingManagerType = ocmType; 
    … …  
    5452                { 
    5553                case VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING: 
    56                         mCullingManager = new CoherentHierarchicalCullingManager(mAssumedVisibilityForChc); 
     54                        { 
     55                                CoherentHierarchicalCullingManager *chcm = new CoherentHierarchicalCullingManager(mAssumedVisibilityForChc); 
     56                                chcm->SetTestGeometryForVisibleLeaves(mTestGeometryForVisibleLeaves); 
     57                                mCullingManager = chcm; 
     58                        } 
    5759                        break; 
    58  
    5960                case VisibilityEnvironment::FRUSTUM_CULLING: 
    6061                        mCullingManager = new FrustumCullingManager(); 
    6162                        break; 
    62  
    6363                case VisibilityEnvironment::RANDOM_UPDATE_CULLING: 
    64                         mCullingManager = new RandomUpdateCullingManager();      
     64                        { 
     65                                RandomUpdateCullingManager *rum = new RandomUpdateCullingManager(mRandomCandidatesForRuc); 
     66                                rum->SetTestGeometryForVisibleLeaves(mTestGeometryForVisibleLeaves); 
     67                                mCullingManager = rum; 
     68                        } 
    6569                        break; 
    66  
    6770                case VisibilityEnvironment::STOP_AND_WAIT_CULLING: 
    6871                        mCullingManager = new StopAndWaitCullingManager(); 
    69                         //mCullingManager = new RandomUpdateCullingManager(); 
    7072                        break; 
    71  
    7273                default: 
    7374                        mCullingManager = new CoherentHierarchicalCullingManager(mAssumedVisibilityForChc); 
    7475                        break; 
    75  
    7676                } 
    7777 
    7878                ///////// 
    7979                //-- set threshold 
     80 
    8081                mCullingManager->SetVisibilityThreshold(mVisibilityThreshold);   
    8182        } 
    … …  
    113114} 
    114115//----------------------------------------------------------------------- 
    115 void VisibilityManager::SetAssumedVisibilityForChc(unsigned int assumedVisibility)  
    116                                                                           
     116void VisibilityManager::SetAssumedVisibilityForChc(unsigned int assumedVisibility)                                                                        
    117117{ 
    118118        mAssumedVisibilityForChc = assumedVisibility; 
    119119 
    120         // in case we currently use chc 
    121         if (VisibilityManager::GetCullingManagerType() ==  
    122                 VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING) 
     120        if (mCullingManagerType == VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING) 
    123121        { 
    124122                static_cast<CoherentHierarchicalCullingManager *>(mCullingManager)-> 
    125                                 SetAssumedVisibility(assumedVisibility); 
     123                                SetAssumedVisibility(mAssumedVisibilityForChc); 
     124        } 
     125} 
     126//----------------------------------------------------------------------- 
     127void VisibilityManager::SetRandomUpdateCandidatesForRuc(unsigned int randomCandidates)                                                                    
     128{ 
     129        mRandomCandidatesForRuc = randomCandidates; 
     130 
     131        if (mCullingManagerType == VisibilityEnvironment::RANDOM_UPDATE_CULLING) 
     132        { 
     133                static_cast<RandomUpdateCullingManager *>(mCullingManager)-> 
     134                                SetRandomCandidates(mRandomCandidatesForRuc); 
    126135        } 
    127136} 
    … …  
    131140        return mVisibilityEnvironment; 
    132141} 
     142//----------------------------------------------------------------------- 
     143unsigned int VisibilityManager::GetAssumedVisibilityForChc() 
     144{ 
     145        return mAssumedVisibilityForChc; 
     146} 
     147//----------------------------------------------------------------------- 
     148unsigned int VisibilityManager::GetRandomUpdateCandidatesForRuc() 
     149{ 
     150        return mRandomCandidatesForRuc; 
     151} 
     152//----------------------------------------------------------------------- 
     153void VisibilityManager::SetTestGeometryForVisibleLeaves(bool testGeometryForVisibleLeaves) 
     154{ 
     155        mTestGeometryForVisibleLeaves = testGeometryForVisibleLeaves; 
     156 
     157        if (mCullingManagerType == VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING) 
     158        { 
     159                static_cast<CoherentHierarchicalCullingManager *>(mCullingManager)-> 
     160                                SetTestGeometryForVisibleLeaves(mTestGeometryForVisibleLeaves); 
     161        } 
     162        else if (mCullingManagerType == VisibilityEnvironment::RANDOM_UPDATE_CULLING) 
     163        { 
     164                static_cast<RandomUpdateCullingManager *>(mCullingManager)-> 
     165                                SetTestGeometryForVisibleLeaves(mTestGeometryForVisibleLeaves); 
     166        } 
     167} 
     168//----------------------------------------------------------------------- 
     169bool VisibilityManager::GetTestGeometryForVisibleLeaves() 
     170{ 
     171        return mTestGeometryForVisibleLeaves; 
     172} 
    133173 
    134174} // namespace GtpVisibility 
Note: See TracChangeset for help on using the changeset viewer.