Ignore:
Timestamp:
05/01/05 23:29:27 (19 years ago)
Author:
mattausch
Message:

added support for release mode

Location:
trunk/VUT/GtpVisibility/src
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r59 r74  
    33namespace GtpVisibility { 
    44 
    5 //----------------------------------------------------------------------- 
    6 CoherentHierarchicalCullingManager::CoherentHierarchicalCullingManager(HierarchyInterface *hierarchyInterface): 
    7 CullingManager(hierarchyInterface) 
    8 { 
    9 } 
    105//----------------------------------------------------------------------- 
    116void CoherentHierarchicalCullingManager::RenderScene() 
    … …  
    4641                        bool intersects = false; 
    4742 
    48                         if(!mHierarchyInterface->CheckFrustumVisible(node, intersects)) 
     43                        if (!mHierarchyInterface->CheckFrustumVisible(node, intersects)) 
    4944                        { 
    5045                                mNumFrustumCulledNodes ++; 
    51                                 continue; 
    5246                        } 
     47                        else 
     48                        { 
     49                                // if intersects near plane => skip occlusion query because wrong results possible 
     50                                if (intersects) 
     51                                { 
     52                                        // update octant's visited flag 
     53                                        mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId()); 
    5354 
    54                         // if intersects near plane => skip occlusion query because wrong results possible 
    55                         if (intersects) 
    56                         { 
    57                                 // update octant's visited flag 
     55                                        mHierarchyInterface->PullUpVisibility(node);                     
     56                                        mHierarchyInterface->TraverseNode(node); 
     57 
     58                                        continue; 
     59                                } 
     60 
     61                                // identify previously visible nodes 
     62                                bool wasVisible = mHierarchyInterface->IsNodeVisible(node) &&  
     63                                        (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId() - 1); 
     64                                 
     65                                // identify nodes that we cannot skip queries for 
     66                                bool mustQuery = !wasVisible || mHierarchyInterface->HasGeometry(node) || mHierarchyInterface->IsLeaf(node); 
     67 
     68                                // reset node's visibility classification  
     69                                mHierarchyInterface->SetNodeVisible(node, false); 
     70 
     71                                // update node's visited flag 
    5872                                mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId()); 
    59  
    60                                 mHierarchyInterface->PullUpVisibility(node);                     
    61                                 mHierarchyInterface->TraverseNode(node); 
    62  
    63                                 continue; 
    64                         } 
    65  
    66                         // identify previously visible nodes 
    67                         bool wasVisible = mHierarchyInterface->IsNodeVisible(node) &&  
    68                                 (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId() - 1); 
    69                                  
    70                         // identify nodes that we cannot skip queries for 
    71                         bool mustQuery = !wasVisible || mHierarchyInterface->HasGeometry(node) || mHierarchyInterface->IsLeaf(node); 
    72  
    73                         // reset node's visibility classification  
    74                         mHierarchyInterface->SetNodeVisible(node, false); 
    75  
    76                         // update node's visited flag 
    77                         mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId()); 
    7873                         
    79                         // skip testing previously visible interior nodes 
    80                         if (mustQuery) 
    81                         { 
    82                                 queryQueue.push(QueryPair(node, mHierarchyInterface->IssueOcclusionQuery(node))); 
    83                         } 
     74                                // skip testing previously visible interior nodes 
     75                                if (mustQuery) 
     76                                { 
     77                                        queryQueue.push(QueryPair(node, mHierarchyInterface->IssueOcclusionQuery(node))); 
     78                                } 
    8479                                         
    85                         // always traverse a node if it was visible 
    86                         if (wasVisible) 
    87                         { 
    88                                 mHierarchyInterface->TraverseNode(node); 
     80                                // always traverse a node if it was visible 
     81                                if (wasVisible) 
     82                                { 
     83                                        mHierarchyInterface->TraverseNode(node); 
     84                                } 
    8985                        } 
    9086                } 

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

    r59 r74  
    44 
    55//----------------------------------------------------------------------- 
    6 CullingManager::CullingManager(HierarchyInterface *hierarchyInterface): 
    7 mHierarchyInterface(hierarchyInterface), mVisibilityThreshold(0), mNumQueryCulledNodes(0),  
     6CullingManager::CullingManager(): 
     7mHierarchyInterface(NULL), mVisibilityThreshold(0), mNumQueryCulledNodes(0),  
    88mNumFrustumCulledNodes(0) 
    99{ 
    … …  
    1414        mHierarchyInterface = hierarchyInterface; 
    1515} 
     16//----------------------------------------------------------------------- 
     17void CullingManager::SetVisibilityThreshold(unsigned int visibilityThreshold) 
     18{ 
     19        mVisibilityThreshold = visibilityThreshold; 
     20} 
     21//----------------------------------------------------------------------- 
     22unsigned int CullingManager::GetNumFrustumCulledNodes() 
     23{ 
     24        return mNumFrustumCulledNodes; 
     25} 
     26//----------------------------------------------------------------------- 
     27unsigned int CullingManager::GetNumQueryCulledNodes() 
     28{ 
     29        return mNumQueryCulledNodes; 
     30} 
    1631} // namespace GtpVisibility 

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

    r65 r74  
    33namespace GtpVisibility { 
    44 
    5 DummyPreprocessingManager::DummyPreprocessingManager( HierarchyInterface *hierarchyInterface ) 
     5DummyPreprocessingManager::DummyPreprocessingManager(HierarchyInterface *hierarchyInterface) 
    66  :PreprocessingManager(hierarchyInterface) 
    77{ 
    … …  
    99   
    1010 
    11 bool 
    12 DummyPreprocessingManager::ExportScene(const string filename) 
     11bool DummyPreprocessingManager::ExportScene(const string filename) 
    1312{ 
    1413  ofstream s(filename.c_str()); 
    … …  
    1918   
    2019 
    21 bool 
    22 DummyPreprocessingManager::LoadPreprocessedData(const string filename) 
     20bool DummyPreprocessingManager::LoadPreprocessedData(const string filename) 
    2321{ 
    2422  // do nothing 
    … …  
    3129      Returns false if no viewcell was found. 
    3230    */ 
    33 bool 
    34 DummyPreprocessingManager::LocateViewCellIds(const Vector3 &center, 
    35                                              const float radius, 
    36                                              vector<int> *viewCellIds 
    37                                              ) 
     31bool DummyPreprocessingManager::LocateViewCellIds(const Vector3 &center, 
     32                                                                                                  const float radius, 
     33                                                                                                  vector<int> *viewCellIds) 
    3834{ 
    3935  return false; 
    … …  
    4339    Uses the specified viewcell to find its PVS 
    4440*/ 
    45 int 
    46 DummyPreprocessingManager::AddViewCellPVS(const int cellID, 
     41int DummyPreprocessingManager::AddViewCellPVS(const int cellID, 
    4742                                          InfoContainer<NodeInfo> *visibleNodes, 
    4843                                          InfoContainer<MeshInfo> *visibleMeshes ) 

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

    r59 r74  
    11#include "FrustumCullingManager.h" 
     2 
     3#include <windows.h> 
    24 
    35namespace GtpVisibility { 
    46 
    57//----------------------------------------------------------------------- 
    6 FrustumCullingManager::FrustumCullingManager(HierarchyInterface *hierarchyInterface): 
    7 CullingManager(hierarchyInterface) 
    8 { 
    9 } 
    10 //----------------------------------------------------------------------- 
    118void FrustumCullingManager::RenderScene() 
    129{ 
    1310        mNumFrustumCulledNodes = mNumQueryCulledNodes = 0; 
    14  
    15         while(!mHierarchyInterface->GetQueue()->empty()) 
     11         
     12        while (!mHierarchyInterface->GetQueue()->empty()) 
    1613        { 
    1714                HierarchyNode *node = mHierarchyInterface->GetQueue()->top(); 
    … …  
    2219                mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId()); 
    2320 
    24                 bool intersects = false; 
    25  
    26                 if(mHierarchyInterface->CheckFrustumVisible(node, intersects)) 
     21                if (!mHierarchyInterface->CheckFrustumVisible(node)) 
    2722                { 
    2823                        mNumFrustumCulledNodes ++; 
    29                         continue; 
    3024                } 
    31                  
    32                 //if intersects near plane => skip occlusion query because wrong results possible 
    33                 if(intersects) 
    34                 { 
    35             mHierarchyInterface->SetNodeVisible(node, true); 
     25                else 
     26                {                
     27                        mHierarchyInterface->SetNodeVisible(node, true); 
    3628                        mHierarchyInterface->TraverseNode(node); 
    37                         continue; 
    3829                } 
    39  
    40                 mHierarchyInterface->TraverseNode(node); 
    4130        } 
    4231} 

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

    r59 r74  
    11#include "HierarchyInterface.h" 
    22 
    3 //#include <windows.h> 
     3#include <windows.h> 
    44 
    55namespace GtpVisibility { 
    … …  
    77//----------------------------------------------------------------------- 
    88HierarchyInterface::HierarchyInterface():  
    9 mFrameId(1), mNumSceneNodes(0), mNumTraversedNodes(0),  
    10 mNumRenderedNodes(0), mSceneRoot(0), mCurrentTestIdx(0) 
     9mFrameId(0), mNumTraversedNodes(0), mNumRenderedNodes(0),  
     10mSceneRoot(0), mCurrentTestIdx(0) 
    1111{        
    1212        mDistanceQueue = new DistanceQueue(GreaterDistance<HierarchyNode *>(this)); 
    … …  
    2525void HierarchyInterface::InitFrame(HierarchyNode *root) 
    2626{ 
    27         mFrameId = 0; 
     27        mFrameId ++; 
    2828        mNumTraversedNodes = 0; 
    2929        mNumRenderedNodes = 0; 
    … …  
    3333} 
    3434//----------------------------------------------------------------------- 
    35 int HierarchyInterface::GetFrameId() 
     35unsigned int HierarchyInterface::GetFrameId() const 
    3636{ 
    3737        return mFrameId; 
    … …  
    4242        return mDistanceQueue; 
    4343} 
     44//----------------------------------------------------------------------- 
     45bool HierarchyInterface::CheckFrustumVisible(HierarchyNode *node) 
     46{ 
     47        bool intersects = false; 
     48        return CheckFrustumVisible(node, intersects); 
     49} 
     50//----------------------------------------------------------------------- 
     51HierarchyNode *HierarchyInterface::GetSceneRoot() const  
     52{ 
     53        return mSceneRoot; 
     54} 
     55//----------------------------------------------------------------------- 
     56unsigned int HierarchyInterface::GetNumTraversedNodes() 
     57{ 
     58        return mNumTraversedNodes; 
     59} 
     60//----------------------------------------------------------------------- 
     61unsigned int HierarchyInterface::GetNumRenderedNodes() 
     62{ 
     63        return mNumRenderedNodes; 
     64} 
    4465} // namespace GtpVisibility 

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

    r59 r74  
    33namespace GtpVisibility { 
    44 
    5 //----------------------------------------------------------------------- 
    6 StopAndWaitCullingManager::StopAndWaitCullingManager(HierarchyInterface *HierarchyInterface): 
    7 CullingManager(HierarchyInterface) 
    8 { 
    9 } 
    105//----------------------------------------------------------------------- 
    116void StopAndWaitCullingManager::RenderScene() 
    … …  
    2419                bool intersects = false; 
    2520 
    26                 if (mHierarchyInterface->CheckFrustumVisible(node, intersects)) 
     21                if (!mHierarchyInterface->CheckFrustumVisible(node, intersects)) 
    2722                { 
    2823                        mNumFrustumCulledNodes ++; 
    29                         continue; 
    30                 } 
    31                  
    32                 //if intersects near plane => skip occlusion query because wrong results possible 
    33                 if (intersects) 
    34                 { 
    35             mHierarchyInterface->SetNodeVisible(node, true); 
    36                         mHierarchyInterface->TraverseNode(node); 
    37                         continue; 
    38                 } 
    39  
    40                 // node visible 
    41                 if (mHierarchyInterface->IssueOcclusionQuery(node)->GetQueryResult() >  
    42                         mVisibilityThreshold) 
    43                 { 
    44                         mHierarchyInterface->TraverseNode(node); 
    4524                } 
    4625                else 
    4726                { 
    48                         mNumQueryCulledNodes ++; 
     27                        //if intersects near plane => skip occlusion query because wrong results possible 
     28                        if (intersects) 
     29                        { 
     30                    mHierarchyInterface->SetNodeVisible(node, true); 
     31                                mHierarchyInterface->TraverseNode(node); 
     32                                continue; 
     33                        } 
     34 
     35                        // node visible 
     36                        if (mHierarchyInterface->IssueOcclusionQuery(node)->GetQueryResult() >  
     37                                mVisibilityThreshold) 
     38                        { 
     39                                mHierarchyInterface->TraverseNode(node); 
     40                        } 
     41                        else 
     42                        { 
     43                                mNumQueryCulledNodes ++; 
     44                        } 
    4945                } 
    5046        } 

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

    r59 r74  
    22 
    33namespace GtpVisibility { 
    4  
     4//----------------------------------------------------------------------- 
    55VisibilityEnvironment::VisibilityEnvironment() 
    66{ 
    77} 
    8          
     8//----------------------------------------------------------------------- 
    99void VisibilityEnvironment::LoadEnvironment() 
    1010{ 

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

    r65 r74  
    77 
    88namespace GtpVisibility { 
    9  
    10 VisibilityManager::VisibilityManager(VisibilityEnvironment *visEnvironment) 
     9//----------------------------------------------------------------------- 
     10VisibilityManager::VisibilityManager(VisibilityEnvironment *visEnvironment): 
     11mVisibilityThreshold(0) 
    1112{ 
    1213        mVisibilityEnvironment = visEnvironment; 
    13         //mVisibilityManagerType = VisibilityEnvironment::STOP_AND_WAIT; 
    14         //mVisibilityManager = new StopAndWaitCullingManager(NULL); 
    15         mCullingManagerType = VisibilityEnvironment::FRUSTUM_CULLING; 
    16         mCullingManager = new FrustumCullingManager(0); 
     14         
     15        mCullingManagerType = VisibilityEnvironment::STOP_AND_WAIT_CULLING; 
     16        mCullingManager = new StopAndWaitCullingManager(); 
    1717 
    1818        mQueryManager = new DummyQueryManager(0); 
    1919        mPreprocessingManager = new DummyPreprocessingManager(0); 
    20  
    2120} 
    22  
     21//----------------------------------------------------------------------- 
    2322VisibilityManager::~VisibilityManager() 
    2423{ 
    2524        delete mCullingManager; 
    2625} 
    27  
    28 void VisibilityManager::SetCullingManager(VisibilityEnvironment::CullingManagerType ocmType) 
     26//----------------------------------------------------------------------- 
     27void VisibilityManager::SetCullingManager( 
     28        VisibilityEnvironment::CullingManagerType ocmType) 
    2929{ 
    3030        if (mCullingManagerType != ocmType) 
    … …  
    3535                switch (ocmType) 
    3636                { 
    37                 case VisibilityEnvironment::STOP_AND_WAIT: 
    38                         mCullingManager = new StopAndWaitCullingManager(NULL); 
     37                case VisibilityEnvironment::STOP_AND_WAIT_CULLING: 
     38                        mCullingManager = new StopAndWaitCullingManager(); 
    3939                        break; 
    4040 
    4141                case VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING: 
    42                         mCullingManager = new CoherentHierarchicalCullingManager(NULL); 
     42                        mCullingManager = new CoherentHierarchicalCullingManager(); 
    4343                        break; 
    4444 
    4545                case VisibilityEnvironment::FRUSTUM_CULLING: 
    46                         mCullingManager = new FrustumCullingManager(NULL); 
     46                        mCullingManager = new FrustumCullingManager(); 
    4747                        break; 
    4848                default: 
    49                         mCullingManager = new StopAndWaitCullingManager(NULL); 
     49                        mCullingManager = new StopAndWaitCullingManager(); 
    5050                        break; 
    5151                } 
    5252        } 
    5353} 
    54  
     54//----------------------------------------------------------------------- 
     55void VisibilityManager::SetVisibilityCullingThreshold(unsigned int visibilityThreshold) 
     56{ 
     57        mVisibilityThreshold = visibilityThreshold; 
     58        mCullingManager->SetVisibilityThreshold(mVisibilityThreshold); 
     59} 
     60//----------------------------------------------------------------------- 
    5561CullingManager *VisibilityManager::GetCullingManager() 
    5662{ 
    5763        return mCullingManager; 
    5864} 
    59  
     65//----------------------------------------------------------------------- 
    6066void VisibilityManager::ApplyVisibilityCulling() 
    6167{ 
    6268        mCullingManager->RenderScene(); 
    6369} 
    64  
     70//----------------------------------------------------------------------- 
    6571} // namespace GtpVisibility 
Note: See TracChangeset for help on using the changeset viewer.