Changeset 2770 for GTP/trunk/App/Demos


Ignore:
Timestamp:
06/18/08 14:38:45 (16 years ago)
Author:
mattausch
Message:

chc++ still problems

Location:
GTP/trunk/App/Demos/Vis/CHC_revisited
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Bvh.cpp

    r2764 r2770  
    104104{ 
    105105        mIsVisible = false; 
    106          
    107         mAssumedVisibleFrames = 0; 
    108  
     106        mAssumedVisibleFrameId = 0; 
    109107        mLastVisitedFrame = -1; 
    110          
    111108        mTimesInvisible = 0; 
    112109        mIsFrustumCulled = false; 
    113  
    114110        mIsNew = true; 
    115111} 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/Bvh.h

    r2767 r2770  
    4242                /// if the node is visible 
    4343                bool mIsVisible; 
    44                 /// #frames this node is assumed to stay visible 
    45                 int mAssumedVisibleFrames; 
     44                /// frame id until this node is assumed to stay visible 
     45                int mAssumedVisibleFrameId; 
    4646                /// the frame when this node was last touched during traversal 
    4747                int mLastVisitedFrame; 
    … …  
    9696        */ 
    9797        inline void SetVisible(bool visible); 
    98         /** The assumed visible time span of this node. 
    99         */ 
    100         inline void SetAssumedVisibleFrames(int t); 
     98        /** The frame id until this node is assumed visible 
     99        */ 
     100        inline void SetAssumedVisibleFrameId(int t); 
    101101        /** See set. 
    102102        */ 
    103         inline int GetAssumedVisibleFrames() const; 
    104         /** The time span this node remains visible. 
    105         */ 
    106         inline void SetRemainingVisibleFrames(const int t); 
    107         /** Decrease the time this node is considered visible. 
    108         */ 
    109         inline void DecAssumedVisibleFrames(); 
     103        inline int GetAssumedVisibleFrameId() const; 
    110104        /** Increases the #times this node was 
    111105                successfully tested invisible. 
    … …  
    318312 
    319313 
    320 void BvhNode::SetAssumedVisibleFrames(const int t)  
    321 {  
    322         mVisibility.mAssumedVisibleFrames = t;  
    323 } 
    324  
    325  
    326 int BvhNode::GetAssumedVisibleFrames() const  
    327 {  
    328         return mVisibility.mAssumedVisibleFrames; 
    329 } 
    330  
    331 void BvhNode::DecAssumedVisibleFrames()  
    332 { 
    333         -- mVisibility.mAssumedVisibleFrames;  
     314void BvhNode::SetAssumedVisibleFrameId(int t)  
     315{  
     316        mVisibility.mAssumedVisibleFrameId = t;  
     317} 
     318 
     319 
     320int BvhNode::GetAssumedVisibleFrameId() const  
     321{  
     322        return mVisibility.mAssumedVisibleFrameId; 
    334323} 
    335324 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/CHCPlusPlusTraverser.cpp

    r2767 r2770  
    11#include "CHCPlusPlusTraverser.h" 
     2#include "RenderState.h" 
     3 
    24 
    35namespace CHCDemo 
    … …  
    1719                           (mQueryQueue.front()->ResultAvailable() || mDistanceQueue.empty())) 
    1820                { 
    19                         OcclusionQuery *query = mQueryQueue.front(); 
    20                         mQueryQueue.pop(); 
    21                          
    22                         // wait until result available 
    23                         int visiblePixels = query->GetQueryResult(); 
     21                        if (mQueryQueue.front()->ResultAvailable()) 
     22                        { 
     23                                OcclusionQuery *query = mQueryQueue.front(); 
     24                                mQueryQueue.pop(); 
    2425 
    25                         if (visiblePixels > mVisibilityThreshold) 
     26                                // wait until result available 
     27                                int visiblePixels = query->GetQueryResult(); 
     28 
     29                                if (visiblePixels > mVisibilityThreshold) 
     30                                { 
     31                                        BvhNode *node = query->GetFrontNode(); 
     32 
     33                                        node->SetVisible(true); 
     34                                        mBvh->MakeParentsVisible(node); 
     35                                        TraverseNode(node); 
     36                                } 
     37                                else 
     38                                { 
     39                                        ++ mStats.mNumQueryCulledNodes; 
     40                                } 
     41                        } 
     42                        else if (!mVQueue.empty()) 
    2643                        { 
    27                                 BvhNode *node = query->GetFrontNode(); 
     44                                BvhNode *node = mVQueue.front(); 
     45                                mVQueue.pop(); 
    2846 
    29                                 mBvh->MakeParentsVisible(node); 
    30                                 TraverseNode(node); 
    31                         } 
    32                         else 
    33                         { 
    34                                 ++ mStats.mNumQueryCulledNodes; 
     47                                OcclusionQuery *query = IssueOcclusionQuery(node, true); 
     48                                mQueryQueue.push(query); 
    3549                        } 
    3650                }        
    … …  
    6175                                         
    6276                                        // identify nodes that we cannot skip queries for 
    63                                         const bool leafOrWasInvisible =  
    64                                                 (node->GetLastVisitedFrame() != mFrameId) && (!wasVisible || node->IsVirtualLeaf()); 
    65  
    66                                         // reset node's visibility classification  
    67                                         node->SetVisible(false); 
     77                                        const bool testFeasible = (!wasVisible || (node->IsVirtualLeaf() /*&& (node->GetAssumedVisibleFrameId() <= mFrameId)*/)); 
     78                                                  
    6879 
    6980                                        // update node's visited flag 
    … …  
    7182                                         
    7283                                        // skip testing previously visible interior nodes 
    73                                         if (leafOrWasInvisible) 
     84                                        if (testFeasible) 
    7485                                        { 
    75                                                 OcclusionQuery *query = IssueOcclusionQuery(node, wasVisible); 
    76                                                 mQueryQueue.push(query); 
     86                                                // reset node's visibility classification  
     87                                                node->SetVisible(false); 
     88 
     89                                                if (!wasVisible) 
     90                                                { 
     91                                                        QueryPreviouslyInvisibleNodes(node); 
     92                                                } 
     93                                                else 
     94                                                { 
     95                                                        mVQueue.push(node); 
     96                                                } 
    7797                                        } 
    7898                                         
    79                                         // always traverse a node if it was visible 
     99                                        // always traverse a node if it was previously visible 
    80100                                        if (wasVisible) 
    81101                                                TraverseNode(node); 
    … …  
    88108                        } 
    89109                } 
     110 
     111                if (mDistanceQueue.empty()) 
     112                { 
     113                        // issue remaining multiqueries 
     114                        IssueMultiQueries(); 
     115                } 
     116        } 
     117 
     118        ////////////// 
     119        //-- issue remaining previously visible node queries 
     120 
     121        while (!mVQueue.empty()) 
     122        { 
     123                BvhNode *node = mVQueue.front(); 
     124                mVQueue.pop(); 
     125 
     126                OcclusionQuery *query = IssueOcclusionQuery(node, true); 
     127                mQueryQueue.push(query); 
     128        } 
     129 
     130        while (!mQueryQueue.empty()) 
     131        { 
     132                OcclusionQuery *query = mQueryQueue.front(); 
     133                mQueryQueue.pop(); 
     134 
     135                // wait until result available 
     136                int visiblePixels = query->GetQueryResult(); 
     137 
     138                if (visiblePixels > mVisibilityThreshold) 
     139                { 
     140                        BvhNode *node = query->GetFrontNode(); 
     141 
     142                        node->SetVisible(true); 
     143                        mBvh->MakeParentsVisible(node); 
     144                } 
     145                else 
     146                { 
     147                        ++ mStats.mNumQueryCulledNodes; 
     148                } 
    90149        } 
    91150} 
    92151 
     152 
     153 
     154void CHCPlusPlusTraverser::QueryPreviouslyInvisibleNodes(BvhNode *node) 
     155{ 
     156        mIQueue.push(node); 
     157 
     158        if (mIQueue.size() > 50) 
     159        { 
     160                IssueMultiQueries(); 
     161        } 
    93162} 
     163 
     164 
     165void CHCPlusPlusTraverser::IssueMultiQueries() 
     166{ 
     167        if (0 && mUseRenderQueue) 
     168        { 
     169                if (mRenderState->SetState(RenderState::RENDER)) 
     170                        ++ mStats.mNumStateChanges; 
     171         
     172                mRenderQueue.Render(); 
     173                mRenderQueue.Clear(); 
     174        } 
     175 
     176        while (!mIQueue.empty()) 
     177        { 
     178                BvhNode *node = mIQueue.front(); 
     179                mIQueue.pop(); 
     180 
     181                OcclusionQuery *query = IssueOcclusionQuery(node, false); 
     182                mQueryQueue.push(query); 
     183        } 
     184} 
     185 
     186 
     187} 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/CHCPlusPlusTraverser.h

    r2767 r2770  
    2121        */ 
    2222        virtual void Traverse(); 
     23 
     24        void QueryPreviouslyInvisibleNodes(BvhNode *node); 
     25 
     26        void IssueMultiQueries(); 
     27 
     28        ////////////// 
     29 
     30        BvhNodeQueue mIQueue; 
     31        BvhNodeQueue mVQueue; 
    2332}; 
    2433 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/CHCTraverser.cpp

    r2767 r2770  
    2828                                BvhNode *node = query->GetFrontNode(); 
    2929 
     30                                node->SetVisible(true); 
    3031                                mBvh->MakeParentsVisible(node); 
    3132                                TraverseNode(node); 
    … …  
    6263                                         
    6364                                        // identify nodes that we cannot skip queries for 
    64                                         const bool leafOrWasInvisible =  
    65                                                 (node->GetLastVisitedFrame() != mFrameId) && (!wasVisible || node->IsVirtualLeaf()); 
     65                                        const bool leafOrWasInvisible = (!wasVisible || node->IsVirtualLeaf()); 
    6666 
    6767                                        // reset node's visibility classification  

  • GTP/trunk/App/Demos/Vis/CHC_revisited/FrustumCullingTraverser.cpp

    r2767 r2770  
    3636                } 
    3737        } 
    38  
    39         mRenderQueue.Render(); 
    40         mRenderQueue.Clear(); 
    4138} 
    4239 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/RenderTraverser.cpp

    r2769 r2770  
    1919        mNumRenderedGeometry = 0; 
    2020        mNumRenderedTriangles = 0; 
    21  
     21        mNumPreviouslyVisibleNodeQueries = 0; 
    2222        mNumIssuedQueries = 0; 
    2323        mRenderTime = 0; 
     24        mNumStateChanges = 0; 
    2425} 
    2526 
    … …  
    3536mBvh(NULL),  
    3637mIsQueryMode(false), 
    37 mUseOptimization(true), 
     38mUseOptimization(false), 
    3839mFrameId(-1), 
    39 mUseRenderQueue(false) 
     40mUseRenderQueue(false), 
     41mAssumedVisibleFrames(10) 
    4042{ 
    4143} 
    … …  
    6163        if (node->IsVirtualLeaf()) 
    6264        { 
    63                 if (mUseRenderQueue) 
    64                 { 
    65                         int geometrySize; 
    66                         SceneEntity **geom = mBvh->GetGeometry(node, geometrySize); 
    67                         mRenderQueue.Enqueue(geom, geometrySize); 
    68                         mStats.mNumRenderedGeometry += geometrySize; 
    69                 } 
    70                 else 
    71                 { 
    72                         // RenderBox(node->GetBox()); 
    73                         mStats.mNumRenderedGeometry += mBvh->Render(node, mRenderState); 
    74                 }                
     65                RenderNode(node); 
    7566        } 
    7667        else  
    … …  
    8576 
    8677 
     78void RenderTraverser::RenderNode(BvhNode *node) 
     79{ 
     80        if (mUseRenderQueue) 
     81        { 
     82                int geometrySize; 
     83                SceneEntity **geom = mBvh->GetGeometry(node, geometrySize); 
     84                mRenderQueue.Enqueue(geom, geometrySize); 
     85                mStats.mNumRenderedGeometry += geometrySize; 
     86        } 
     87        else 
     88        { 
     89                if (mRenderState->SetState(RenderState::RENDER)) 
     90                        ++ mStats.mNumStateChanges; 
     91 
     92                mStats.mNumRenderedGeometry += mBvh->Render(node, mRenderState); 
     93        }                
     94} 
     95 
     96 
    8797void RenderTraverser::SetHierarchy(Bvh *bvh) 
    8898{ 
    … …  
    101111{ 
    102112        ++ mStats.mNumIssuedQueries; 
     113 
     114        if (mUseRenderQueue && (mRenderState->GetMode() == RenderState::RENDER)) 
     115        { 
     116                mRenderQueue.Render(); 
     117                mRenderQueue.Clear(); 
     118        } 
    103119 
    104120        OcclusionQuery *query = mQueryHandler.RequestQuery(); 
    … …  
    107123 
    108124        query->BeginQuery(); 
    109          
    110         // if leaf and was visible => will be rendered anyway, thus we 
     125 
     126        if (wasVisible) 
     127        { 
     128                node->SetAssumedVisibleFrameId(mFrameId + 10); 
     129                ++ mStats.mNumPreviouslyVisibleNodeQueries; 
     130        } 
     131 
     132        // if this node is a previous visible leaf => will be rendered anyway, thus we 
    111133        // can also test with the real geometry  
    112         /*if(node->IsLeaf() && wasVisible && mUseOptimization) 
    113         { 
    114                 mNumRenderedGeometry += node->Render(); 
     134        if (wasVisible && mUseOptimization) 
     135        { 
     136                mStats.mNumRenderedGeometry += mBvh->Render(node, mRenderState); 
    115137        } 
    116138        else 
    117         {*/ 
    118  
    119         // change to query mode 
    120         mRenderState->SetState(RenderState::QUERY); 
    121         mBvh->RenderBoundingBox(node); 
    122         mRenderState->SetState(RenderState::RENDER); 
     139        { 
     140                // change to query mode and render box 
     141                if (mRenderState->SetState(RenderState::QUERY)) 
     142                        ++ mStats.mNumStateChanges; 
     143 
     144                mBvh->RenderBoundingBox(node); 
     145        } 
    123146 
    124147        query->EndQuery(); 
    … …  
    172195        Traverse(); 
    173196 
     197        // render the rest of the objects 
     198        if (mUseRenderQueue) 
     199        { 
     200                if (mRenderState->SetState(RenderState::RENDER)) 
     201                        ++ mStats.mNumStateChanges; 
     202 
     203                mRenderQueue.Render(); 
     204                mRenderQueue.Clear(); 
     205        } 
     206 
     207        mRenderState->Reset(); 
     208 
    174209        glDisableClientState(GL_VERTEX_ARRAY); 
    175210        glDisableClientState(GL_NORMAL_ARRAY); 
    176211 
    177         mRenderState->Reset(); 
    178  
    179212        t2 = GetTime(); 
    180213        mStats.mRenderTime = TimeDiff(t1, t2); 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/RenderTraverser.h

    r2769 r2770  
    3333        int mNumRenderedTriangles; 
    3434        int mNumIssuedQueries; 
     35        int mNumStateChanges; 
     36        int mNumPreviouslyVisibleNodeQueries; 
    3537 
    3638        long mRenderTime; 
    … …  
    99101        */ 
    100102        inline bool IntersectsNearPlane(BvhNode *node) const;  
    101         /** Enqueues a bvh node. 
     103        /** Enqueues a bvh node for distance traversal 
    102104        */ 
    103105        void EnqueueNode(BvhNode *node); 
    104  
     106        /** Renders the bvh node. 
     107        */ 
     108        void RenderNode(BvhNode *node); 
    105109 
    106110 
    … …  
    134138 
    135139        bool mUseRenderQueue; 
     140 
     141        int mAssumedVisibleFrames; 
    136142}; 
    137143 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/chcdemo.cpp

    r2769 r2770  
    5757float visZoomFactor = 1.5f; 
    5858 
     59long accumulatedTime = 1000; 
     60float fps = 1e3f; 
     61 
     62int renderedObjects = 0; 
     63int issuedQueries = 0; 
     64int traversedNodes = 0; 
     65int frustumCulledNodes = 0; 
     66int queryCulledNodes = 0; 
     67int stateChanges = 0; 
     68 
    5969bool showHelp = false; 
    6070bool showStatistics = true; 
    … …  
    6979int xEyeBegin, yEyeBegin, yMotionBegin, verticalMotionBegin, horizontalMotionBegin = 0; 
    7080 
    71 bool useOptimization = true; 
     81bool useOptimization = false; 
    7282 
    7383 
    … …  
    296306        traverser->SetHierarchy(bvh); 
    297307        traverser->SetRenderState(&state); 
     308        traverser->SetUseOptimization(useOptimization); 
     309        traverser->SetUseRenderQueue(useRenderQueue); 
     310        traverser->SetVisibilityThreshold(threshold); 
    298311} 
    299312 
    … …  
    843856 
    844857 
    845         sprintf_s(msg2, "traversed: %4d, frustum culled: %4d, query culled: %4d (of %d nodes)", 
    846                           traverser->GetStats().mNumTraversedNodes, traverser->GetStats().mNumFrustumCulledNodes, 
    847                           traverser->GetStats().mNumQueryCulledNodes, bvh->GetNumVirtualNodes()); 
    848  
    849858        char *optstr[2] = {"", ", using optimization"}; 
    850859         
    851         float fps = 1e3f; 
    852860        static long renderTime = traverser->GetStats().mRenderTime; 
    853  
    854861        const float expFactor = 0.5f; 
    855  
    856862        renderTime = traverser->GetStats().mRenderTime * expFactor + (1.0f - expFactor) * renderTime; 
    857863 
    858         if (renderTime) fps = 1e3f / (float)renderTime; 
     864        accumulatedTime += renderTime; 
     865 
     866        if (accumulatedTime > 200) // update every fraction of a second 
     867        {        
     868                accumulatedTime = 0; 
     869                if (renderTime) fps = 1e3f / (float)renderTime; 
     870 
     871                renderedObjects = traverser->GetStats().mNumRenderedGeometry; 
     872                traversedNodes = traverser->GetStats().mNumTraversedNodes; 
     873                frustumCulledNodes = traverser->GetStats().mNumFrustumCulledNodes; 
     874                queryCulledNodes = traverser->GetStats().mNumQueryCulledNodes; 
     875                issuedQueries = traverser->GetStats().mNumIssuedQueries; 
     876                stateChanges = traverser->GetStats().mNumStateChanges; 
     877        } 
    859878 
    860879        sprintf_s(msg2, "threshold: %4d%s",  
    … …  
    869888 
    870889        sprintf_s(msg3, "rendered objects: %6d (of %6d), rendered triangles: %s (of %s)",  
    871                           traverser->GetStats().mNumRenderedGeometry, sceneEntities.size(), str.c_str(), str2.c_str());  
    872  
    873         sprintf_s(msg4, "issued queries: %5d", traverser->GetStats().mNumIssuedQueries); 
     890                          renderedObjects, sceneEntities.size(), str.c_str(), str2.c_str());  
     891 
     892        sprintf_s(msg4, "nodes: %5d, traversed: %5d, frustum culled: %5d, query culled: %5d, issued queries: %5d, state changes: %5d", 
     893                          bvh->GetNumVirtualNodes(), traversedNodes, frustumCulledNodes, 
     894                          queryCulledNodes, issuedQueries, stateChanges); 
    874895 
    875896        sprintf_s(msg5, "fps: %6.1f", fps); 
    876897 
     898        cout << "previously visible node queries: " << traverser->GetStats().mNumPreviouslyVisibleNodeQueries << endl; 
    877899 
    878900        begin2D(); 

  • GTP/trunk/App/Demos/Vis/CHC_revisited/common.h

    r2763 r2770  
    472472 
    473473typedef std::queue<OcclusionQuery *> QueryQueue; 
     474typedef std::queue<BvhNode *> BvhNodeQueue; 
    474475 
    475476static std::ofstream Debug("debug.log"); 
Note: See TracChangeset for help on using the changeset viewer.