Changeset 345


Ignore:
Timestamp:
10/21/05 19:53:30 (19 years ago)
Author:
mattausch
Message:

fixed bug in chc when traversing node two times because of priority queue. left debug info in there

Location:
trunk/VUT
Files:
16 edited

Legend:

Unmodified
Added
Removed

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

    r155 r345  
    2727                if 0, the visibility is tested deterministically for each frame. 
    2828        */ 
    29         void SetAssumedVisibility(unsigned int assumedVisibility); 
     29        void SetAssumedVisibility(const unsigned int assumedVisibility); 
    3030 
    3131protected: 
    … …  
    4040        /** Skip query for this node. 
    4141        */ 
    42         void SkipQuery(HierarchyNode *node); 
     42        void SkipQuery(HierarchyNode *node) const; 
    4343 
    4444 

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

    r175 r345  
    4242                @param node the current node  
    4343        */ 
    44         virtual void PullUpVisibility(HierarchyNode *node) = 0; 
     44        virtual void PullUpVisibility(HierarchyNode *node) const = 0; 
    4545        /** Issue a occlusion query for this node.  
    4646                @param node the current hierarchy node 
    … …  
    9696                @param visible the visible flag 
    9797        */ 
    98         virtual void SetNodeVisible(HierarchyNode *node, const bool visible) = 0; 
     98        virtual void SetNodeVisible(HierarchyNode *node, const bool visible) const = 0; 
    9999        /** Returns true if node has the visible flag set. See set 
    100100        */ 
    … …  
    105105        */ 
    106106        virtual void SetLastVisited(HierarchyNode *node,  
    107                                                                 const unsigned int frameId) = 0; 
     107                                                                const unsigned int frameId) const = 0; 
    108108        /** Returns frame id when this node was last visited by the traverser. See set 
    109109        */ 
    … …  
    122122        */ 
    123123        virtual void VisualizeCulledNode(HierarchyNode *node,  
    124                 CullingType type) = NULL; 
     124                CullingType type) const = 0; 
    125125 
    126126        /** Returns vector of visible hierarchy nodes from previous render. 

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

    r343 r345  
    2525        unsigned int visiblePixels = 0; 
    2626        bool isAvailable = false; 
    27         //Ogre::LogManager::getSingleton().logMessage("Coherent Hierarchical Culling"); 
     27        Ogre::LogManager::getSingleton().logMessage("Coherent Hierarchical Culling\n"); 
    2828 
    2929        //-- PART 1: process finished occlusion queries 
    … …  
    3737                         
    3838                        queryQueue.pop(); 
     39 
     40                        std::stringstream d2; d2 << "fetch node from query queue " << node; 
     41                        Ogre::LogManager::getSingleton().logMessage(d2.str()); 
    3942 
    4043                        if (visiblePixels > mVisibilityThreshold) 
    … …  
    6063                        mHierarchyInterface->GetQueue()->pop(); 
    6164                                 
     65                        std::stringstream d2; d2 << "fetch node from hierarchy queue " << node; 
     66                        Ogre::LogManager::getSingleton().logMessage(d2.str()); 
     67 
    6268                        bool intersects = false; 
    6369 
    … …  
    8187                                bool wasVisible = mHierarchyInterface->IsNodeVisible(node) &&  
    8288                                        (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId() - 1); 
    83                                          
     89                                if (mHierarchyInterface->LastVisited(node) == mHierarchyInterface->GetFrameId()) 
     90                                { 
     91                                std::stringstream d2; d2 << "!!!!lastVisited: " << mHierarchyInterface->LastVisited(node) << " " << node; 
     92                                Ogre::LogManager::getSingleton().logMessage(d2.str()); 
     93                                std::stringstream d; d << "!!!!!frameid: " << mHierarchyInterface->GetFrameId() << " " << node << "\n"; 
     94                                Ogre::LogManager::getSingleton().logMessage(d.str()); 
     95                                } 
    8496                                // if we assume node to be visible in this frame => skip query  
    8597                                // TODO: check this (not the expected speed up) 
    … …  
    93105                // identify nodes that we cannot skip queries for 
    94106                                // geometry not only in leaves => test for renderable geometry 
    95                                 bool issueQuery = !wasVisible || mHierarchyInterface->HasGeometry(node); 
    96                                                                  
     107                                bool issueQuery = (mHierarchyInterface->LastVisited(node) != mHierarchyInterface->GetFrameId()) 
     108                                                && (!wasVisible || mHierarchyInterface->HasGeometry(node)); 
     109                                                         
    97110                                // reset node's visibility classification 
    98111                                mHierarchyInterface->SetNodeVisible(node, false); 
    … …  
    100113                                // update node's visited flag 
    101114                                mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId()); 
    102                          
     115 
     116                                std::stringstream d2; d2 << "lastVisited: " << mHierarchyInterface->LastVisited(node) << " " << node; 
     117                                Ogre::LogManager::getSingleton().logMessage(d2.str()); 
     118 
    103119                                // skip testing previously visible nodes without geometry 
    104120                                if (issueQuery) 
    … …  
    113129                                if (wasVisible) 
    114130                                { 
     131                                                std::stringstream d2; d2 << "traversing node " << node; 
     132                                        Ogre::LogManager::getSingleton().logMessage(d2.str()); 
    115133                                        mHierarchyInterface->TraverseNode(node); 
    116134                                } 
    … …  
    120138} 
    121139//----------------------------------------------------------------------- 
    122 void CoherentHierarchicalCullingManager::SetAssumedVisibility(unsigned int assumedVisibility) 
     140void CoherentHierarchicalCullingManager::SetAssumedVisibility(const unsigned int assumedVisibility) 
    123141{ 
    124142        mAssumedVisibility = assumedVisibility; 
    … …  
    133151} 
    134152//----------------------------------------------------------------------- 
    135 bool CoherentHierarchicalCullingManager::DecideVisible(HierarchyNode *node) const 
     153inline bool CoherentHierarchicalCullingManager::DecideVisible(HierarchyNode *node) const 
    136154{ 
    137         /*bool result = rand() < mThreshold; std::stringstream d; d << "Assumed vis: " << mAssumedVisibility << ", result: " << result; 
    138         Ogre::LogManager::getSingleton().logMessage(d.str()); return result;*/ 
     155        //bool result = rand() < mThreshold; std::stringstream d; d << "Assumed vis: " << mAssumedVisibility << ", result: " << result; 
     156        //Ogre::LogManager::getSingleton().logMessage(d.str()); return result; 
    139157         
    140158        return rand() < mThreshold; 
    141159} 
    142160//----------------------------------------------------------------------- 
    143 void CoherentHierarchicalCullingManager::SkipQuery(HierarchyNode *node) 
     161inline void CoherentHierarchicalCullingManager::SkipQuery(HierarchyNode *node) const 
    144162{ 
    145163        // -- set node to be visible in this frame, then traverse it 
     164        std::stringstream d2; d2 << "skipping node " << node; 
     165                                        Ogre::LogManager::getSingleton().logMessage(d2.str()); 
    146166        mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId()); 
    147  
     167         
     168        mHierarchyInterface->SetNodeVisible(node, true); 
    148169        mHierarchyInterface->PullUpVisibility(node);                     
    149170        mHierarchyInterface->TraverseNode(node); 

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

    r259 r345  
    1818 
    1919                bool intersects = false; 
    20  
     20         
     21                //if (mHierarchyInterface->HasGeometry(node) && (!mHierarchyInterface->IsLeaf(node))) ++ mNumFrustumCulledNodes; 
     22                                //      Ogre::LogManager::getSingleton().logMessage("no geometry"); 
     23                        //else if (!mHierarchyInterface->IsLeaf(node)) ++ mNumQueriesIssued;//  Ogre::LogManager::getSingleton().logMessage("has geometry"); 
     24/*if (!mHierarchyInterface->HasGeometry(node)) 
     25                                        Ogre::LogManager::getSingleton().logMessage("no geometry"); 
     26                                else    Ogre::LogManager::getSingleton().logMessage("has geometry");*/ 
    2127                if (!mHierarchyInterface->CheckFrustumVisible(node, intersects)) 
    2228                { 
    … …  
    3642                else 
    3743                { 
    38  
    3944                        ++ mNumQueriesIssued; 
    4045 

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

    r158 r345  
    1919        //bool getOption( const String &, void * ); 
    2020        //bool getOptionKeys( StringVector &refKeys ); 
    21         void PullUpVisibility(GtpVisibility::HierarchyNode *node); 
     21        void PullUpVisibility(GtpVisibility::HierarchyNode *node) const; 
    2222        /** Traverses given node. 
    2323                @param node current node 
    … …  
    3030        float GetSquaredDistance(GtpVisibility::HierarchyNode *node) const; 
    3131         
    32         void SetNodeVisible(GtpVisibility::HierarchyNode *node, const bool visible); 
     32        void SetNodeVisible(GtpVisibility::HierarchyNode *node, const bool visible) const; 
    3333        void SetLastVisited(GtpVisibility::HierarchyNode *node,  
    34                                                 const unsigned int frameId); 
     34                                                const unsigned int frameId) const; 
    3535 
    3636        bool IsNodeVisible(GtpVisibility::HierarchyNode *node) const; 

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

    r174 r345  
    2525                See setOption 
    2626        */ 
    27         void PullUpVisibility(GtpVisibility::HierarchyNode *node); 
     27        void PullUpVisibility(GtpVisibility::HierarchyNode *node) const; 
    2828         
    2929        /** Traverses and renders the given node. 
    … …  
    3838        float GetSquaredDistance(GtpVisibility::HierarchyNode *node) const; 
    3939         
    40         void SetNodeVisible(GtpVisibility::HierarchyNode *node, const bool visible); 
    41         void SetLastVisited(GtpVisibility::HierarchyNode *node, const unsigned int frameId); 
     40        void SetNodeVisible(GtpVisibility::HierarchyNode *node, const bool visible) const; 
     41        void SetLastVisited(GtpVisibility::HierarchyNode *node, const unsigned int frameId) const; 
    4242 
    4343        bool IsNodeVisible(GtpVisibility::HierarchyNode *node) const; 
    … …  
    4545 
    4646        void VisualizeCulledNode(GtpVisibility::HierarchyNode *node,  
    47                                                          GtpVisibility::CullingType type); 
     47                                                         GtpVisibility::CullingType type) const; 
    4848 
    4949        void GetNodeGeometryList(GtpVisibility::HierarchyNode *node, 

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

    r158 r345  
    2626        void TraverseNode(GtpVisibility::HierarchyNode *node); 
    2727        void RenderNode(GtpVisibility::HierarchyNode *node); 
    28         void PullUpVisibility(GtpVisibility::HierarchyNode *node); 
     28        void PullUpVisibility(GtpVisibility::HierarchyNode *node) const; 
    2929        bool HasGeometry(GtpVisibility::HierarchyNode *node) const; 
    3030        float GetSquaredDistance(GtpVisibility::HierarchyNode *node) const; 
    3131 
    32         void SetNodeVisible(GtpVisibility::HierarchyNode *node, const bool visible); 
     32        void SetNodeVisible(GtpVisibility::HierarchyNode *node, const bool visible) const; 
    3333        void SetLastVisited(GtpVisibility::HierarchyNode *node,  
    34                                                 const unsigned int frameId); 
     34                                                const unsigned int frameId) const; 
    3535 
    3636        bool IsNodeVisible(GtpVisibility::HierarchyNode *node) const; 
    … …  
    4040 
    4141        void VisualizeCulledNode(GtpVisibility::HierarchyNode *node,  
    42                                                         GtpVisibility::CullingType type); 
     42                                                        GtpVisibility::CullingType type) const; 
    4343         
    4444        void GetNodeGeometryList(GtpVisibility::HierarchyNode *node,     

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

    r158 r345  
    3232//----------------------------------------------------------------------- 
    3333void BspHierarchyInterface::SetNodeVisible(GtpVisibility::HierarchyNode *node,  
    34                                                                                    const bool visible) 
     34                                                                                   const bool visible) const 
    3535{ 
    3636} 
    3737//----------------------------------------------------------------------- 
    3838void BspHierarchyInterface::SetLastVisited(GtpVisibility::HierarchyNode *node,  
    39                                                                                    const unsigned int frameId) 
     39                                                                                   const unsigned int frameId) const 
    4040{ 
    4141} 
    4242//----------------------------------------------------------------------- 
    43 void BspHierarchyInterface::PullUpVisibility(GtpVisibility::HierarchyNode *node) 
     43void BspHierarchyInterface::PullUpVisibility(GtpVisibility::HierarchyNode *node) const 
    4444{                
    4545} 

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

    r343 r345  
    3333                        Octree *nextChild =  
    3434                                octree->mChildren[(i & 4) >> 2][(i & 2) >> 1][i & 1]; 
    35  
     35                         
    3636                        if (nextChild) 
    3737                        { 
     38                                        std::stringstream d2; d2 << "pushing node " << nextChild; 
     39                                        Ogre::LogManager::getSingleton().logMessage(d2.str()); 
    3840                                mDistanceQueue->push(nextChild); 
    3941                        } 
    … …  
    5759{ 
    5860        AxisAlignedBox *box = &static_cast<Octree *>(node)->mBox; 
    59         Vector3 mid = ((box->getMaximum() - box->getMinimum()) * 0.5) + box->getMinimum(); 
    60  
    61         return (mCullCamera->getDerivedPosition() - mid).squaredLength(); 
     61        Vector3 pos = ((box->getMaximum() - box->getMinimum()) * 0.5) + box->getMinimum(); 
     62         
     63        return (mCullCamera->getDerivedPosition() - pos).squaredLength(); 
    6264} 
    6365//----------------------------------------------------------------------- 
    6466void OctreeHierarchyInterface::SetNodeVisible(GtpVisibility::HierarchyNode *node,  
    65                                                                                           const bool visible) 
     67                                                                                          const bool visible) const 
    6668{ 
    6769#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    … …  
    7173//----------------------------------------------------------------------- 
    7274void OctreeHierarchyInterface::SetLastVisited(GtpVisibility::HierarchyNode *node,  
    73                                                                                           const unsigned int frameId) 
     75                                                                                          const unsigned int frameId) const 
    7476{ 
    7577#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    … …  
    7880} 
    7981//----------------------------------------------------------------------- 
    80 void OctreeHierarchyInterface::PullUpVisibility(GtpVisibility::HierarchyNode *node) 
     82void OctreeHierarchyInterface::PullUpVisibility(GtpVisibility::HierarchyNode *node) const 
    8183{                
    8284#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    … …  
    140142//----------------------------------------------------------------------- 
    141143void OctreeHierarchyInterface::VisualizeCulledNode(GtpVisibility::HierarchyNode *node,  
    142                                                                                                    GtpVisibility::CullingType type) 
     144                                                                                                   GtpVisibility::CullingType type) const 
    143145{ 
    144146        WireBoundingBox *box = static_cast<Octree *>(node)->getWireBoundingBox(); 

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

    r174 r345  
    6262} 
    6363//----------------------------------------------------------------------- 
    64 void SceneNodeHierarchyInterface::PullUpVisibility(GtpVisibility::HierarchyNode *node) 
     64void SceneNodeHierarchyInterface::PullUpVisibility(GtpVisibility::HierarchyNode *node) const 
    6565{ 
    6666#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    … …  
    8181//----------------------------------------------------------------------- 
    8282void SceneNodeHierarchyInterface::SetNodeVisible(GtpVisibility::HierarchyNode *node,  
    83                                                                                                  const bool visible) 
     83                                                                                                 const bool visible) const 
    8484{ 
    8585#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    … …  
    9090//----------------------------------------------------------------------- 
    9191void SceneNodeHierarchyInterface::SetLastVisited(GtpVisibility::HierarchyNode *node,  
    92                                                                                                  const unsigned int frameId) 
     92                                                                                                 const unsigned int frameId) const 
    9393{ 
    9494#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    … …  
    131131//----------------------------------------------------------------------- 
    132132void SceneNodeHierarchyInterface::VisualizeCulledNode(GtpVisibility::HierarchyNode *node,  
    133                                                                                                           GtpVisibility::CullingType type) 
     133                                                                                                          GtpVisibility::CullingType type) const 
    134134{ 
    135135        // TODO 

  • trunk/VUT/chcdemo/HierarchyNode.cpp

    r74 r345  
    459459} 
    460460 
    461  
    462 float HierarchyNode::GetDistance() 
    463 { 
    464         return mDistance; 
    465 } 
    466  
    467  
    468461void HierarchyNode::SetDistance(float distance) 
    469462{ 

  • trunk/VUT/chcdemo/HierarchyNode.h

    r87 r345  
    5353        bool Visible(); 
    5454        //! last time this node was visited (in framenumber) 
    55         int LastVisited(); 
     55        unsigned int LastVisited(); 
    5656        //! sets visible flag 
    5757        void SetVisible(bool visible); 
    5858        //! sets timestamp (current framenumber) 
    59         void SetLastVisited(int lastVisited); 
     59        void SetLastVisited(unsigned int lastVisited); 
    6060        //! is this node a leaf node (i.e., geometry) 
    6161        bool IsLeaf(); 

  • trunk/VUT/chcdemo/RenderTraverser.cpp

    r86 r345  
    199199                                        // update node's visited flag 
    200200                                        node->SetLastVisited(mFrameID); 
    201                                  
     201                                        //if (mFrameID == node->LastVisited()) mNumFrustumCulledNodes ++; 
    202202                                        // skip testing previously visible interior nodes 
    203203                                        if(leafOrWasInvisible) 
    … …  
    215215                        { 
    216216                                // for stats 
    217                                 mNumFrustumCulledNodes ++; 
     217                                //mNumFrustumCulledNodes ++; 
    218218                        } 
    219219                } 
    … …  
    331331        // get next available test id 
    332332        unsigned int occlusionQuery = mOcclusionQueries[mCurrentTestIdx++]; 
    333          
     333        mNumFrustumCulledNodes ++; 
    334334        node->SetOcclusionQuery(occlusionQuery); 
    335335        // do the actual occlusion query for this node 

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

    r343 r345  
    4949Real TerrainFrameListener::msObjectScales[] =  
    5050{ 
    51         0.1, 
     51        0.07, 
    5252        0.03, 
    5353        //0.1, 
    … …  
    191191         
    192192        // arb or nv queries 
    193         mSceneMgr->setOption("UseArbQueries", &mUseArbQueries); 
     193        //mSceneMgr->setOption("UseArbQueries", &mUseArbQueries); 
    194194         
    195195        // reset statistics 

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

    r254 r345  
    302302         
    303303        // if no objects in file, we generate new objects 
    304         if (!mTerrainContentGenerator->LoadObjects("objects.out")) 
    305         { 
     304        //if (!mTerrainContentGenerator->LoadObjects("objects.out")) 
     305        //{ 
    306306                // the objects are generated randomly distributed over the terrain 
    307307                generateScene(900, 0); // create soldiers, trees, ninjas 
    308308                generateScene(500, 1); 
    309309                generateScene(100, 2); 
    310         } 
     310        //} 
    311311 
    312312        // no limitations on height => it is possible for the user to put single  
    … …  
    317317void  TestCullingTerrainApplication::generateScene(int num, int objectType) 
    318318{ 
    319         Vector3 scale(TerrainFrameListener::msObjectScales[objectType],  
    320                                   TerrainFrameListener::msObjectScales[objectType], 
    321                                   TerrainFrameListener::msObjectScales[objectType]); 
     319        float val = TerrainFrameListener::msObjectScales[objectType]; 
     320        Vector3 scale(val, val, val);  
    322321 
    323322        // to provide much occlusion, 
    … …  
    325324        mTerrainContentGenerator->SetMinPos(Vector3(mTerrainMinPos)); 
    326325        mTerrainContentGenerator->SetMaxPos(Vector3(mTerrainMaxPos.x, 75.0f, mTerrainMaxPos.z)); 
    327          
     326        std::stringstream d; d << "objscale: " << scale[0]; 
     327        Ogre::LogManager::getSingleton().logMessage(d.str()); 
    328328        mTerrainContentGenerator->SetScale(scale); 
    329329        mTerrainContentGenerator->SetOffset(TerrainFrameListener::msObjectTerrainOffsets[objectType]); 

  • trunk/VUT/work/iv/IVFrameListener.cpp

    r343 r345  
    126126        mSceneMgr->setOption("DelayRenderTransparents", &delayRenderTransparents); 
    127127        mSceneMgr->setOption("UseDepthPass", &mUseDepthPass); 
    128         mSceneMgr->setOption("UseArbQueries", &mUseArbQueries); 
     128        //mSceneMgr->setOption("UseArbQueries", &mUseArbQueries); 
    129129 
    130130        mSceneMgr->setOption("ShowOctree", &mShowOctree); 
Note: See TracChangeset for help on using the changeset viewer.