Ignore:
Timestamp:
07/06/05 11:04:25 (20 years ago)
Author:
mattausch
Message:

removed node visibility for item buffer

Location:
trunk/VUT/GtpVisibility
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r155 r158  
    1414typedef std::pair<HierarchyNode *, OcclusionQuery *> QueryPair; 
    1515typedef std::queue<QueryPair> QueryQueue; 
    16 typedef std::stack<HierarchyNode *> TraversalStack; 
     16 
    1717 
    1818/**     Class which implements a hierarchy interface for a scene hierarchy. 
    … …  
    3333                @param node the hierarchy node 
    3434        */ 
    35         virtual void TraverseAndRenderNode(HierarchyNode *node) = 0; 
     35        virtual void TraverseNode(HierarchyNode *node) = 0; 
    3636        /** Renders current hierarchy node. 
    3737                @param node current hierarchy node to be rendered 
    … …  
    5656        */ 
    5757        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. 
     58        /** Sets the scene root and initialises this hierarchy interface for a traversal.                
    6259                @remark also resets the statistics evaluated in the last traversal 
    6360        */ 
    64         void InitTraversal(bool frontToBack = true); 
     61        void InitTraversal(); 
    6562        /** Returns current frame id. 
    6663                @returns frame id 
    … …  
    152149        virtual void RenderGeometry(GtpVisibility::Mesh *geom) = 0; 
    153150 
    154         /** Sets node id to specified value.  
    155         */ 
    156         virtual void SetNodeId(HierarchyNode *node, int id) = 0; 
    157         /** Returns id of given node.  
    158         */ 
    159         virtual int GetNodeId(HierarchyNode *node) = 0; 
    160  
     151         
    161152        /** This is an optimization when issuing the occlusion test.  
    162153                The test is done with actual geometry rather than the bounding  
    163                 box of leave nodes previously marked as visible 
     154                box of leave nodes previously marked as visible. 
     155 
    164156                @param testGeometry if this optimization should be used 
    165157                @remark this option is only useful for the coherent hierarchical culling algorithm 
    … …  
    167159        void TestGeometryForVisibleLeaves(bool testGeometry); 
    168160 
    169         /**  
    170                 Traverses hierarchy and returns next node. 
    171                 @returns next node in hierarchy. 
    172         */ 
    173         virtual HierarchyNode *GetNextNode() = 0; 
     161 
    174162 
    175163protected: 
    176164        /// chc optimization for testing geometry of leaves instead of bounding box 
    177165        bool mTestGeometryForVisibleLeaves; 
    178  
     166        /// the current frame number 
    179167        unsigned int mFrameId; 
    180  
     168        /// points to the last occlusion query in the query list 
    181169        int mCurrentTestIdx; 
    182170         
    183171        /// number of traversed nodes 
    184172        unsigned int mNumTraversedNodes; 
    185         /// the distance queue used for rendering of nodes in front to back order. 
     173 
     174        /// The queue is useful for rendering hierarchy nodes in front to back order. 
    186175        DistanceQueue *mDistanceQueue; 
    187         /// internal structure for traversal 
    188         TraversalStack *mTraversalStack; 
    189176 
    190177        /// the root of the hierarchy 
    191178        HierarchyNode *mHierarchyRoot; 
    192179         
    193         // buffer for a node pointer 
     180        /// buffer for a node pointer 
    194181        HierarchyNode *mSavedNode; 
    195  
     182        /// list of rendered hierarchy nodes (e.g., useful for exact visibility queries) 
    196183        std::vector<HierarchyNode *> mRenderedNodes; 
    197184}; 

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

    r155 r158  
    4040                        { 
    4141                                mHierarchyInterface->PullUpVisibility(node); 
    42                                 mHierarchyInterface->TraverseAndRenderNode(node); 
     42                                mHierarchyInterface->TraverseNode(node); 
    4343                        } 
    4444                        else 
    … …  
    111111                                if (wasVisible) 
    112112                                { 
    113                                         mHierarchyInterface->TraverseAndRenderNode(node); 
     113                                        mHierarchyInterface->TraverseNode(node); 
    114114                                } 
    115115                        } 
    … …  
    145145 
    146146        mHierarchyInterface->PullUpVisibility(node);                     
    147         mHierarchyInterface->TraverseAndRenderNode(node); 
     147        mHierarchyInterface->TraverseNode(node); 
    148148} 
    149149 

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

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

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

    r155 r158  
    1111{        
    1212        mDistanceQueue = new DistanceQueue(GreaterDistance<HierarchyNode *>(this)); 
    13         mTraversalStack = new std::stack<HierarchyNode *>; 
    1413} 
    1514//----------------------------------------------------------------------- 
    … …  
    1716{                
    1817        delete mDistanceQueue; 
    19         delete mTraversalStack; 
    2018} 
    2119//----------------------------------------------------------------------- 
    … …  
    2523} 
    2624//----------------------------------------------------------------------- 
    27 void HierarchyInterface::InitTraversal(bool frontToBack) 
     25void HierarchyInterface::InitTraversal() 
    2826{ 
    2927        // initialise for front-to-back rendering 
    30         if (frontToBack) 
    31         { 
    32                 ++ mFrameId; 
    33                 mCurrentTestIdx = 0; 
    34                 mNumTraversedNodes = 0; 
    35                 mRenderedNodes.clear(); 
    3628 
    37                 mDistanceQueue->push(mHierarchyRoot); 
    38         } 
    39         else 
    40         {       // initialise for simple node traversal 
    41                 mTraversalStack->push(mHierarchyRoot); 
    42         } 
     29        ++ mFrameId; 
     30        mCurrentTestIdx = 0; 
     31        mNumTraversedNodes = 0; 
     32        mRenderedNodes.clear(); 
     33 
     34        mDistanceQueue->push(mHierarchyRoot); 
    4335} 
    4436//----------------------------------------------------------------------- 

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

    r155 r158  
    3131                { 
    3232                        mHierarchyInterface->SetNodeVisible(node, true); 
    33                         mHierarchyInterface->TraverseAndRenderNode(node); 
     33                        mHierarchyInterface->TraverseNode(node); 
    3434                } 
    3535                else 
    … …  
    4545                        if (visiblePixels > mVisibilityThreshold) 
    4646                        { 
    47                                 mHierarchyInterface->TraverseAndRenderNode(node); 
     47                                mHierarchyInterface->TraverseNode(node); 
    4848                        } 
    4949                        else 
Note: See TracChangeset for help on using the changeset viewer.