Changeset 74 for trunk/VUT/GtpVisibility


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

added support for release mode

Location:
trunk/VUT/GtpVisibility
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/GtpVisibility/include/CoherentHierarchicalCullingManager.h

    r59 r74  
    1717{ 
    1818public: 
    19         CoherentHierarchicalCullingManager(HierarchyInterface *hierarchyInterface); 
    2019        void RenderScene(); 
    2120}; 

  • trunk/VUT/GtpVisibility/include/CullingManager.h

    r59 r74  
    1212{ 
    1313public: 
    14         /** Constructor taking a scene traverser for a specific type of hierarchy as argument.  
     14        /** Default constructor.  
     15                @remark an appropriate hierarchy interface must be provided for the algorithms to 
     16                work on specific hierarchy 
    1517        */ 
    16         CullingManager(HierarchyInterface *hierarchyInterface); 
     18        CullingManager(); 
    1719        /** Renders the scene using a specific occlusion culling algorithm, e.g., coherent 
    1820                hierarchical culling or stop and wait. 
    … …  
    2426        */ 
    2527        void SetHierarchyInterface(HierarchyInterface *hierarchyInterface); 
     28        /** Sets the threshold for the visibiliy culling algorithm. 
     29                @param visibilityThreshold number of visible pixels where an object  
     30                is still considered invisible. 
     31        */ 
     32        void SetVisibilityThreshold(unsigned int visibilityThreshold); 
     33 
     34        /** Returns number of frustum culled nodes. 
     35        */ 
     36        unsigned int GetNumFrustumCulledNodes(); 
     37        /** Returns number of occlusion query culled nodes. 
     38        */ 
     39        unsigned int GetNumQueryCulledNodes(); 
    2640 
    2741protected: 
    … …  
    2943        unsigned int mNumQueryCulledNodes; 
    3044        unsigned int mNumFrustumCulledNodes; 
     45        unsigned int mVisibilityThreshold; 
    3146 
    32         unsigned int mVisibilityThreshold; 
    3347        HierarchyInterface *mHierarchyInterface; 
    3448}; 

  • trunk/VUT/GtpVisibility/include/FrustumCullingManager.h

    r59 r74  
    1212{ 
    1313public: 
    14         FrustumCullingManager(HierarchyInterface *hierarchyInterface); 
    1514        void RenderScene(); 
    1615}; 

  • trunk/VUT/GtpVisibility/include/HierarchyInterface.h

    r65 r74  
    1919                @returns true if node is leaf 
    2020        */ 
    21     virtual bool IsLeaf(HierarchyNode *node) = 0; 
     21    virtual bool IsLeaf(HierarchyNode *node) const = 0; 
    2222        /** Traverses the given node.  
    2323                @param node the hierarchy node 
    … …  
    4141        */ 
    4242        void SetSceneRoot(HierarchyNode *root); 
    43   /** Get the root of the scene hierarchy. 
    44       @return the hierarchy root 
    45   */ 
    46   HierarchyNode *GetSceneRoot() const { 
    47     return mSceneRoot; 
    48   } 
     43    /** Get the root of the scene hierarchy. 
     44                @return the hierarchy root 
     45        */ 
     46        HierarchyNode *GetSceneRoot() const; 
    4947        /** Sets the scene root and initialises this scene traverser for a traversal. 
    5048                @param root current scene root 
    … …  
    5250        */ 
    5351        void InitFrame(HierarchyNode *root); 
    54          
    5552        /** Returns current frame id. 
    5653                @returns frame id 
    5754        */ 
    58         int GetFrameId(); 
     55        unsigned int GetFrameId() const; 
    5956        /** Returns the current distance queue. 
    6057                @returns current distance queue 
    … …  
    6663                @param node2 the second node to be compared 
    6764        */                       
    68         virtual bool HasGreaterDistance(HierarchyNode *node1, HierarchyNode *node2) = 0; 
     65        virtual bool HasGreaterDistance(HierarchyNode *node1, HierarchyNode *node2) const = 0; 
    6966        /** Checks if the node is visible from the current view frustum. 
    7067                @param node the current node 
    … …  
    7269        */ 
    7370        virtual bool CheckFrustumVisible(HierarchyNode *node, bool &intersects) = 0; 
     71        /** Checks if the node is visible from the current view frustum. 
     72                @param node the current node 
     73        */ 
     74        bool CheckFrustumVisible(HierarchyNode *node); 
    7475        /** Returns next available occlusion query or creates new one. 
    7576                @return the next occlusion query 
    … …  
    8081                @returns if the node has renderable geometry 
    8182        */ 
    82     virtual bool HasGeometry(HierarchyNode *node) = 0; 
     83    virtual bool HasGeometry(HierarchyNode *node) const = 0; 
    8384        /** Sets the visible flag for this node. 
    8485                @param node the current node 
    … …  
    8889        /** Returns true if node has the visible flag set. See set 
    8990        */ 
    90         virtual bool IsNodeVisible(HierarchyNode *node) = 0; 
     91        virtual bool IsNodeVisible(HierarchyNode *node) const = 0; 
    9192        /** Sets the last visited frame id for this node. 
    9293                @param node the current node 
    9394                @param frameId the current frame id 
    9495        */ 
    95         virtual void SetLastVisited(HierarchyNode *node, const int frameId) = 0; 
     96        virtual void SetLastVisited(HierarchyNode *node,  
     97                                                                const unsigned int frameId) = 0; 
    9698        /** Returns frame id when this node was last visited by the traverser. See set 
    9799        */ 
    98         virtual int LastVisited(HierarchyNode *node) = 0; 
     100        virtual unsigned int LastVisited(HierarchyNode *node) const = 0; 
     101        /** Returns number of traversed nodes. 
     102        */ 
     103        unsigned int GetNumTraversedNodes(); 
     104        /** Returns number of rendered nodes. 
     105        */ 
     106        unsigned int GetNumRenderedNodes(); 
    99107 
    100108protected: 
    … …  
    105113         
    106114        //--- statistics 
    107         unsigned int mNumSceneNodes; 
    108115        unsigned int mNumTraversedNodes; 
    109         unsigned int mNumRenderedGeometry; 
    110116        unsigned int mNumRenderedNodes; 
    111117 

  • trunk/VUT/GtpVisibility/include/StopAndWaitCullingManager.h

    r59 r74  
    1111{ 
    1212public: 
    13         StopAndWaitCullingManager(HierarchyInterface *hierarchyInterface); 
    1413        void RenderScene(); 
    1514}; 

  • trunk/VUT/GtpVisibility/include/VisibilityEnvironment.h

    r71 r74  
    1313        /** Different types of occlusion culling algorithms  
    1414        */ 
    15         enum CullingManagerType {FRUSTUM_CULLING, STOP_AND_WAIT, COHERENT_HIERARCHICAL_CULLING}; 
     15        enum CullingManagerType {FRUSTUM_CULLING,  
     16                                                         STOP_AND_WAIT_CULLING,  
     17                                                         COHERENT_HIERARCHICAL_CULLING,  
     18                                                         NUM_CULLING_MANAGERS}; 
    1619 
    1720        /** Loads an environment from disk. 
    … …  
    2124} // namespace GtpVisibility 
    2225 
    23 /** @}*/ // end of group Visibility 
    24  
    2526#endif // VisibilityEnvironment_H 

  • trunk/VUT/GtpVisibility/include/VisibilityManager.h

    r71 r74  
    4141        void ApplyVisibilityCulling(); 
    4242 
     43        /** Sets the threshold for the visibiliy culling algorithm. 
     44                @param visibilityThreshold number of visible pixels where an object  
     45                is still considered invisible. 
     46                @remark automatically sets the threshold of the current and of  
     47                new culling managers to this value. 
     48        */ 
     49        void SetVisibilityCullingThreshold(unsigned int threshold); 
     50 
    4351protected: 
    4452         
    … …  
    4856  VisibilityEnvironment *mVisibilityEnvironment; 
    4957  VisibilityEnvironment::CullingManagerType mCullingManagerType; 
     58 
     59  unsigned int mVisibilityThreshold; 
     60 
    5061}; 
    5162} // namespace GtpVisibility 

  • trunk/VUT/GtpVisibility/scripts/GtpVisibility.vcproj

    r71 r74  
    2020                                Name="VCCLCompilerTool" 
    2121                                Optimization="0" 
    22                                 AdditionalIncludeDirectories=""$(OGRE_PATH)/OgreMain/include";..\include" 
     22                                AdditionalIncludeDirectories=""$(OGRE_PATH)\OgreMain\include";..\include" 
    2323                                PreprocessorDefinitions="WIN32;_DEBUG;_LIB" 
    2424                                MinimalRebuild="TRUE" 
    … …  
    5555                <Configuration 
    5656                        Name="Release|Win32" 
    57                         OutputDirectory="..\bin\$(ConfigurationName)" 
     57                        OutputDirectory="..\lib\$(ConfigurationName)" 
    5858                        IntermediateDirectory="..\obj\$(ConfigurationName)" 
    5959                        ConfigurationType="4" 
    … …  
    6161                        <Tool 
    6262                                Name="VCCLCompilerTool" 
     63                                AdditionalIncludeDirectories="..\include;&quot;$(OGRE_PATH)\OgreMain\include&quot;" 
    6364                                PreprocessorDefinitions="WIN32;NDEBUG;_LIB" 
    6465                                RuntimeLibrary="2" 
    65                                 UsePrecompiledHeader="3" 
     66                                UsePrecompiledHeader="0" 
    6667                                WarningLevel="3" 
    6768                                Detect64BitPortabilityProblems="TRUE" 

  • 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.