Changeset 155 for trunk


Ignore:
Timestamp:
07/05/05 18:35:47 (19 years ago)
Author:
mattausch
Message:

added node traversal interface

Location:
trunk/VUT
Files:
30 edited

Legend:

Unmodified
Added
Removed

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

    r147 r155  
    1515public: 
    1616        CoherentHierarchicalCullingManager(); 
     17        /** Constructor taking the assumed visibility into account, i.e., the estimation 
     18                for how many frames the current visibility is considered to be valid 
     19        */ 
     20        CoherentHierarchicalCullingManager(const unsigned int assumedVisibility); 
     21 
    1722        void RenderScene(); 
    18         /** Sets assumed visibility which is a an estimation for e  
    19                 how many frames the visibility is considered to be valied 
     23        /** Sets assumed visibility (i.e., an estimation for  
     24                how many frames the visibility is considered to be valid). 
    2025                @param assumedVisibility indicates for how many frames the  
    2126                same visibility is be assumed. 
    … …  
    3237 
    3338        unsigned int mAssumedVisibility; 
     39         
     40        /** Skip query for this node. 
     41        */ 
     42        void SkipQuery(HierarchyNode *node); 
     43 
     44 
    3445        /** Threshold for rand function to return positive result with respect to 
    3546                mAssumedVisibility. 

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

    r154 r155  
    44#include "DistanceQueue.h" 
    55#include "VisibilityMesh.h" 
     6#include <stack> 
    67 
    78namespace GtpVisibility { 
    … …  
    1314typedef std::pair<HierarchyNode *, OcclusionQuery *> QueryPair; 
    1415typedef std::queue<QueryPair> QueryQueue; 
     16typedef std::stack<HierarchyNode *> TraversalStack; 
    1517 
    1618/**     Class which implements a hierarchy interface for a scene hierarchy. 
    … …  
    2830        */ 
    2931    virtual bool IsLeaf(HierarchyNode *node) const = 0; 
    30         /** Traverses the given node.  
     32        /** Traverses and renders the given node.  
    3133                @param node the hierarchy node 
    3234        */ 
    33         virtual void TraverseNode(HierarchyNode *node) = 0; 
     35        virtual void TraverseAndRenderNode(HierarchyNode *node) = 0; 
    3436        /** Renders current hierarchy node. 
    3537                @param node current hierarchy node to be rendered 
    … …  
    4951                @param root the hierarchy root 
    5052        */ 
    51         void SetSceneRoot(HierarchyNode *root); 
     53        void SetHierarchyRoot(HierarchyNode *root); 
    5254    /** Get the root of the scene hierarchy. 
    5355                @return the hierarchy root 
    5456        */ 
    55         HierarchyNode *GetSceneRoot() const; 
    56         /** Sets the scene root and initialises this scene traverser for a traversal. 
    57                 @param root current scene root 
    58                 @remark initialises some parameters, and also the statistics. 
    59         */ 
    60         void InitFrame(HierarchyNode *root); 
     57        HierarchyNode *GetHierarchyRoot() const; 
     58        /** Sets the scene root and initialises this hierarchy interface for a traversal. 
     59                @param frontToBack  
     60                        if traversal is initialised for front-to-back rendering or 
     61                        simple traversal of the nodes. 
     62                @remark also resets the statistics evaluated in the last traversal 
     63        */ 
     64        void InitTraversal(bool frontToBack = true); 
    6165        /** Returns current frame id. 
    6266                @returns frame id 
    6367        */ 
    6468        unsigned int GetFrameId() const; 
    65         /** Returns the current distance queue. 
    66                 @returns current distance queue 
     69        /** Returns a pointer to the distance queue. 
     70                @returns current distance queue. 
     71                @remark the distance queue stores hierarchy nodes in a front-to-back order 
    6772        */ 
    6873        DistanceQueue *GetQueue(); 
    … …  
    112117        */ 
    113118        unsigned int GetNumRenderedNodes(); 
    114         /** Optimization when issuing occlusion test: test is done with actual geometry  
    115                 rather than the bounding box 
    116                 @param useOptimization if the optimization should be used 
    117         */ 
    118         void SetUseOptimization(bool useOptimization); 
     119                 
    119120        //bool mIsShadowPass; 
    120121 
    … …  
    137138        virtual GtpVisibility::OcclusionQuery *IssueOcclusionQuery(GtpVisibility::Mesh *mesh) = 0; 
    138139 
    139         /** Returns geometry of hierarchy node.  
    140         */ 
    141         virtual void GetGeometry(GtpVisibility::HierarchyNode *node,     
     140        /** Returns the geometry of a given hierarchy node.  
     141                @param node the hierarchy node containing the geometry 
     142                @param geometryList geometry is returned in this list 
     143                @param includeChildren if the geometry of the children should be taken into account 
     144        */ 
     145        virtual void GetNodeGeometryList(GtpVisibility::HierarchyNode *node,     
    142146                                                         GeometryList *geometryList,  
    143147                                                         bool includeChildren) = 0; 
    … …  
    154158        */ 
    155159        virtual int GetNodeId(HierarchyNode *node) = 0; 
     160 
     161        /** This is an optimization when issuing the occlusion test.  
     162                The test is done with actual geometry rather than the bounding  
     163                box of leave nodes previously marked as visible 
     164                @param testGeometry if this optimization should be used 
     165                @remark this option is only useful for the coherent hierarchical culling algorithm 
     166        */ 
     167        void TestGeometryForVisibleLeaves(bool testGeometry); 
     168 
     169        /**  
     170                Traverses hierarchy and returns next node. 
     171                @returns next node in hierarchy. 
     172        */ 
     173        virtual HierarchyNode *GetNextNode() = 0; 
     174 
    156175protected: 
    157          
    158         bool mUseOptimization; 
     176        /// chc optimization for testing geometry of leaves instead of bounding box 
     177        bool mTestGeometryForVisibleLeaves; 
     178 
    159179        unsigned int mFrameId; 
    160180 
    161181        int mCurrentTestIdx; 
    162182         
    163         //--- statistics 
     183        /// number of traversed nodes 
    164184        unsigned int mNumTraversedNodes; 
    165  
     185        /// the distance queue used for rendering of nodes in front to back order. 
    166186        DistanceQueue *mDistanceQueue; 
    167         HierarchyNode *mSceneRoot; 
    168         HierarchyNode *mPreviousNode; 
     187        /// internal structure for traversal 
     188        TraversalStack *mTraversalStack; 
     189 
     190        /// the root of the hierarchy 
     191        HierarchyNode *mHierarchyRoot; 
     192         
     193        // buffer for a node pointer 
     194        HierarchyNode *mSavedNode; 
    169195 
    170196        std::vector<HierarchyNode *> mRenderedNodes; 
    171197}; 
    172198} // namespace GtpVisibility 
     199 
    173200#endif // GtpVisisibilityHierarchyInterface_H 

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

    r146 r155  
    5252        void SetVisibilityCullingThreshold(unsigned int threshold); 
    5353 
    54         /** Determines if optimization for coherent hierarchical culling is used. 
    55         */ 
    56         void SetUseChcOptimization(bool useOptimization); 
    5754        /** Indicates for how long a frame is considered to be visible. 
    5855                @param assumedVisibility estimation for how long visibility is assumed to be valid. 
     56                @remark this option is only valid for the coherent hierarchical culling algorithm 
    5957        */ 
    60         void SetAssumedVisibility(unsigned int assumedVisibility); 
     58        void SetAssumedVisibilityForChc(unsigned int assumedVisibility); 
     59         
    6160        /** Sets pointer to a query manager.  
    6261        */ 
    … …  
    7574 
    7675        unsigned int mVisibilityThreshold; 
    77         unsigned int mAssumedVisibility; 
     76        unsigned int mAssumedVisibilityForChc; 
    7877}; 
    7978} // namespace GtpVisibility 

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

    r148 r155  
    55 
    66//----------------------------------------------------------------------- 
    7 CoherentHierarchicalCullingManager:: CoherentHierarchicalCullingManager(): 
    8 mAssumedVisibility(0), mThreshold(0) 
     7CoherentHierarchicalCullingManager::CoherentHierarchicalCullingManager() 
    98{ 
    10         // initialise random generator because of assumed visibility 
     9        SetAssumedVisibility(0); 
     10        // initialise random generator in case we use assumed visibility 
     11        srand(time(NULL)); 
     12} 
     13//----------------------------------------------------------------------- 
     14CoherentHierarchicalCullingManager::CoherentHierarchicalCullingManager(const unsigned int  
     15                                                                                                                                                assumedVisibility) 
     16{ 
     17        SetAssumedVisibility(assumedVisibility); 
     18        // initialise random generator in case we use assumed visibility 
    1119        srand(time(NULL)); 
    1220} 
    … …  
    3240                        { 
    3341                                mHierarchyInterface->PullUpVisibility(node); 
    34                                 mHierarchyInterface->TraverseNode(node); 
     42                                mHierarchyInterface->TraverseAndRenderNode(node); 
    3543                        } 
    3644                        else 
    3745                        {        
    38                                 mNumQueryCulledNodes ++; 
     46                                ++ mNumQueryCulledNodes; 
    3947                                 
    4048                                if(mVisualizeCulledNodes) 
    … …  
    6270                                } 
    6371                        } 
     72                        // -- if node intersects near plane, skip query because wrong results possible 
     73                        else if (intersects) 
     74                        { 
     75                                SkipQuery(node); 
     76                        } 
    6477                        else 
    6578                        { 
    … …  
    6780                                bool wasVisible = mHierarchyInterface->IsNodeVisible(node) &&  
    6881                                        (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId() - 1); 
    69  
    70                                 // if node is assumed to be visible in this frame => skip query 
    71                                 // if intersects near plane => also skip query because wrong results possible 
    72                                 bool assumeVisible = intersects || 
    73                                         (wasVisible && (mAssumedVisibility > 0) &&  
    74                                          mHierarchyInterface->HasGeometry(node) && DecideVisible(node));         
    75  
    76                                 if (assumeVisible) 
     82                                         
     83                                // if we assume node to be visible in this frame => skip query  
     84                                if (wasVisible && (mAssumedVisibility > 0) &&  DecideVisible(node))// && mHierarchyInterface->HasGeometry(node)) 
    7785                                { 
    78                                         // update node's visited flag 
    79                                         mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId()); 
    80  
    81                                         mHierarchyInterface->PullUpVisibility(node);                     
    82                                         mHierarchyInterface->TraverseNode(node); 
     86                                        SkipQuery(node); 
    8387 
    8488                                        continue; 
    … …  
    107111                                if (wasVisible) 
    108112                                { 
    109                                         mHierarchyInterface->TraverseNode(node); 
     113                                        mHierarchyInterface->TraverseAndRenderNode(node); 
    110114                                } 
    111115                        } 
    … …  
    129133bool CoherentHierarchicalCullingManager::DecideVisible(HierarchyNode *node) const 
    130134{ 
    131         /*bool result = rand() < mThreshold; 
    132         std::stringstream d; d << "Assumed vis: " << mAssumedVisibility << ", result: " << result; 
     135        /*bool result = rand() < mThreshold; std::stringstream d; d << "Assumed vis: " << mAssumedVisibility << ", result: " << result; 
    133136        Ogre::LogManager::getSingleton().logMessage(d.str()); return result;*/ 
    134137         
    135138        return rand() < mThreshold; 
    136139} 
     140//----------------------------------------------------------------------- 
     141void CoherentHierarchicalCullingManager::SkipQuery(HierarchyNode *node) 
     142{ 
     143        // -- set node to be visible in this frame, then traverse it 
     144        mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId()); 
     145 
     146        mHierarchyInterface->PullUpVisibility(node);                     
     147        mHierarchyInterface->TraverseAndRenderNode(node); 
     148} 
     149 
    137150} // namespace GtpVisibility 

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

    r144 r155  
    1313                                             bool relativeVisibility) 
    1414  { 
    15           visibleNodes->push_back(NodeInfo(mHierarchyInterface->GetSceneRoot(), 0, 0)); 
     15          visibleNodes->push_back(NodeInfo(mHierarchyInterface->GetHierarchyRoot(), 0, 0)); 
    1616     
    1717//      HierarchyInterface::MeshIterator *mi = 
    … …  
    3131                                                bool relativeVisibility) 
    3232  { 
    33           visibleNodes->push_back(NodeInfo(mHierarchyInterface->GetSceneRoot(), 0, 0)); 
     33          visibleNodes->push_back(NodeInfo(mHierarchyInterface->GetHierarchyRoot(), 0, 0)); 
    3434     
    3535//      HierarchyInterface::MeshIterator *mi = 

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

    r147 r155  
    2828                {                
    2929                        mHierarchyInterface->SetNodeVisible(node, true); 
    30                         mHierarchyInterface->TraverseNode(node); 
     30                        mHierarchyInterface->TraverseAndRenderNode(node); 
    3131                } 
    3232        } 

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

    r130 r155  
    77//----------------------------------------------------------------------- 
    88HierarchyInterface::HierarchyInterface():  
    9 mFrameId(0), mNumTraversedNodes(0), mSceneRoot(0),  
    10 mPreviousNode(0), mCurrentTestIdx(0), mUseOptimization(false) 
    11 //, mIsShadowPass(false) 
     9mFrameId(0), mNumTraversedNodes(0), mHierarchyRoot(NULL),  
     10mSavedNode(NULL), mCurrentTestIdx(0), mTestGeometryForVisibleLeaves(false) 
    1211{        
    1312        mDistanceQueue = new DistanceQueue(GreaterDistance<HierarchyNode *>(this)); 
     13        mTraversalStack = new std::stack<HierarchyNode *>; 
    1414} 
    1515//----------------------------------------------------------------------- 
    … …  
    1717{                
    1818        delete mDistanceQueue; 
     19        delete mTraversalStack; 
    1920} 
    2021//----------------------------------------------------------------------- 
    21 void HierarchyInterface::SetSceneRoot(HierarchyNode *root) 
     22void HierarchyInterface::SetHierarchyRoot(HierarchyNode *root) 
    2223{ 
    23         mSceneRoot = root; 
     24        mHierarchyRoot = root; 
    2425} 
    2526//----------------------------------------------------------------------- 
    26 void HierarchyInterface::InitFrame(HierarchyNode *root) 
     27void HierarchyInterface::InitTraversal(bool frontToBack) 
    2728{ 
    28         ++ mFrameId; 
    29         mCurrentTestIdx = 0; 
    30         mNumTraversedNodes = 0; 
    31         mRenderedNodes.clear(); 
     29        // initialise for front-to-back rendering 
     30        if (frontToBack) 
     31        { 
     32                ++ mFrameId; 
     33                mCurrentTestIdx = 0; 
     34                mNumTraversedNodes = 0; 
     35                mRenderedNodes.clear(); 
    3236 
    33         SetSceneRoot(root); 
    34         mDistanceQueue->push(mSceneRoot); 
     37                mDistanceQueue->push(mHierarchyRoot); 
     38        } 
     39        else 
     40        {       // initialise for simple node traversal 
     41                mTraversalStack->push(mHierarchyRoot); 
     42        } 
    3543} 
    3644//----------------------------------------------------------------------- 
    … …  
    5159} 
    5260//----------------------------------------------------------------------- 
    53 HierarchyNode *HierarchyInterface::GetSceneRoot() const  
     61HierarchyNode *HierarchyInterface::GetHierarchyRoot() const 
    5462{ 
    55         return mSceneRoot; 
     63        return mHierarchyRoot; 
    5664} 
    5765//----------------------------------------------------------------------- 
    … …  
    6674} 
    6775//----------------------------------------------------------------------- 
    68 void HierarchyInterface::SetUseOptimization(bool useOptimization) 
     76void HierarchyInterface::TestGeometryForVisibleLeaves(bool testGeometry) 
    6977{ 
    70         mUseOptimization = useOptimization; 
     78        mTestGeometryForVisibleLeaves = testGeometry; 
    7179} 
    7280//----------------------------------------------------------------------- 
    … …  
    7583        return &mRenderedNodes; 
    7684} 
    77  
    7885} // namespace GtpVisibility 

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

    r139 r155  
    2727                        } 
    2828                } 
     29                // if intersects near plane => skip occlusion query because wrong results possible 
     30                else if (intersects) 
     31                { 
     32                        mHierarchyInterface->SetNodeVisible(node, true); 
     33                        mHierarchyInterface->TraverseAndRenderNode(node); 
     34                } 
    2935                else 
    3036                { 
    31                         // if intersects near plane => skip occlusion query because wrong results possible 
    32                         if (intersects) 
    33                         { 
    34                     mHierarchyInterface->SetNodeVisible(node, true); 
    35                                 mHierarchyInterface->TraverseNode(node); 
    36                                 continue; 
    37                         } 
    3837 
    3938                        ++ mNumQueriesIssued; 
    … …  
    4645                        if (visiblePixels > mVisibilityThreshold) 
    4746                        { 
    48                                 mHierarchyInterface->TraverseNode(node); 
     47                                mHierarchyInterface->TraverseAndRenderNode(node); 
    4948                        } 
    5049                        else 

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

    r153 r155  
    1414mPreprocessingManager(new DummyPreprocessingManager(NULL)), 
    1515mVisibilityEnvironment(visEnvironment), 
    16 mAssumedVisibility(0) 
     16mAssumedVisibilityForChc(0) 
    1717{ 
    1818        SetCullingManager(VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING); 
    … …  
    2727} 
    2828//----------------------------------------------------------------------- 
    29 void VisibilityManager::SetCullingManager( 
    30         VisibilityEnvironment::CullingManagerType ocmType) 
     29void VisibilityManager::SetCullingManager(VisibilityEnvironment:: 
     30                                                                                  CullingManagerType ocmType) 
    3131{ 
    3232        // change only if necessary 
    … …  
    3838                        delete mCullingManager; 
    3939                } 
     40 
    4041                mCullingManagerType = ocmType; 
    4142                 
    … …  
    4748 
    4849                case VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING: 
    49                         mCullingManager = new CoherentHierarchicalCullingManager(); 
    50                         dynamic_cast<CoherentHierarchicalCullingManager *>(mCullingManager)-> 
    51                                 SetAssumedVisibility(mAssumedVisibility); 
     50                        mCullingManager = new CoherentHierarchicalCullingManager(mAssumedVisibilityForChc); 
    5251                        break; 
    5352 
    … …  
    9897} 
    9998//----------------------------------------------------------------------- 
    100 void VisibilityManager::SetAssumedVisibility(unsigned int assumedVisibility) 
     99void VisibilityManager::SetAssumedVisibilityForChc(unsigned int assumedVisibility)  
     100                                                                          
    101101{ 
    102         mAssumedVisibility = assumedVisibility; 
     102        mAssumedVisibilityForChc = assumedVisibility; 
    103103 
     104        // in case we currently use chc 
    104105        if (VisibilityManager::GetCullingManagerType() ==  
    105106                VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING) 
    106107        { 
    107108                dynamic_cast<CoherentHierarchicalCullingManager *>(mCullingManager)-> 
    108                                 SetAssumedVisibility(mAssumedVisibility); 
     109                                SetAssumedVisibility(assumedVisibility); 
    109110        } 
    110111} 
     112 
     113 
    111114} // namespace GtpVisibility 

  • trunk/VUT/Ogre/include/OgreBspHierarchyInterface.h

    r154 r155  
    2222        /** Traverses given node. 
    2323                @param node current node 
    24                 @remark pushes children on distance queue 
     24                @remark pushes children on the distance queue 
    2525        */ 
    26         void TraverseNode(GtpVisibility::HierarchyNode *node); 
     26        void TraverseAndRenderNode(GtpVisibility::HierarchyNode *node); 
    2727        void RenderNode(GtpVisibility::HierarchyNode *node); 
    2828        bool IsLeaf(GtpVisibility::HierarchyNode *node) const; 

  • trunk/VUT/Ogre/include/OgreOctreeHierarchyInterface.h

    r154 r155  
    2929        /** Traverses given node. 
    3030                @param node current node 
    31                 @remark pushes children on distance queue 
     31                @remark pushes children on a distance queue. 
    3232        */ 
    33         void TraverseNode(GtpVisibility::HierarchyNode *node); 
     33        void TraverseAndRenderNode(GtpVisibility::HierarchyNode *node); 
    3434        void RenderNode(GtpVisibility::HierarchyNode *node); 
    3535        bool IsLeaf(GtpVisibility::HierarchyNode *node) const; 
    … …  
    4646                                                         GtpVisibility::CullingType type); 
    4747 
    48         /*bool FindVisibleObjects(GtpVisibility::HierarchyNode *node,    
    49                                                         InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,  
    50                                                         bool includeChildren = false);*/ 
    51  
    52         void GetGeometry(GtpVisibility::HierarchyNode *node, 
     48        void GetNodeGeometryList(GtpVisibility::HierarchyNode *node, 
    5349                                         GtpVisibility::GeometryList *geometryList,  
    5450                                         bool includeChildren); 
    … …  
    5753         
    5854        int GetNodeId(GtpVisibility::HierarchyNode *node); 
     55 
     56        GtpVisibility::HierarchyNode *GetNextNode(); 
    5957 
    6058protected: 
    … …  
    6967        */ 
    7068        Real GetSquaredViewDepth(const Camera* cam, const AxisAlignedBox* box) const; 
     69 
     70        int mCurrentOctreePosition; 
    7171}; 
    7272} // namespace Ogre 

  • trunk/VUT/Ogre/include/OgrePlatformHierarchyInterface.h

    r139 r155  
    4747                @remark This is a convenience method which resets the stats,  
    4848                                sets the current camera, and initialises the distance queue. 
    49                 @param root root of the hierarchy 
    5049                @param cam the actual camera definding the view frustum 
    5150                @param cullCam the camera used for culling.  
    52                 @remark If null, the actual camera is used for both viewing and culling          
     51                @remark If cullCam is null, the actual camera is used for both viewing and culling               
    5352        */ 
    54         void InitFrame(GtpVisibility::HierarchyNode *root, Camera *cam, Camera *cullCam = NULL,  
    55                 int leavePassesInQueue = 0); 
     53        void InitTraversal(Camera *cam, Camera *cullCam = NULL, int leavePassesInQueue = 0); 
    5654        /** Checks if the node is visible from the current view frustum. 
    5755                @param node the current node 
    … …  
    9593        /** see set  
    9694        */ 
    97         bool GetUseOptimization(); 
     95        bool GetTestGeometryForVisibleLeaves(); 
    9896        /** see set 
    9997        */ 

  • trunk/VUT/Ogre/include/OgreSceneNodeHierarchyInterface.h

    r154 r155  
    2424        bool IsLeaf(GtpVisibility::HierarchyNode *node) const; 
    2525         
    26         void TraverseNode(GtpVisibility::HierarchyNode *node); 
     26        void TraverseAndRenderNode(GtpVisibility::HierarchyNode *node); 
    2727        void RenderNode(GtpVisibility::HierarchyNode *node); 
    2828        void PullUpVisibility(GtpVisibility::HierarchyNode *node); 
    … …  
    4646                                                        bool includeChildren = false);*/ 
    4747         
    48         void GetGeometry(GtpVisibility::HierarchyNode *node,     
     48        void GetNodeGeometryList(GtpVisibility::HierarchyNode *node,     
    4949                                         GtpVisibility::GeometryList *geometryList,  
    5050                                         bool includeChildren); 
    … …  
    5353         
    5454        int GetNodeId(GtpVisibility::HierarchyNode *node); 
     55 
     56        GtpVisibility::HierarchyNode *GetNextNode(); 
    5557}; 
    5658 

  • trunk/VUT/Ogre/include/OgreVisibilityTerrainSceneManager.h

    r153 r155  
    122122        int mLeavePassesInQueue; 
    123123        ShadowTechnique mSavedShadowTechnique; 
     124 
     125        bool mRenderOnlyBoundingBoxes; 
    124126}; 
    125127 

  • trunk/VUT/Ogre/resources/VisibilityDemo.overlay

    r147 r155  
    2222                left 5  
    2323                top 5 
    24                 width 400 
     24                width 430 
    2525                height 90 
    2626                material Core/StatsBlockCenter 
    … …  
    4646                element TextArea(Example/Visibility/AlgorithmInfo): Example/Visibility/Templates/BasicText 
    4747                { 
    48                         left 170 
     48                        left 210 
    4949                        top 5 
    50                         width 90 
     50                        width 120 
    5151                        height 30 
    5252                        caption : 
    … …  
    5757                        left 5 
    5858                        top 20 
    59                         width 90 
     59                        width 120 
    6060                        height 30 
    6161                        caption [-][+] Threshold 
    … …  
    6363                element TextArea(Example/Visibility/ThresholdInfo): Example/Visibility/Templates/BasicText 
    6464                { 
    65                         left 170 
     65                        left 210 
    6666                        top 20 
    67                         width 90 
    68                         height 30 
    69                         caption : 
    70                 } 
    71                 element TextArea(Example/Visibility/UseOptimization): Example/Visibility/Templates/BasicText 
     67                        width 120 
     68                        height 30 
     69                        caption : 
     70                } 
     71                element TextArea(Example/Visibility/TestGeometryForVisibleLeaves): Example/Visibility/Templates/BasicText 
    7272                { 
    7373                        left 5 
    7474                        top 35 
    75                         width 90 
    76                         height 30 
    77                         caption [O] Optimization 
    78                 } 
    79                 element TextArea(Example/Visibility/UseOptimizationInfo): Example/Visibility/Templates/BasicText 
    80                 { 
    81                         left 170 
     75                        width 120 
     76                        height 30 
     77                        caption [G] Test Geometry For Leaves 
     78                } 
     79                element TextArea(Example/Visibility/TestGeometryForVisibleLeavesInfo): Example/Visibility/Templates/BasicText 
     80                { 
     81                        left 210 
    8282                        top 35 
    83                         width 90 
     83                        width 120 
    8484                        height 30 
    8585                        caption : 
    … …  
    8989                        left 5 
    9090                        top 50 
    91                         width 90 
     91                        width 120 
    9292                        height 30 
    9393                        caption [X] Depth pass 
    … …  
    9595                element TextArea(Example/Visibility/UseDepthPassInfo): Example/Visibility/Templates/BasicText 
    9696                { 
    97                         left 170 
     97                        left 210 
    9898                        top 50 
    99                         width 90 
     99                        width 120 
    100100                        height 30 
    101101                        caption : 
    … …  
    105105                        left 5 
    106106                        top 65 
    107                         width 90 
     107                        width 120 
    108108                        height 30 
    109109                        caption [8][9] Assumed Visibility 
    … …  
    112112                element TextArea(Example/Visibility/AssumedVisibilityInfo): Example/Visibility/Templates/BasicText 
    113113                { 
    114                         left 170 
     114                        left 210 
    115115                        top 65 
    116                         width 90 
     116                        width 120 
    117117                        height 30 
    118118                        caption : 
    … …  
    128128                top 5 
    129129                width 320 
    130                 height 120 
     130                height 150 
    131131                material Core/StatsBlockCenter 
    132132                border_size 1 1 1 1 
    … …  
    249249                        left 180 
    250250                        top 95 
     251                        width 90 
     252                        font_name TrebuchetMSBold 
     253                        caption :                        
     254                }                
     255                element TextArea(Example/Visibility/DelayedQueriesIssued): Example/Visibility/Templates/BasicText 
     256                { 
     257                        left 5 
     258                        top 110 
     259                        width 180 
     260                        height 30 
     261                        caption Avg. queries issued  
     262                }        
     263                element TextArea(Example/Visibility/DelayedQueriesIssuedInfo): Example/Visibility/Templates/BasicText 
     264                { 
     265                        left 180 
     266                        top 110 
     267                        width 90 
     268                        font_name TrebuchetMSBold 
     269                        caption :                        
     270                }                
     271                element TextArea(Example/Visibility/DelayedTraversedNodes): Example/Visibility/Templates/BasicText 
     272                { 
     273                        left 5 
     274                        top 125 
     275                        width 180 
     276                        height 30 
     277                        caption Avg. traversed Nodes 
     278                }        
     279                element TextArea(Example/Visibility/DelayedTraversedNodesInfo): Example/Visibility/Templates/BasicText 
     280                { 
     281                        left 180 
     282                        top 125 
    251283                        width 90 
    252284                        font_name TrebuchetMSBold 

  • trunk/VUT/Ogre/src/OgreBspHierarchyInterface.cpp

    r87 r155  
    1212} 
    1313//----------------------------------------------------------------------- 
    14 void BspHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node) 
     14void BspHierarchyInterface::TraverseAndRenderNode(GtpVisibility::HierarchyNode *node) 
    1515{ 
    1616} 

  • trunk/VUT/Ogre/src/OgreItemBufferQueryManager.cpp

    r154 r155  
    3232        SceneManager *sm = pfHierarchyInterface->GetSceneManager(); 
    3333 
    34         //-- Render scene as item buffer (e.g., color coded objects) 
     34        // ---- Render scene as item buffer (i.e., objects with their id as color codes) 
    3535 
    3636        // const_cast allowed because camera is not changed in renderScene 
    … …  
    4949        mViewport->setBackgroundColour(ColourValue(0, 0, 0, 0)); 
    5050 
    51         //pfHierarchyInterface->GetRenderSystem()->clearFrameBuffer(FBT_COLOUR); 
    52         // render item buffer 
     51 
     52        // --- render item buffer 
    5353        pfHierarchyInterface->GetSceneManager()->_renderScene(pCam, mViewport, false); 
    5454         
     55 
     56 
    5557        // reset old overlay status 
    5658        mViewport->setOverlaysEnabled(overlayEnabled); 
    … …  
    8486                        ((*visibleGeometry)[id]).AddVisibility(1, 1); 
    8587                } 
    86                 /*else {        std::stringstream d;  
    87                         d << "adding pixel to geometry with id: " << id << ", buf 1: " << (int)buf[idx] << ", buf 2: " << (int)buf[idx + 1] << ", buf 3: " << (int)buf[idx + 2]; 
    88                         LogManager::getSingleton().logMessage(d.str()); }*/ 
    8988        } 
    9089 
    … …  
    101100                return; 
    102101 
     102 
    103103        mWasInitialised = true; 
    104104 
    105         SceneManager::EntityIterator it =  
    106                 dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface)-> 
    107                 GetSceneManager()->getEntityIterator(); 
     105        SceneManager *sm =  
     106                dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->GetSceneManager(); 
     107 
     108        SceneManager::EntityIterator it = sm->getEntityIterator(); 
    108109 
    109110        // TODO: make this more efficient 
    … …  
    115116                visibleGeometry->push_back(GtpVisibility::MeshInfo(it.getNext(), 0, 0)); 
    116117        } 
     118 
     119        // -- initialise hierarchy interface for simple node traversal 
     120        mHierarchyInterface->InitTraversal(false); 
     121 
     122        GtpVisibility::HierarchyNode *node = NULL; 
     123         
     124        while (node = mHierarchyInterface->GetNextNode()) 
     125        { 
     126                visibleNodes->push_back(GtpVisibility::NodeInfo(node, 0, 0)); 
     127        } 
    117128} 
     129 
    118130} // namespace Ogre 

  • trunk/VUT/Ogre/src/OgreOcclusionQueriesQueryManager.cpp

    r154 r155  
    8383                        if (i == 0) 
    8484                        { 
    85                                 mHierarchyInterface->GetGeometry(*nodeIt, &geometryList, false); 
     85                                mHierarchyInterface->GetNodeGeometryList(*nodeIt, &geometryList, false); 
    8686                        } 
    8787                } 
    … …  
    105105        mViewport->setOverlaysEnabled(overlayEnabled); 
    106106 
    107         //---- collect results 
     107        // ---- collect results 
    108108        GtpVisibility::QueryList::iterator visQueryIt, projQueryIt; 
    109109 
    … …  
    135135        } 
    136136 
    137         //---- queries for geometry 
     137        // ---- queries for geometry 
    138138        geometryIt_end = geometryList.end(); 
    139139         
    … …  
    154154                ++visQueryIt; 
    155155 
    156                 // approximate depth ordering during rendering =>  
     156                // WARNING: approximate depth ordering during rendering =>  
    157157                // geometry maybe occluded 
    158158                if (visiblePixels > 0) 

  • trunk/VUT/Ogre/src/OgreOctreeHierarchyInterface.cpp

    r154 r155  
    1010//----------------------------------------------------------------------- 
    1111OctreeHierarchyInterface::OctreeHierarchyInterface(OctreeSceneManager *sm, RenderSystem *rsys):  
    12 SceneNodeHierarchyInterface(sm, rsys) 
    13 { 
    14 } 
    15 //----------------------------------------------------------------------- 
    16 void OctreeHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node) 
     12SceneNodeHierarchyInterface(sm, rsys), mCurrentOctreePosition(0) 
     13{ 
     14} 
     15//----------------------------------------------------------------------- 
     16void OctreeHierarchyInterface::TraverseAndRenderNode(GtpVisibility::HierarchyNode *node) 
    1717{ 
    1818        ++ mNumTraversedNodes; 
    … …  
    8484        Octree *octant = static_cast<Octree *>(node); 
    8585 
    86         while(octant && !octant->isOctreeVisible()) 
     86        while (octant && !octant->isOctreeVisible()) 
    8787        { 
    8888                octant->setOctreeVisible(true); 
    … …  
    129129AxisAlignedBox *OctreeHierarchyInterface::GetBoundingBox(GtpVisibility::HierarchyNode *node) 
    130130{ 
    131         if (node != mPreviousNode)       
    132         { 
    133                 mPreviousNode = node; 
     131        if (node != mSavedNode) 
     132        { 
     133                mSavedNode = node; 
    134134            //static_cast<Octree *>(node)->_getCullBounds(&mBox); 
    135135                mBox = static_cast<Octree *>(node)->_getWorldAABB(); 
    136                 //std::stringstream d; d << mBox;LogManager::getSingleton().logMessage(d.str());  
    137136        } 
    138137 
    … …  
    157156} 
    158157//----------------------------------------------------------------------- 
    159 void OctreeHierarchyInterface::GetGeometry(GtpVisibility::HierarchyNode *node,   
     158void OctreeHierarchyInterface::GetNodeGeometryList(GtpVisibility::HierarchyNode *node,   
    160159                                                                                   GtpVisibility::GeometryList *geometryList,  
    161160                                                                                   bool includeChildren) 
    … …  
    166165        for (nodeIt = static_cast<Octree *>(node)->mNodes.begin(); nodeIt != nodeIt_end; ++nodeIt) 
    167166        { 
    168                 SceneNodeHierarchyInterface::GetGeometry(*nodeIt, geometryList, includeChildren); 
     167                SceneNodeHierarchyInterface::GetNodeGeometryList(*nodeIt, geometryList, includeChildren); 
    169168        } 
    170169} 
    … …  
    180179} 
    181180//----------------------------------------------------------------------- 
    182 /*bool OctreeHierarchyInterface::FindVisibleObjects(GtpVisibility::HierarchyNode *node,  
    183                                                                         InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,  
    184                                                                         bool includeChildren) 
    185 { 
    186         bool foundVisible = false; 
    187  
    188         PlatformOcclusionQuery query(mRenderSystem); 
    189  
    190         NodeList *nodes = &static_cast<Octree *>(node)->mNodes; 
     181GtpVisibility::HierarchyNode *OctreeHierarchyInterface::GetNextNode() 
     182{ 
     183        if (mTraversalStack->empty()) 
     184                return NULL; 
    191185         
    192         NodeList::const_iterator nodeIt = nodes->begin(), nodeIt_end; 
    193          
    194         nodeIt_end = nodes->end(); 
    195  
    196         while (nodeIt != nodeIt_end) 
    197         { 
    198                 OctreeNode *octreeNode = (*nodeIt); 
    199                 if (SceneNodeHierarchyInterface::FindVisibleObjects(octreeNode, visibleGeometry, includeChildren)) 
     186        Octree *octree = static_cast<Octree *>(mTraversalStack->top()); 
     187        mTraversalStack->pop(); 
     188                 
     189        for(int i=0; i<8; ++i) 
     190        { 
     191                Octree *nextChild =  
     192                        octree->mChildren[(i & 4) >> 2][(i & 2) >> 1][i & 1]; 
     193 
     194                if (nextChild) 
    200195                { 
    201                         foundVisible = true; 
     196                        mTraversalStack->push(nextChild); 
    202197                } 
    203                 ++nodeIt; 
    204         } 
    205  
    206         return foundVisible; 
    207 }*/ 
    208  
     198        } 
     199 
     200        return octree; 
     201}  
     202                 
    209203} // namespace Ogre 

  • trunk/VUT/Ogre/src/OgrePlatformHierarchyInterface.cpp

    r139 r155  
    130130} 
    131131//----------------------------------------------------------------------- 
    132 void PlatformHierarchyInterface::InitFrame(GtpVisibility::HierarchyNode *root,  
    133                                                                                    Camera *cam, Camera *cullCam, int leavePassesInQueue) 
    134 { 
    135         GtpVisibility::HierarchyInterface::InitFrame(root); 
    136          
    137         mPreviousNode = NULL; 
     132void PlatformHierarchyInterface::InitTraversal(Camera *cam, Camera *cullCam, int leavePassesInQueue) 
     133{ 
     134        GtpVisibility::HierarchyInterface::InitTraversal(); 
     135         
     136        mSavedNode = NULL; 
    138137        mLeavePassesInQueue = leavePassesInQueue; 
    139138 
    … …  
    178177        // If camera for culling is different from camera for rendering or only solids  
    179178        // will be rendereded => cannot optimize 
    180         if (mUseOptimization && (mCamera == mCullCamera) && wasVisible && IsLeaf(node))  
     179        if (mTestGeometryForVisibleLeaves && (mCamera == mCullCamera) && wasVisible && IsLeaf(node))  
    181180        { 
    182181                //LogManager::getSingleton().logMessage("render node\n"); 
    … …  
    253252} 
    254253//----------------------------------------------------------------------- 
    255 bool PlatformHierarchyInterface::GetUseOptimization() 
    256 { 
    257         return mUseOptimization; 
     254bool PlatformHierarchyInterface::GetTestGeometryForVisibleLeaves() 
     255{ 
     256        return mTestGeometryForVisibleLeaves; 
    258257} 
    259258//----------------------------------------------------------------------- 

  • trunk/VUT/Ogre/src/OgreSceneNodeHierarchyInterface.cpp

    r154 r155  
    1717} 
    1818//----------------------------------------------------------------------- 
    19 void SceneNodeHierarchyInterface::TraverseNode(GtpVisibility::HierarchyNode *node) 
     19void SceneNodeHierarchyInterface::TraverseAndRenderNode(GtpVisibility::HierarchyNode *node) 
    2020{ 
    2121        ++ mNumTraversedNodes; 
    … …  
    121121{ 
    122122        // only create renderable bounding box for new node 
    123         if (node != mPreviousNode) 
     123        if (node != mSavedNode) 
    124124        { 
    125                 mPreviousNode = node; 
     125                mSavedNode = node; 
    126126                mBox = static_cast<SceneNode *>(node)->_getWorldAABB(); 
    127127        } 
    … …  
    136136} 
    137137//----------------------------------------------------------------------- 
    138 void SceneNodeHierarchyInterface::GetGeometry(GtpVisibility::HierarchyNode *node,        
     138void SceneNodeHierarchyInterface::GetNodeGeometryList(GtpVisibility::HierarchyNode *node,        
    139139                                                                                          GtpVisibility::GeometryList *geometryList,  
    140140                                                                                          bool includeChildren) 
    … …  
    151151                { 
    152152                        Entity *ent = static_cast<Entity *>(movable); 
    153                         //std::stringstream d; d << "ent " << ent->getName(); LogManager::getSingleton().logMessage(d.str()); 
     153                        //std::stringstream d; d << "ent " << ent->getName();  
     154                        //LogManager::getSingleton().logMessage(d.str()); 
    154155                        geometryList->push_back(ent); 
    155156                } 
    … …  
    166167        return static_cast<SceneNode *>(node)->getId(); 
    167168} 
     169//----------------------------------------------------------------------- 
     170GtpVisibility::HierarchyNode *SceneNodeHierarchyInterface::GetNextNode() 
     171{ 
     172        if (mTraversalStack->empty()) 
     173                return NULL; 
     174         
     175        SceneNode *node = static_cast<SceneNode *>(mTraversalStack->top()); 
     176        mTraversalStack->pop(); 
     177 
     178        // internal node: add children to priority queue for further processing 
     179        Node::ChildNodeIterator it = node->getChildIterator(); 
     180                                 
     181        while (it.hasMoreElements())                     
     182        {  
     183                mTraversalStack->push(it.getNext()); 
     184        } 
     185 
     186        return node; 
     187}  
    168188} // namespace Ogre      

  • trunk/VUT/Ogre/src/OgreVisibilityOctreeSceneManager.cpp

    r154 r155  
    184184        bool leaveTransparentsInQueue = mDelayRenderTransparents && !mUseDepthPass; 
    185185 
     186    // -- initialise interface for rendering traversal of the hierarchy 
     187        mHierarchyInterface->SetHierarchyRoot(mOctree); 
     188         
    186189        // possible two cameras (one for culling, one for rendering) 
    187         mHierarchyInterface->InitFrame(mOctree, mCameraInProgress,  
     190        mHierarchyInterface->InitTraversal(mCameraInProgress,  
    188191                                                        mCullCamera ? getCamera("CullCamera") : NULL, 
    189192                                                        leaveTransparentsInQueue); 
     193                 
    190194 
    191195        // reset culling manager stats 
    … …  
    352356        d << "Depth pass: " << StringConverter::toString(mUseDepthPass) << ", " 
    353357          << "Delay transparents: " << StringConverter::toString(mDelayRenderTransparents) << ", " 
    354           << "Use optimization: " << StringConverter::toString(mHierarchyInterface->GetUseOptimization()) << ", " 
     358          << "Use optimization: " << StringConverter::toString(mHierarchyInterface->GetTestGeometryForVisibleLeaves()) << ", " 
    355359          << "Algorithm type: " << mVisibilityManager->GetCullingManagerType() << "\n" 
    356360          << "Hierarchy nodes: " << mNumOctreeNodes << ", "  

  • trunk/VUT/Ogre/src/OgreVisibilityOptionsManager.cpp

    r146 r155  
    2626        if (key == "AssumedVisibility") 
    2727        { 
    28                 mVisibilityManager->SetAssumedVisibility(*static_cast<const int *>(val)); 
     28                mVisibilityManager->SetAssumedVisibilityForChc(*static_cast<const int *>(val)); 
    2929                return true; 
    3030        } 
    31         if (key == "UseOptimization") 
     31        if (key == "TestGeometryForVisibleLeaves") 
    3232        { 
    33                 mHierarchyInterface->SetUseOptimization(*static_cast<const bool *>(val)); 
     33                mHierarchyInterface->TestGeometryForVisibleLeaves(*static_cast<const bool *>(val)); 
    3434                return true; 
    3535        } 

  • trunk/VUT/Ogre/src/OgreVisibilitySceneManager.cpp

    r139 r155  
    4040        if (!mShowVisualization) 
    4141        { 
    42                 // two cameras (one for culling, one for rendering) 
    43                 mHierarchyInterface->InitFrame(mSceneRoot, mCameraInProgress); 
     42                mHierarchyInterface->SetHierarchyRoot(mSceneRoot); 
     43                mHierarchyInterface->InitTraversal(mCameraInProgress); 
    4444 
    4545                // reset culling manager stats 

  • trunk/VUT/Ogre/src/OgreVisibilityTerrainSceneManager.cpp

    r154 r155  
    3030mEnableDepthWrite(true), 
    3131mSkipTransparents(false), 
    32 mSavedShadowTechnique(SHADOWTYPE_NONE) 
     32mSavedShadowTechnique(SHADOWTYPE_NONE), 
     33mRenderOnlyBoundingBoxes(false) 
    3334{ 
    3435        mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem); 
    … …  
    126127                        if (mRenderNodesForViz) 
    127128                        { 
    128                                 OctreeNode *node = *it;  
    129                                 if ((node->numAttachedObjects() > 0) && (node->numChildren() == 0) 
    130                                         && node->getAttachedObject(0)->getMovableType() == "Entity") 
    131                                 getRenderQueue()->addRenderable(node); 
     129                                if (((*it)->numAttachedObjects() > 0) && ((*it)->numChildren() == 0) 
     130                                        && (*it)->getAttachedObject(0)->getMovableType() == "Entity") 
     131                                getRenderQueue()->addRenderable((*it)); 
    132132 
    133133                                // addbounding boxes instead of node itself 
    … …  
    213213                PrepareVisualization(cam); 
    214214        } 
    215         else 
     215        else if (mRenderOnlyBoundingBoxes) 
     216        { 
     217        } 
     218        else  
    216219        {        
    217220                // for hierarchical culling, we interleave identification  
    218221                // and rendering of objects in _renderVisibibleObjects 
    219222 
    220                 // only for the shadow pass we use standard rendering 
     223                // for the shadow pass we use only standard rendering 
     224                // because of low occlusion 
    221225                if (mShadowTechnique == SHADOWTYPE_TEXTURE_MODULATIVE &&  
    222226                        mIlluminationStage == IRS_RENDER_TO_TEXTURE) 
    … …  
    225229                } 
    226230                // only shadow casters will be rendered in shadow texture pass 
    227                 //mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters); 
     231                // mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters); 
    228232        } 
    229233        //TerrainSceneManager::_findVisibleObjects(cam, onlyShadowCasters); 
    … …  
    236240void VisibilityTerrainSceneManager::_renderVisibleObjects() 
    237241{ 
     242        // save ambient light to reset later 
    238243        ColourValue savedAmbient = mAmbientLight; 
    239244 
    240         // visualization or shadow pass: apply standard rendering 
    241         if (mShowVisualization || (mShadowTechnique == SHADOWTYPE_TEXTURE_MODULATIVE &&  
    242                 mIlluminationStage == IRS_RENDER_TO_TEXTURE)) 
     245        // --- apply standard rendering for some cases  
     246    // e.g., visualization, shadow pass 
     247 
     248        if (mShowVisualization || mRenderOnlyBoundingBoxes || 
     249           (mShadowTechnique == SHADOWTYPE_TEXTURE_MODULATIVE && mIlluminationStage == IRS_RENDER_TO_TEXTURE)) 
    243250        {        
    244251                IlluminationRenderStage savedStage = mIlluminationStage;  
    245252         
    246253                if (mShowVisualization)  
    247                         // disable illumination stage so we have no shadows in visualization 
     254                        // disable illumination stage because we want no shadows in visualization 
    248255                        mIlluminationStage = IRS_NONE; 
    249256 
    … …  
    455462        d << "Depth pass: " << StringConverter::toString(mUseDepthPass) << ", " 
    456463          << "Delay transparents: " << StringConverter::toString(mDelayRenderTransparents) << ", " 
    457           << "Use optimization: " << StringConverter::toString(mHierarchyInterface->GetUseOptimization()) << ", " 
     464          << "Use optimization: " << StringConverter::toString(mHierarchyInterface->GetTestGeometryForVisibleLeaves()) << ", " 
    458465          << "Algorithm type: " << mVisibilityManager->GetCullingManagerType() << ", " 
    459466          << "Hierarchy nodes: " << mNumOctreeNodes << ", "  
    … …  
    699706                (mLeavePassesInQueue & RenderPriorityGroup::TRANSPARENT_PASSES); 
    700707 
     708        // -- initialise interface for rendering traversal of the hierarchy 
     709        mHierarchyInterface->SetHierarchyRoot(mOctree); 
     710         
    701711        // possible two cameras (one for culling, one for rendering) 
    702         mHierarchyInterface->InitFrame(mOctree, cam,  
    703                                                 mCullCamera ? getCamera("CullCamera") : NULL, 
    704                                                 mLeavePassesInQueue); 
     712        mHierarchyInterface->InitTraversal(mCameraInProgress,  
     713                                                        mCullCamera ? getCamera("CullCamera") : NULL, 
     714                                                        mLeavePassesInQueue); 
    705715                 
    706716        //std::stringstream d; d << "leave passes in queue: " << mLeavePassesInQueue;LogManager::getSingleton().logMessage(d.str()); 

  • trunk/VUT/work/TestCulling/TestCullingApplication.cpp

    r139 r155  
    112112mShowOctree(false), 
    113113mUseDepthPass(false), 
    114 mUseOptimization(true), 
     114mTestGeometryForVisibleLeaves(true), 
    115115mShowVisualization(false), 
    116116mVisualizeCulledNodes(false) 
    … …  
    137137        mRenderedNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/RenderedNodesInfo"); 
    138138        mObjectsInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/ObjectsInfo"); 
    139         mUseOptimizationInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/UseOptimizationInfo"); 
     139        mTestGeometryForVisibleLeavesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/TestGeometryForVisibleLeavesInfo"); 
    140140        mQueriesIssuedInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/QueriesIssuedInfo"); 
     141         
    141142 
    142143        mAlgorithmInfo->setCaption(": " + mCurrentAlgorithmCaptions[mCurrentAlgorithm]); 
    … …  
    148149        mRenderedNodesInfo->setCaption(": 0"); 
    149150        mObjectsInfo->setCaption(": 0"); 
    150         mUseOptimizationInfo->setCaption(": true"); 
     151        mTestGeometryForVisibleLeavesInfo->setCaption(": true"); 
    151152        mQueriesIssuedInfo->setCaption(": 0"); 
     153         
    152154 
    153155        setAlgorithm(mCurrentAlgorithm); 
    154156         
    155         mSceneMgr->setOption("UseOptimization", &mUseOptimization); 
     157        mSceneMgr->setOption("TestGeometryForVisibleLeaves", &mTestGeometryForVisibleLeaves); 
    156158        mSceneMgr->setOption("UseDepthPass", &mUseDepthPass); 
    157159        mSceneMgr->setOption("ShowVizualisation", &mShowVisualization); 
    … …  
    236238        KEY_PRESSED(KC_SUBTRACT, 0, changeThreshold(-10)); 
    237239        KEY_PRESSED(KC_ADD, 0, changeThreshold(10)); 
    238         KEY_PRESSED(KC_O, 0.3, toggleUseOptimization()); 
     240        KEY_PRESSED(KC_O, 0.3, toggleTestGeometryForVisibleLeaves()); 
    239241        KEY_PRESSED(KC_C, 0.3, toggleUseDepthPass()); 
    240242        KEY_PRESSED(KC_V, 0.3, toggleShowViz()); 
    … …  
    264266} 
    265267//----------------------------------------------------------------------- 
    266 void TerrainFrameListener::toggleUseOptimization() 
    267 { 
    268         mUseOptimization = !mUseOptimization; 
    269  
    270         mSceneMgr->setOption("UseOptimization", &mUseOptimization); 
    271  
    272         if(mUseOptimization) 
    273                 mUseOptimizationInfo->setCaption(": true"); 
     268void TerrainFrameListener::toggleTestGeometryForVisibleLeaves() 
     269{ 
     270        mTestGeometryForVisibleLeaves = !mTestGeometryForVisibleLeaves; 
     271 
     272        mSceneMgr->setOption("TestGeometryForVisibleLeaves", &mTestGeometryForVisibleLeaves); 
     273 
     274        if(mTestGeometryForVisibleLeaves) 
     275                mTestGeometryForVisibleLeavesInfo->setCaption(": true"); 
    274276        else 
    275                 mUseOptimizationInfo->setCaption(": false"); 
     277                mTestGeometryForVisibleLeavesInfo->setCaption(": false"); 
    276278} 
    277279//----------------------------------------------------------------------- 

  • trunk/VUT/work/TestCulling/TestCullingApplication.h

    r133 r155  
    6464        void changeThreshold(int incr); 
    6565        void updateStats(); 
    66         void toggleUseOptimization(); 
     66        void toggleTestGeometryForVisibleLeaves(); 
    6767        void toggleShowOctree(); 
    6868        void toggleUseDepthPass(); 
    … …  
    8787        OverlayElement *mRenderedNodesInfo; 
    8888        OverlayElement *mObjectsInfo; 
    89         OverlayElement *mUseOptimizationInfo; 
     89        OverlayElement *mTestGeometryForVisibleLeavesInfo; 
    9090        OverlayElement *mQueriesIssuedInfo; 
    9191 
    9292        SceneContentGenerator *mSceneContentGenerator; 
    9393 
    94         bool mUseOptimization; 
     94        bool mTestGeometryForVisibleLeaves; 
    9595        bool mShowOctree; 
    9696        bool mUseDepthPass; 

  • trunk/VUT/work/TestCullingTerrain/TerrainFrameListener.cpp

    r154 r155  
    8989mShowOctree(false), 
    9090mUseDepthPass(false), 
    91 mUseOptimization(true), 
     91mTestGeometryForVisibleLeaves(true), 
    9292mShowVisualization(false), 
    9393mCullCamera(false), 
    … …  
    101101mShowQueryStats(false), 
    102102mQueryManager(NULL), 
    103 mVisibilityManager(NULL) 
     103mVisibilityManager(NULL), 
     104mDelayedQueriesIssued(0.0), 
     105mDelayedTraversedNodes(0.0) 
    104106{ 
    105107        //mInputDevice = PlatformManager::getSingleton().createInputReader(); 
    … …  
    129131        mAlgorithmInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/AlgorithmInfo"); 
    130132        mThresholdInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/ThresholdInfo"); 
    131         mUseOptimizationInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/UseOptimizationInfo"); 
     133        mTestGeometryForVisibleLeavesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/TestGeometryForVisibleLeavesInfo"); 
    132134        mUseDepthPassInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/UseDepthPassInfo"); 
    133135        mAssumedVisibilityInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/AssumedVisibilityInfo"); 
    … …  
    140142        mObjectsInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/ObjectsInfo"); 
    141143        mQueriesIssuedInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/QueriesIssuedInfo"); 
    142          
     144        mDelayedQueriesIssuedInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/DelayedQueriesIssuedInfo"); 
     145        mDelayedTraversedNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/DelayedTraversedNodesInfo"); 
     146 
    143147        mAlgorithmInfo->setCaption(": " + currentAlgorithmCaptions[mCurrentAlgorithm]); 
    144148        mThresholdInfo->setCaption(": 0"); 
    … …  
    149153        mRenderedNodesInfo->setCaption(": 0"); 
    150154        mObjectsInfo->setCaption(": 0"); 
    151         mUseOptimizationInfo->setCaption(": true"); 
     155        mTestGeometryForVisibleLeavesInfo->setCaption(": true"); 
    152156        mUseDepthPassInfo->setCaption(": false"); 
    153157        mQueriesIssuedInfo->setCaption(": 0"); 
    154158        mAssumedVisibilityInfo->setCaption(": 0"); 
    155  
     159        mDelayedQueriesIssuedInfo->setCaption(": 0"); 
     160        mDelayedTraversedNodesInfo->setCaption(": 0"); 
    156161 
    157162        //-- visibility query stats overlay 
    … …  
    170175 
    171176        // set scene manager options 
    172         mSceneMgr->setOption("UseOptimization", &mUseOptimization); 
     177        mSceneMgr->setOption("TestGeometryForVisibleLeaves", &mTestGeometryForVisibleLeaves); 
    173178 
    174179        // apply delayed rendering (i.e., transparents after hierarchical culling pass) 
    175180        // only if optimization is not used  
    176         bool delayRenderTransparents = !mUseOptimization; 
     181        bool delayRenderTransparents = !mTestGeometryForVisibleLeaves; 
    177182 
    178183        mSceneMgr->setOption("DelayRenderTransparents", &delayRenderTransparents); 
    … …  
    736741                mSceneMgr->getOption("NumFrustumCulledNodes", &opt); sprintf(str,": %d", opt);  
    737742                mFrustumCulledNodesInfo->setCaption(str); 
    738          
    739                 mSceneMgr->getOption("NumQueriesIssued", &opt); sprintf(str,": %d", opt);  
     743 
     744                // delay so there is no jump 
     745                mSceneMgr->getOption("NumQueriesIssued", &opt);  
     746                sprintf(str,": %d", (int)opt);  
    740747                mQueriesIssuedInfo->setCaption(str); 
    741748 
    … …  
    754761                sprintf(str,": %d", mTerrainContentGenerator->GetObjectCount());  
    755762                mObjectsInfo->setCaption(str); 
     763 
     764                // delay so there is no jump 
     765                mSceneMgr->getOption("NumQueriesIssued", &opt);  
     766                mDelayedQueriesIssued = mDelayedQueriesIssued * 0.8 + (float)opt * 0.2; 
     767                sprintf(str,": %d", (int)mDelayedQueriesIssued);  
     768                mDelayedQueriesIssuedInfo->setCaption(str); 
     769 
     770                mSceneMgr->getOption("NumTraversedNodes", &opt);  
     771                mDelayedTraversedNodes = mDelayedTraversedNodes * 0.8 + (float)opt * 0.2; 
     772                sprintf(str,": %d", (int)mDelayedTraversedNodes);  
     773                mDelayedTraversedNodesInfo->setCaption(str); 
     774 
    756775        } 
    757776        catch (...) 
    … …  
    761780} 
    762781//----------------------------------------------------------------------- 
    763 void TerrainFrameListener::toggleUseOptimization() 
    764 { 
    765         mUseOptimization = !mUseOptimization; 
    766         mSceneMgr->setOption("UseOptimization", &mUseOptimization); 
     782void TerrainFrameListener::toggleTestGeometryForVisibleLeaves() 
     783{ 
     784        mTestGeometryForVisibleLeaves = !mTestGeometryForVisibleLeaves; 
     785        mSceneMgr->setOption("TestGeometryForVisibleLeaves", &mTestGeometryForVisibleLeaves); 
    767786         
    768787        // disable optimization which tests geometry instead of aabb 
    769788        // for delayed rendering (i.e., render transparents after all the solids) 
    770789        // because otherwise visible transparents could be skipped 
    771         bool delayedRendering = !mUseOptimization; 
     790        bool delayedRendering = !mTestGeometryForVisibleLeaves; 
     791 
    772792        mSceneMgr->setOption("DelayRenderTransparents", &delayedRendering); 
    773793 
    774         if (mUseOptimization) 
    775         { 
    776                 mUseOptimizationInfo->setCaption(": true"); 
     794        if (mTestGeometryForVisibleLeaves) 
     795        { 
     796                mTestGeometryForVisibleLeavesInfo->setCaption(": true"); 
    777797        } 
    778798        else 
    779799        { 
    780                 mUseOptimizationInfo->setCaption(": false"); 
     800                mTestGeometryForVisibleLeavesInfo->setCaption(": false"); 
    781801        } 
    782802} 
    … …  
    898918                toggleDisplayCameraDetails(); 
    899919                break; 
    900         case KC_O: 
    901                 toggleUseOptimization(); 
     920        case KC_G: 
     921                toggleTestGeometryForVisibleLeaves(); 
    902922                break; 
    903923        case KC_T: 

  • trunk/VUT/work/TestCullingTerrain/TerrainFrameListener.h

    r154 r155  
    109109    void changeThreshold(int incr); 
    110110        void changeAssumedVisibility(int incr); 
    111         void toggleUseOptimization(); 
     111        void toggleTestGeometryForVisibleLeaves(); 
    112112        void toggleShowOctree(); 
    113113        void toggleUseDepthPass(); 
    … …  
    159159    OverlayElement *mTraversedNodesInfo; 
    160160        OverlayElement *mHierarchyNodesInfo; 
    161         OverlayElement *mUseOptimizationInfo; 
     161        OverlayElement *mTestGeometryForVisibleLeavesInfo; 
    162162        OverlayElement *mUseDepthPassInfo; 
    163163        OverlayElement *mRenderedNodesInfo; 
    164164        OverlayElement *mObjectsInfo; 
    165165        OverlayElement *mQueriesIssuedInfo; 
     166        OverlayElement *mDelayedQueriesIssuedInfo; 
     167        OverlayElement *mDelayedTraversedNodesInfo; 
    166168 
    167169        OverlayElement *mQueryTypeInfo; 
    … …  
    175177        TerrainContentGenerator *mTerrainContentGenerator; 
    176178 
    177         bool mUseOptimization; 
     179        bool mTestGeometryForVisibleLeaves; 
    178180        bool mShowOctree; 
    179181        bool mUseDepthPass; 
    … …  
    236238        //bool mUseBufferedInputKeys, mUseBufferedInputMouse, mInputTypeSwitchingOn; 
    237239        PlatformQueryManager *mQueryManager; 
     240 
     241        float mDelayedQueriesIssued; 
     242        float mDelayedTraversedNodes; 
    238243}; 
    239244 

  • trunk/VUT/work/TestCullingTerrain/TestCullingTerrainApplication.cpp

    r150 r155  
    162162 
    163163                // the objects are generated on the whole terrain 
    164                 //mTerrainContentGenerator->GenerateScene(1500, "robot"); 
    165                 mTerrainContentGenerator->GenerateScene(1500, "athene"); 
     164                mTerrainContentGenerator->GenerateScene(1500, "robot"); 
     165                //mTerrainContentGenerator->GenerateScene(1500, "athene"); 
    166166                //mTerrainContentGenerator->GenerateScene(500, "ninja"); 
    167167        } 
Note: See TracChangeset for help on using the changeset viewer.