Ignore:
Timestamp:
06/18/08 17:33:16 (17 years ago)
Author:
mattausch
Message:
 
Location:
GTP/trunk/App/Demos/Vis/CHC_revisited
Files:
12 edited

Legend:

Unmodified
Added
Removed

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

    r2770 r2771  
    124124Bvh::Bvh(): 
    125125mCamera(NULL),  
    126 mFrameId(-1),  
    127126mRoot(NULL),  
    128127mVertices(NULL), 
    … …  
    138137Bvh::Bvh(const SceneEntityContainer &entities): 
    139138mCamera(NULL),  
    140 mFrameId(-1),  
    141139mRoot(NULL),  
    142140mVertices(NULL), 
    … …  
    349347 
    350348 
    351 void Bvh::InitFrame(Camera *camera, int currentFrameId) 
     349void Bvh::InitFrame() 
    352350{ 
    353351        // = 0011 1111 which means that at the beginning, all six planes have to frustum culled 
    354352        mRoot->mPlaneMask = 0x3f; 
    355         mCamera = camera; 
    356  
    357         mFrameId = currentFrameId; 
    358353 
    359354        mCamera->CalcFrustum(sFrustum); 
    … …  
    809804int Bvh::Render(BvhNode *node, RenderState *state) 
    810805{ 
    811         //cout << "r " << node->mFirst << " " <<  node->mLast << endl; 
    812  
    813         int rendered = 0; 
     806        int renderedTriangles = 0; 
    814807 
    815808        for (int i = node->mFirst; i <= node->mLast; ++ i) 
    816809        { 
    817                 if (mGeometry[i]->GetLastRendered() != mFrameId) 
    818                 { 
    819                         mGeometry[i]->Render(state); 
    820                         mGeometry[i]->SetLastRendered(mFrameId); 
    821                         ++ rendered; 
    822                 } 
    823         } 
    824  
    825         return rendered; 
     810                renderedTriangles += mGeometry[i]->GetGeometry()->CountTriangles(); 
     811                mGeometry[i]->Render(state); 
     812        } 
     813 
     814        return renderedTriangles; 
    826815} 
    827816 

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

    r2770 r2771  
    447447        */ 
    448448        int CountTriangles(BvhLeaf *leaf) const; 
    449  
     449        /** Sets the scene camera 
     450        */ 
     451        void SetCamera(Camera * camera) { mCamera = camera; } 
     452 
     453        /////////////// 
     454        //-- functions collecting nodes based on some criteria 
    450455 
    451456        void CollectNodes(BvhNode *node, BvhNodeContainer &nodes, int depth); 
    … …  
    490495        */ 
    491496        int     IsWithinViewFrustum(BvhNode *node); 
    492         /** Sets frame dependent values. 
    493         */ 
    494         void InitFrame(Camera *camera, int currentFrameId); 
     497        /** Sets frame dependent values 
     498        */ 
     499        void InitFrame(); 
    495500        /** This gives the orthogonal distance from the viewpoint to the nearest bounding box vertex 
    496501                note that negative values can appear because culling is done only afterwards 
    … …  
    618623        /// the current camera 
    619624        Camera *mCamera; 
    620         // current frame id 
    621         int mFrameId; 
    622625        /// a vertex array used if working with indexed arrays (without vbo) 
    623626        Vector3 *mVertices; 

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

    r2770 r2771  
    22#include "RenderState.h" 
    33 
     4using namespace std; 
    45 
    56namespace CHCDemo 
    67{ 
    78 
    8 CHCPlusPlusTraverser::CHCPlusPlusTraverser()  
     9 
     10CHCPlusPlusTraverser::CHCPlusPlusTraverser() 
    911{ 
    1012} 
    … …  
    1618        while (!mDistanceQueue.empty() || !mQueryQueue.empty()) 
    1719        { 
     20                bool resultAvailable; 
    1821                while (!mQueryQueue.empty() &&  
    19                            (mQueryQueue.front()->ResultAvailable() || mDistanceQueue.empty())) 
    20                 { 
    21                         if (mQueryQueue.front()->ResultAvailable()) 
    22                         { 
    23                                 OcclusionQuery *query = mQueryQueue.front(); 
    24                                 mQueryQueue.pop(); 
    25  
    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()) 
     22                           (mDistanceQueue.empty() || (resultAvailable = mQueryQueue.front()->ResultAvailable()))) 
     23                { 
     24                        while (!resultAvailable && !mVQueue.empty()) 
    4325                        { 
    4426                                BvhNode *node = mVQueue.front(); 
    4527                                mVQueue.pop(); 
    46  
     28                                 
    4729                                OcclusionQuery *query = IssueOcclusionQuery(node, true); 
    4830                                mQueryQueue.push(query); 
     31                                resultAvailable = mQueryQueue.front()->ResultAvailable(); 
     32                        } 
     33                         
     34                        OcclusionQuery *query = mQueryQueue.front(); 
     35                        mQueryQueue.pop(); 
     36 
     37                        // wait until result available 
     38                        int visiblePixels = query->GetQueryResult(); 
     39 
     40                        if (visiblePixels > mVisibilityThreshold) 
     41                        { 
     42                                BvhNode *node = query->GetFrontNode(); 
     43 
     44                                node->SetVisible(true); 
     45                                mBvh->MakeParentsVisible(node); 
     46                                TraverseNode(node); 
     47                        } 
     48                        else 
     49                        { 
     50                                ++ mStats.mNumQueryCulledNodes; 
    4951                        } 
    5052                }        
    … …  
    7577                                         
    7678                                        // identify nodes that we cannot skip queries for 
    77                                         const bool testFeasible = (!wasVisible || (node->IsVirtualLeaf() /*&& (node->GetAssumedVisibleFrameId() <= mFrameId)*/)); 
     79                                        const bool testFeasible = (!wasVisible || (node->IsVirtualLeaf() && (node->GetAssumedVisibleFrameId() <= mFrameId))); 
    7880                                                  
    7981 
    … …  
    109111                } 
    110112 
     113                // distance queue empty: feed the remaining multiqueries to 
     114                // be able to proceed traversal 
    111115                if (mDistanceQueue.empty()) 
    112116                { 
    113                         // issue remaining multiqueries 
    114117                        IssueMultiQueries(); 
    115118                } 
     119        } 
     120 
     121        // render the rest of the objects 
     122        if (mUseRenderQueue) 
     123        { 
     124                if (mRenderState->SetState(RenderState::RENDER)) 
     125                        ++ mStats.mNumStateChanges; 
     126 
     127                mRenderQueue.Render(); 
     128                mRenderQueue.Clear(); 
    116129        } 
    117130 
    … …  
    156169        mIQueue.push(node); 
    157170 
    158         if (mIQueue.size() > 50) 
     171        if (mIQueue.size() > mMaxBatchSize) 
    159172        { 
    160173                IssueMultiQueries(); 

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

    r2770 r2771  
    1717        //~CHCPlusPlusTraverser(); 
    1818 
     19 
    1920protected: 
    2021        /** Traverses and renders the scene with the specified method 
    … …  
    2627        void IssueMultiQueries(); 
    2728 
     29 
    2830        ////////////// 
     31 
     32        /// the query queue 
     33        QueryQueue mQueryQueue; 
    2934 
    3035        BvhNodeQueue mIQueue; 

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

    r2767 r2771  
    2121        */ 
    2222        virtual void Traverse(); 
     23 
     24        /// the query queue 
     25        QueryQueue mQueryQueue; 
     26 
    2327}; 
    2428 

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

    r2770 r2771  
    3636                } 
    3737        } 
     38 
     39        // render the rest of the objects 
     40        if (mUseRenderQueue) 
     41        { 
     42                mRenderQueue.Render(); 
     43                mRenderQueue.Clear(); 
     44        } 
    3845} 
    3946 

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

    r2768 r2771  
    2828 
    2929 
    30 RenderQueue::RenderQueue(): mState(NULL) 
     30RenderQueue::RenderQueue(): mState(NULL), mMinSizeForSorting(5) 
    3131{ 
    3232} 
    … …  
    4343        for (int i = 0; i < size; ++ i) 
    4444                mEntities.push_back(entities[i]); 
    45  
    4645} 
    4746         
    … …  
    6261void RenderQueue::Render() 
    6362{ 
    64         Sort(); 
     63        if (mEntities.size() >= mMinSizeForSorting) 
     64                Sort(); 
    6565         
    6666        //if (!mEntities.empty()) Debug << "rendering render queue" << endl; 

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

    r2767 r2771  
    4848        RenderState *mState; 
    4949        SceneEntityContainer mEntities; 
     50        int mMinSizeForSorting; 
    5051}; 
    5152 

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

    r2770 r2771  
    55#include "SceneEntity.h" 
    66#include "RenderState.h" 
     7 
     8 
     9using namespace std; 
    710 
    811 
    … …  
    3538mVisibilityThreshold(0), 
    3639mBvh(NULL),  
    37 mIsQueryMode(false), 
    3840mUseOptimization(false), 
    3941mFrameId(-1), 
    4042mUseRenderQueue(false), 
    41 mAssumedVisibleFrames(10) 
     43mAssumedVisibleFrames(10), 
     44mMaxBatchSize(50) 
    4245{ 
    4346} 
    … …  
    7881void RenderTraverser::RenderNode(BvhNode *node) 
    7982{ 
    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         }                
     83        if (node->GetLastRenderedFrame() != mFrameId) 
     84        { 
     85                //cout << "big error!!" << endl; 
     86                node->SetLastRenderedFrame(mFrameId); 
     87 
     88                if (mUseRenderQueue) 
     89                { 
     90                        int geometrySize; 
     91                        SceneEntity **geom = mBvh->GetGeometry(node, geometrySize); 
     92                        mRenderQueue.Enqueue(geom, geometrySize); 
     93                        mStats.mNumRenderedGeometry += geometrySize; 
     94                } 
     95                else 
     96                { 
     97                        if (mRenderState->SetState(RenderState::RENDER)) 
     98                                ++ mStats.mNumStateChanges; 
     99 
     100                        mStats.mNumRenderedGeometry += mBvh->Render(node, mRenderState); 
     101                }                
     102        } 
    94103} 
    95104 
    … …  
    130139        } 
    131140 
    132         // if this node is a previous visible leaf => will be rendered anyway, thus we 
    133         // can also test with the real geometry  
     141        // if this node is a previous visible leaf: 
     142        // leaves will be rendered anyway => we can also test with the real geometry  
    134143        if (wasVisible && mUseOptimization) 
    135144        { 
    136                 mStats.mNumRenderedGeometry += mBvh->Render(node, mRenderState); 
     145                RenderNode(node); 
    137146        } 
    138147        else 
    … …  
    151160 
    152161 
    153 void RenderTraverser::SetVisibilityThreshold(int threshold) 
    154 { 
    155         mVisibilityThreshold = threshold; 
    156 } 
    157  
    158  
    159 int RenderTraverser::GetVisibilityThreshold() const 
    160 { 
    161         return mVisibilityThreshold; 
    162 } 
    163  
    164  
    165 void RenderTraverser::SetUseOptimization(bool useOptimization) 
    166 { 
    167         mUseOptimization = useOptimization; 
    168 } 
    169  
    170  
    171  
    172162void RenderTraverser::RenderScene() 
    173163{ 
    … …  
    182172        ++ mFrameId; 
    183173 
    184         mBvh->InitFrame(mCamera, mFrameId); 
     174        mBvh->InitFrame(); 
    185175 
    186176        mStats.Reset(); 
    … …  
    195185        Traverse(); 
    196186 
    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  
    207187        mRenderState->Reset(); 
    208188 
    … …  
    221201} 
    222202 
    223 } 
     203 
     204 
     205 
     206void RenderTraverser::SetVisibilityThreshold(int threshold) 
     207{ 
     208        mVisibilityThreshold = threshold; 
     209} 
     210 
     211 
     212void RenderTraverser::SetUseOptimization(bool useOptimization) 
     213{ 
     214        mUseOptimization = useOptimization; 
     215} 
     216 
     217 
     218} 

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

    r2770 r2771  
    6767        */ 
    6868        void SetCamera(Camera *cam)  {mCamera = cam;} 
     69        /** Renders a visualization of the hierarchy 
     70        */ 
     71        void RenderVisualization(); 
     72        /** Sets the current render state 
     73        */ 
     74        void SetRenderState(RenderState *state); 
     75        /** The traversal statistics 
     76        */ 
     77        const TraversalStatistics &GetStats() const { return mStats; } 
     78 
     79 
     80        ////////////////// 
     81        //-- options for the different rendering algorithms 
     82 
     83        /** If a render queue should be used to batch up and sort scene entities before 
     84                rendering. 
     85        */ 
     86        void SetUseRenderQueue(bool useRenderQueue); 
    6987        /** Sets visible pixels threshold for visibility classification 
    7088        */ 
    7189        void SetVisibilityThreshold(int threshold); 
    72         /** Returns visibility threshold 
    73         */ 
    74         int GetVisibilityThreshold() const; 
    75         /** renders a visualization of the hierarchy 
    76         */ 
    77         void RenderVisualization(); 
    78         /** use optimization to take leaf nodes instead of bounding box for occlusion queries    
     90 
     91 
     92        /////////////////// 
     93        //-- CHC / CHC ++ related options 
     94 
     95 
     96        /** CHC optimization to query the geometry itself instead of the bounding box. 
    7997        */ 
    8098        void SetUseOptimization(bool useOptimization); 
    81         /** Sets the current render state 
     99        /** The number of frames a previously visible node is assumed to stay visible. 
    82100        */ 
    83         void SetRenderState(RenderState *state); 
     101        void SetAssumedVisibleFrames(int assumedVisibleFrames); 
     102        /** The maximum batch size for the i-queue 
     103        */ 
     104        void SetMaxBatchSize(int batchSize); 
    84105 
    85         void SetUseRenderQueue(bool useRenderQueue); 
    86         const TraversalStatistics &GetStats() const { return mStats; } 
    87106 
    88107protected: 
    … …  
    120139        /// the current frame id 
    121140        int mFrameId; 
     141        /// the current render state 
     142        RenderState *mRenderState; 
     143        /// manages creation and destruction of the queries 
     144        QueryHandler mQueryHandler; 
     145        /// the statisitcs 
     146        TraversalStatistics mStats; 
     147         
     148        RenderQueue mRenderQueue; 
    122149 
    123         bool mIsQueryMode; 
    124150 
    125         RenderState *mRenderState; 
    126  
    127         QueryHandler mQueryHandler; 
    128  
    129         TraversalStatistics mStats; 
    130  
    131         QueryQueue mQueryQueue; 
     151        ///////////////// 
     152        //-- algorithm parametes 
    132153 
    133154        int mVisibilityThreshold; 
    … …  
    135156        bool mUseOptimization; 
    136157 
    137         RenderQueue mRenderQueue; 
    138  
    139158        bool mUseRenderQueue; 
    140159 
    141160        int mAssumedVisibleFrames; 
     161 
     162        int mMaxBatchSize; 
    142163}; 
    143164 

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

    r2767 r2771  
    4949                tStack.pop(); 
    5050 
    51                 if (!node->IsLeaf()) 
     51                if (!node->IsVirtualLeaf()) 
    5252                { 
    5353                        BvhInterior *interior = static_cast<BvhInterior *>(node); 

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

    r2770 r2771  
    4141/// the rendering algorithm 
    4242int renderMode = RenderTraverser::CULL_FRUSTUM; 
    43 /// the visibility threshold 
    44 int threshold = 0; 
    4543// eye near plane distance 
    4644float nearDist = 0.1f;  
     45/// the pixel threshold where a node is still considered invisible 
     46int threshold; 
     47 
    4748 
    4849const float keyForwardMotion = 1.0f; 
    … …  
    7172bool showBoundingVolumes = false; 
    7273bool visMode = false; 
    73  
    74  
    75 // visualisation view matrix 
    76 Matrix4x4 visView;  
    7774 
    7875//mouse navigation state 
    … …  
    154151        //bvh = bvhLoader.Load("house_test.bvh", sceneEntities); 
    155152 
     153        bvh->SetCamera(camera); 
    156154        ResetTraverser(); 
    157155 
    … …  
    284282        DEL_PTR(traverser); 
    285283 
     284        bvh->ResetNodeClassifications(); 
     285 
    286286        switch (renderMode) 
    287287        { 
    … …  
    427427                break; 
    428428        case '+': 
    429                 threshold = traverser->GetVisibilityThreshold() + 10; 
     429                threshold += 10; 
    430430                traverser->SetVisibilityThreshold(threshold); 
    431431                break; 
    432432        case '-': 
    433                 threshold = traverser->GetVisibilityThreshold() - 10; 
     433                threshold -= 10; 
    434434                if(threshold < 0) threshold = 0; 
    435  
    436435                traverser->SetVisibilityThreshold(threshold);            
    437436                break; 
    … …  
    776775        glViewport(winWidth / 2, winHeight / 2, winWidth, winHeight); 
    777776        glPushMatrix(); 
    778         glLoadMatrixf((float *)visView.x); 
     777        //glLoadMatrixf((float *)visView.x); 
    779778         
    780779        glClear(GL_DEPTH_BUFFER_BIT); 
    … …  
    859858         
    860859        static long renderTime = traverser->GetStats().mRenderTime; 
    861         const float expFactor = 0.5f; 
     860        const float expFactor = 0.95f; 
    862861        renderTime = traverser->GetStats().mRenderTime * expFactor + (1.0f - expFactor) * renderTime; 
    863862 
    864863        accumulatedTime += renderTime; 
    865864 
    866         if (accumulatedTime > 200) // update every fraction of a second 
     865        if (accumulatedTime > 100) // update every fraction of a second 
    867866        {        
    868867                accumulatedTime = 0; 
    … …  
    877876        } 
    878877 
    879         sprintf_s(msg2, "threshold: %4d%s",  
    880                 traverser->GetVisibilityThreshold(), optstr[useOptimization]); 
     878        sprintf_s(msg2, "threshold: %4d%s", threshold, optstr[useOptimization]); 
    881879 
    882880        string str; 
Note: See TracChangeset for help on using the changeset viewer.