Changeset 2773 for GTP/trunk


Ignore:
Timestamp:
06/18/08 20:42:06 (17 years ago)
Author:
mattausch
Message:

implemented multiqueries, but still buggy version

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

Legend:

Unmodified
Added
Removed

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

    r2771 r2773  
    1212#include "SceneEntity.h" 
    1313#include "Geometry.h" 
     14#include "RenderState.h" 
     15 
    1416 
    1517namespace CHCDemo 
    … …  
    1719 
    1820#define INVALID_TEST ((unsigned int)-1) 
    19  
    20 const static bool useVbos = true; 
    21 unsigned int Bvh::sCurrentVboId = -1; 
    2221 
    2322using namespace std; 
    … …  
    122121 
    123122 
    124 Bvh::Bvh(): 
    125 mCamera(NULL),  
    126 mRoot(NULL),  
    127 mVertices(NULL), 
    128 mIndices(NULL), 
    129 mTestIndices(NULL), 
    130 mCurrentIndicesPtr(0), 
    131 mNumNodes(0), 
    132 mMaxDepthForTestingChildren(4), 
    133 mAreaRatioThreshold(1.4f) 
    134 {} 
    135  
    136  
    137 Bvh::Bvh(const SceneEntityContainer &entities): 
    138 mCamera(NULL),  
    139 mRoot(NULL),  
    140 mVertices(NULL), 
    141 mIndices(NULL), 
    142 mTestIndices(NULL), 
    143 mCurrentIndicesPtr(0), 
    144 mNumNodes(0), 
    145 mMaxDepthForTestingChildren(4), 
    146 mAreaRatioThreshold(1.4f) 
    147 { 
     123Bvh::Bvh() 
     124{ 
     125        Init(); 
     126} 
     127 
     128 
     129Bvh::Bvh(const SceneEntityContainer &entities) 
     130{ 
     131        Init(); 
     132 
    148133        mGeometrySize = entities.size(); 
    149134        mGeometry = new SceneEntity*[mGeometrySize]; 
    … …  
    172157 
    173158        if (mRoot) delete mRoot; 
     159} 
     160 
     161 
     162void Bvh::Init() 
     163{ 
     164        mCamera = NULL; 
     165        mRoot = NULL; 
     166        mVertices = NULL; 
     167        mIndices = NULL; 
     168        mTestIndices = NULL; 
     169        mCurrentIndicesPtr = 0; 
     170        mNumNodes = 0; 
     171        mMaxDepthForTestingChildren = 4; 
     172        mAreaRatioThreshold = 1.4f; 
     173        mVboId = -1; 
    174174} 
    175175 
    … …  
    366366 
    367367 
    368 void Bvh::RenderBoundingBox(BvhNode *node) 
    369 { 
    370         RenderBoundingBoxImmediate(node->GetBox()); 
    371         /**static BvhNodeContainer dummy(1); 
     368void Bvh::RenderBoundingBox(BvhNode *node, RenderState *state) 
     369{ 
     370        //RenderBoundingBoxImmediate(node->GetBox()); 
     371        static BvhNodeContainer dummy(1); 
    372372        dummy[0] = node; 
    373         RenderBoundingBoxes(dummy);*/ 
    374 } 
    375  
    376  
    377  
    378 int Bvh::RenderBoundingBoxes(const BvhNodeContainer &nodes) 
     373        RenderBoundingBoxes(dummy, state); 
     374} 
     375 
     376 
     377 
     378int Bvh::RenderBoundingBoxes(const BvhNodeContainer &nodes, RenderState *state) 
    379379{ 
    380380        int renderedBoxes = PrepareBoundingBoxesWithDrawArrays(nodes); 
    381         RenderBoundingBoxesWithDrawArrays(renderedBoxes); 
     381        RenderBoundingBoxesWithDrawArrays(renderedBoxes, state); 
    382382 
    383383        return renderedBoxes; 
    … …  
    395395        } 
    396396 
    397         if (sCurrentVboId == -1) 
     397        if (mVboId == -1) 
    398398        {        
    399399                // prepare the vbo  
    … …  
    428428 
    429429 
    430 void Bvh::RenderBoundingBoxesWithDrawArrays(int numNodes) 
     430void Bvh::RenderBoundingBoxesWithDrawArrays(int numNodes, RenderState *state) 
    431431{ 
    432432        ////// 
    433433        //-- Rendering the vbo 
    434         if (useVbos) 
     434 
     435        if (state->GetCurrentVboId() != mVboId) 
     436        { 
     437                glBindBufferARB(GL_ARRAY_BUFFER_ARB, mVboId); 
    435438                // set the vertex pointer to the vertex buffer 
    436                 glVertexPointer(3, GL_FLOAT, 0, (char *)NULL);           
    437         else 
    438                 glVertexPointer(3, GL_FLOAT, 0, mVertices); 
     439                glVertexPointer(3, GL_FLOAT, 0, (char *)NULL);   
     440 
     441                state->SetCurrentVboId(mVboId); 
     442        } 
    439443 
    440444        // we do use the last or the first index (they are generate and only used to connect strips) 
    441         const int numElements = numNodes * sNumIndicesPerBox - 1; 
    442  
     445        int numElements = numNodes * sNumIndicesPerBox - 1; 
    443446        // don't render first degenerate index 
    444447        glDrawElements(GL_TRIANGLE_STRIP, numElements, GL_UNSIGNED_INT, mIndices + 1);  
    … …  
    559562        } 
    560563 
    561         if (useVbos) 
    562         { 
    563                 glGenBuffersARB(1, &sCurrentVboId); 
    564                 glBindBufferARB(GL_ARRAY_BUFFER_ARB, sCurrentVboId); 
    565                 glVertexPointer(3, GL_FLOAT, 0, (char *)NULL); 
    566          
    567                 glBufferDataARB(GL_ARRAY_BUFFER_ARB,  
    568                                     bufferSize * sizeof(Vector3),  
    569                                     mVertices,  
    570                                                 GL_STATIC_DRAW_ARB); 
    571  
    572                 //glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); 
    573  
    574                 // data handled by graphics driver from now on 
    575                 DEL_PTR(mVertices); 
    576  
    577                 cout << "***** created vbos *********" << endl; 
    578         } 
    579         else 
    580         { 
    581                 sCurrentVboId = 0; 
    582         glVertexPointer(3, GL_FLOAT, 0, mVertices); 
    583  
    584                 cout << "******* created vertex arrays ********" << endl; 
    585         } 
     564        glGenBuffersARB(1, &mVboId); 
     565        glBindBufferARB(GL_ARRAY_BUFFER_ARB, mVboId); 
     566        glVertexPointer(3, GL_FLOAT, 0, (char *)NULL); 
     567         
     568        glBufferDataARB(GL_ARRAY_BUFFER_ARB,  
     569                            bufferSize * sizeof(Vector3),  
     570                            mVertices,  
     571                                        GL_STATIC_DRAW_ARB); 
     572 
     573        //glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); 
     574 
     575        // data handled by graphics driver from now on 
     576        DEL_PTR(mVertices); 
     577 
     578        cout << "***** created vbos for tighter bounds *********" << endl; 
    586579} 
    587580 
    … …  
    713706         
    714707        for (int i = leaf->mFirst; i <= leaf->mLast; ++ i) 
    715                 triangleCount += mGeometry[i]->GetGeometry()->CountTriangles(); 
     708                triangleCount += mGeometry[i]->GetGeometry()->GetNumTriangles(); 
    716709         
    717710        return triangleCount; 
    … …  
    729722                nodeStack.pop(); 
    730723 
    731                 if (node->IsLeaf())  
     724                if (node->IsVirtualLeaf())  
    732725                { 
    733726                        BvhLeaf *leaf = static_cast<BvhLeaf *>(node); 
    734727 
     728                        mBvhStats.mTriangles += CountTriangles(leaf); 
    735729                        mBvhStats.mLeafSA += leaf->mBox.SurfaceArea(); 
    736730                        mBvhStats.mLeafVol += leaf->mBox.GetVolume(); 
    … …  
    771765 
    772766        for (int i = node->mFirst; i <= node->mLast; ++ i) 
    773                 numTriangles += mGeometry[i]->GetGeometry()->CountTriangles(); 
     767                numTriangles += mGeometry[i]->GetGeometry()->GetNumTriangles(); 
    774768         
    775769        return numTriangles; 
    … …  
    799793                node->mNumLeaves = f->mNumLeaves + b->mNumLeaves; 
    800794        } 
    801 } 
    802  
    803  
    804 int Bvh::Render(BvhNode *node, RenderState *state) 
    805 { 
    806         int renderedTriangles = 0; 
    807  
    808         for (int i = node->mFirst; i <= node->mLast; ++ i) 
    809         { 
    810                 renderedTriangles += mGeometry[i]->GetGeometry()->CountTriangles(); 
    811                 mGeometry[i]->Render(state); 
    812         } 
    813  
    814         return renderedTriangles; 
    815795} 
    816796 

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

    r2772 r2773  
    105105                successfully tested invisible. 
    106106        */ 
    107         inline void IncTimesInvisible(); 
    108          
    109         inline int GetTimesInvisible() const; 
    110         inline void SetTimesInvisible(int t); 
     107        inline void IncTimesTestedInvisible(); 
     108         
     109        inline int GetTimesTestedInvisible() const; 
     110        inline void SetTimesTestedInvisible(int t); 
    111111         
    112112        inline int GetTurnedVisibleFrame() const; 
    … …  
    246246 
    247247 
    248 void BvhNode::IncTimesInvisible()  
     248void BvhNode::IncTimesTestedInvisible()  
    249249{  
    250250        ++ mVisibility.mTimesInvisible;  
    … …  
    252252 
    253253 
    254 int BvhNode::GetTimesInvisible() const  
     254int BvhNode::GetTimesTestedInvisible() const  
    255255{  
    256256        return mVisibility.mTimesInvisible;  
    … …  
    258258 
    259259 
    260 void BvhNode::SetTimesInvisible(const int t)  
     260void BvhNode::SetTimesTestedInvisible(const int t)  
    261261{  
    262262        mVisibility.mTimesInvisible = t;  
    … …  
    465465        /** Renders the bounding box of this node (Or the tigher bounding boxes of some subnodes). 
    466466        */ 
    467         void RenderBoundingBox(BvhNode *node); 
     467        void RenderBoundingBox(BvhNode *node, RenderState *state); 
    468468        /** Renders bounding boxes of the collection of nodes. 
    469469                @returns #rendered boxes 
    470470        */ 
    471         int RenderBoundingBoxes(const BvhNodeContainer &nodes); 
     471        int RenderBoundingBoxes(const BvhNodeContainer &nodes, RenderState *state); 
    472472 
    473473        /** Returns the bounding box of this bvh. 
    … …  
    533533        /** Returns stats. 
    534534        */ 
    535         const BvhStats &GetBvhStats() const {return mBvhStats;} 
    536         /** Renders the geometry contained in this node. 
    537         */ 
    538         int Render(BvhNode *node, RenderState *state); 
     535        const BvhStats &GetBvhStats() const { return mBvhStats; } 
    539536        /** Returns number of 'virtual' nodes in the hierarchy, i.e. 
    540537                the number of nodes actually used for traversal. 
    … …  
    550547        */ 
    551548        Bvh(); 
    552  
    553549        /** Protected constructor taking scene geometry into account 
    554550        */ 
    555551        const Bvh(const SceneEntityContainer &entities); 
    556          
     552        /** Called by the constructor. Initializes important members. 
     553        */ 
     554        void Init(); 
    557555 
    558556        ///////////// 
    … …  
    568566 
    569567        int PrepareBoundingBoxesWithDrawArrays(const BvhNodeContainer &nodes); 
    570         void RenderBoundingBoxesWithDrawArrays(int numNodes); 
     568        void RenderBoundingBoxesWithDrawArrays(int numNodes, RenderState *state); 
    571569 
    572570        /** Create the indices that each node needs to use vbo rendering. 
    … …  
    644642        ////////////// 
    645643 
    646         static unsigned int sCurrentVboId; 
     644        unsigned int mVboId; 
    647645}; 
    648646 

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

    r2763 r2773  
    105105        bvh->ComputeIds(); 
    106106        // specify bounds for occlusion tests 
    107         //bvh->RecomputeBounds(); 
     107        bvh->RecomputeBounds(); 
    108108        // compute and print stats 
    109109        bvh->ComputeBvhStats(); 

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

    r2772 r2773  
    1616{ 
    1717        // wait until result available 
    18         int visiblePixels = query->GetQueryResult(); 
    19  
    20         int visible = visiblePixels > mVisibilityThreshold; 
     18        const int visible = query->GetQueryResult() > mVisibilityThreshold; 
    2119 
    2220        BvhNode *node = query->GetFrontNode(); 
    … …  
    2624                // node was previously invisible 
    2725                if (!node->IsVisible()) 
     26                { 
     27                        // reset flag 
     28                        node->SetTimesTestedInvisible(0); 
    2829                        node->SetAssumedVisibleFrameId(mFrameId + mAssumedVisibleFrames); 
     30                } 
    2931                else 
    3032                        // randomize first invokation 
    … …  
    3638        else 
    3739        { 
     40                node->IncTimesTestedInvisible(); 
    3841                ++ mStats.mNumQueryCulledNodes; 
    3942        } 
    … …  
    5861                                 
    5962                                OcclusionQuery *query = IssueOcclusionQuery(node, true); 
     63 
    6064                                mQueryQueue.push(query); 
    6165                                resultAvailable = mQueryQueue.front()->ResultAvailable(); 
    … …  
    9498                                        // identify nodes that we cannot skip queries for 
    9599                                        const bool testFeasible = (!wasVisible || (node->IsVirtualLeaf() && (node->GetAssumedVisibleFrameId() <= mFrameId))); 
     100 
     101                                        // node was not recently tested => reset flag  
     102                                        if (node->GetLastVisitedFrame() != mFrameId - 1) 
     103                                                node->SetTimesTestedInvisible(0); 
    96104 
    97105                                        // update node's visited flag 
    … …  
    176184 
    177185 
     186OcclusionQuery * CHCPlusPlusTraverser::GetNextMultiQuery(BvhNodeQueue &iqueue) 
     187{ 
     188        OcclusionQuery *query = mQueryHandler.RequestQuery(); 
     189 
     190        float pFail = 1.0f;  
     191        float maxBatchVal = 0.0f; 
     192        float newPBatch = 1.0f; 
     193        float newBatchVal; 
     194 
     195        // issue next query 
     196        while (!iqueue.empty()) 
     197        { 
     198                BvhNode *node = iqueue.front(); 
     199                newPBatch *= mVisibilityPredictor.GetProbability(node); 
     200 
     201                if (query->GetNodes().empty()) 
     202                        newBatchVal = 1.0f; 
     203                else 
     204                { 
     205                        int newSize = query->GetSize() + 1; 
     206                        newBatchVal = newSize / (1.0f + (1.0f - newPBatch) * newSize); 
     207                } 
     208 
     209                if (newBatchVal <= maxBatchVal) 
     210                        break; 
     211 
     212                iqueue.pop(); 
     213                query->AddNode(node); 
     214 
     215                maxBatchVal = newBatchVal; 
     216        } 
     217 
     218        IssueOcclusionQuery(*query, false); 
     219 
     220        return query; 
     221} 
     222 
     223 
    178224void CHCPlusPlusTraverser::IssueMultiQueries() 
    179225{ 
    … …  
    191237                BvhNode *node = mIQueue.front(); 
    192238                mIQueue.pop(); 
    193  
    194                 OcclusionQuery *query = IssueOcclusionQuery(node, false); 
     239                OcclusionQuery *query = GetNextMultiQuery(mIQueue); 
     240                //OcclusionQuery *query = IssueOcclusionQuery(node); 
     241 
    195242                mQueryQueue.push(query); 
    196243        } 

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

    r2772 r2773  
    77namespace CHCDemo 
    88{ 
     9 
     10class OcclusionQuery; 
     11 
     12 
     13/** Class predicting the visiblity of nodes. 
     14*/ 
     15class VisibilityPredictor 
     16{ 
     17public: 
     18        /** Predicts the probability of a node to stay visible / invisible. 
     19            The probability could be taken from a measured or analytic function. 
     20        */ 
     21        float GetProbability(BvhNode *node) const  
     22        {  
     23                return 0.98f - 0.68f * exp(-(float)node->GetTimesTestedInvisible());  
     24        } 
     25}; 
     26 
    927 
    1028/** Class implementing traversal using the CHC++ algorithm. 
    … …  
    2240        */ 
    2341        virtual void Traverse(); 
    24  
     42        /** Queries nodes nodes tested invisible in previous frames. 
     43        */ 
    2544        void QueryPreviouslyInvisibleNodes(BvhNode *node); 
    26  
     45        /** Computes the next multiquery. 
     46        */ 
     47        OcclusionQuery *GetNextMultiQuery(BvhNodeQueue &iqueue); 
     48        /** Issues batched multiqueries. 
     49        */ 
    2750        void IssueMultiQueries(); 
    2851        /** Handles the result of an occlusion query. 
    … …  
    3861        BvhNodeQueue mIQueue; 
    3962        BvhNodeQueue mVQueue; 
     63 
     64        VisibilityPredictor mVisibilityPredictor; 
    4065}; 
    4166 

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

    r2756 r2773  
    22#include "Triangle3.h" 
    33#include "glInterface.h" 
     4#include "RenderState.h" 
    45 
    56 
    … …  
    6768 
    6869 
    69 void Geometry::Render() 
     70void Geometry::Render(RenderState *state) 
    7071{ 
    71         glBindBufferARB(GL_ARRAY_BUFFER_ARB, mVboId); 
     72        if (state->GetCurrentVboId() != mVboId) 
     73        { 
     74                glBindBufferARB(GL_ARRAY_BUFFER_ARB, mVboId); 
     75                glVertexPointer(3, GL_FLOAT, 0, (char *)NULL);   
     76                glNormalPointer(GL_FLOAT, 0, (char *)NULL + mNumVertices * sizeof(Vector3)); 
    7277 
    73         glVertexPointer(3, GL_FLOAT, 0, (char *)NULL);   
    74         glNormalPointer(GL_FLOAT, 0, (char *)NULL + mNumVertices * sizeof(Vector3)); 
     78                if (mTexCoords) 
     79                        glTexCoordPointer(2, GL_FLOAT, 0, (char *)NULL + 2 * mNumVertices * sizeof(Vector3)); 
    7580 
    76         if (mTexCoords) 
    77                 glTexCoordPointer(2, GL_FLOAT, 0, (char *)NULL + 2 * mNumVertices * sizeof(Vector3)); 
     81                state->SetCurrentVboId(mVboId); 
     82        } 
    7883 
    7984        // don't render first degenerate index 

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

    r2756 r2773  
    1010{ 
    1111 
     12class RenderState; 
     13 
    1214/** Represents drawable geometry consisting of triangles 
    1315*/ 
    … …  
    2022        /** Render the geometry 
    2123        */ 
    22         void Render(); 
     24        void Render(RenderState *state); 
    2325 
    24         int CountTriangles() const { return mNumVertices / 3; } 
     26        int GetNumTriangles() const { return mNumVertices / 3; } 
    2527 
    2628        inline bool HasTexture() const { return mTexCoords != NULL; } 

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

    r2764 r2773  
    1818 
    1919 
    20 OcclusionQuery::OcclusionQuery(unsigned int idx): 
    21 mQueryId(idx) 
    22 { 
    23         // reverse for multiequeries with 32 nodes 
    24         mNodes.reserve(32); 
    25 } 
    26  
    27  
    2820OcclusionQuery::~OcclusionQuery() 
    2921{ 
    … …  
    3224 
    3325 
    34 void OcclusionQuery::BeginQuery() 
     26void OcclusionQuery::BeginQuery() const 
    3527{ 
    3628        glBeginQueryARB(GL_SAMPLES_PASSED_ARB, mQueryId); 
    … …  
    3830 
    3931 
    40 void OcclusionQuery::EndQuery() 
     32void OcclusionQuery::EndQuery() const 
    4133{ 
    4234        glEndQueryARB(GL_SAMPLES_PASSED_ARB); 
    … …  
    8779        { 
    8880                query = mOcclusionQueries[mCurrentQueryIdx]; 
     81                query->Reset(); 
    8982        } 
    9083 

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

    r2772 r2773  
    1717{ 
    1818public: 
    19          
     19        /** constructor requesting an opengl occlusion query. 
     20        */ 
    2021        OcclusionQuery(); 
    2122 
    … …  
    2627        unsigned int GetQueryResult() const; 
    2728         
    28         void BeginQuery(); 
     29        void BeginQuery() const; 
    2930         
    30         void EndQuery(); 
     31        void EndQuery() const; 
    3132         
    3233        unsigned int GetQueryId() const; 
    … …  
    3435        */ 
    3536        inline BvhNode *GetFrontNode() const { return mNodes[0]; } 
    36         /** Reset the contents of this query. 
     37        inline const BvhNodeContainer &GetNodes() const { return mNodes; } 
     38 
     39        /** Reset the list of nodes associated with this query. 
    3740        */ 
    3841        inline void Reset() { mNodes.clear(); } 
    … …  
    4043        */ 
    4144        inline void AddNode(BvhNode *node) { mNodes.push_back(node); } 
    42         /** Convenience method that sets up a single node query. 
     45        /** Returns the size of the multiquery. 
    4346        */ 
    44         inline void SetNode(BvhNode *node) { Reset(); AddNode(node); } 
     47        inline int GetSize() const { return (int)mNodes.size();} 
    4548 
    46          
    4749protected: 
    4850 
    49         OcclusionQuery(unsigned int id); 
    50          
    5151         
    5252        /////// 
    5353        //-- members 
    5454 
    55         //float mPFail; 
    5655        /// all nodes that are tested with the same query 
    5756        BvhNodeContainer mNodes;  

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

    r2771 r2773  
    3939 
    4040 
    41 void RenderQueue::Enqueue(SceneEntity **entities, int size) 
     41void RenderQueue::Enqueue(SceneEntity *entity) 
    4242{ 
    43         for (int i = 0; i < size; ++ i) 
    44                 mEntities.push_back(entities[i]); 
     43        mEntities.push_back(entity); 
    4544} 
    4645         

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

    r2771 r2773  
    2323        */ 
    2424        RenderQueue(RenderState *state); 
    25         /** Enqueues a number of entities 
     25        /** Enqueues an entity 
    2626        */ 
    27         void Enqueue(SceneEntity **entities, int size); 
     27        void Enqueue(SceneEntity *entity); 
    2828        /** Renders the contents of the render queue. 
    2929        */ 

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

    r2769 r2773  
    1212*/ 
    1313RenderState::RenderState(): 
    14 mAlphaTestEnabled(false), mTexturesEnabled(false), mMode(RENDER)  
     14mAlphaTestEnabled(false),  
     15mTexturesEnabled(false),  
     16mMode(RENDER)  
    1517{ 
    1618        Reset();  
    … …  
    3234                glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE); 
    3335                glDepthMask(GL_FALSE); 
    34  
    35  
    36                 ///////// 
    37                 //-- handle vbo 
    38  
    39                 /*glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0); 
    40  
    41                 if (Bvh::sCurrentVboId != -1) 
    42                         glBindBufferARB(GL_ARRAY_BUFFER_ARB, Bvh::sCurrentVboId); 
    43                 else 
    44                         glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); 
    45                 */ 
    4636 
    4737                SetState(false, false); 
    … …  
    9282void RenderState::Reset() 
    9383{ 
     84        mCurrentVboId = -1; 
    9485        SetState(false, false); 
    9586        SetState(RENDER); 

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

    r2769 r2773  
    4141        */ 
    4242        void Reset(); 
     43        /** Stores the current vbo id. 
     44        */ 
     45        inline void SetCurrentVboId(int id) { mCurrentVboId = id; } 
     46        /** Returns the current vbo id. 
     47        */ 
     48        inline int GetCurrentVboId() { return mCurrentVboId; } 
    4349 
    4450protected: 
    … …  
    4854 
    4955        Mode mMode; 
     56 
     57        int mCurrentVboId; 
    5058}; 
    5159 

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

    r2772 r2773  
    55#include "SceneEntity.h" 
    66#include "RenderState.h" 
     7#include "Geometry.h" 
    78 
    89 
    … …  
    1617void TraversalStatistics::Reset() 
    1718{ 
    18         // reset statistics 
    1919        mNumTraversedNodes = 0; 
    2020        mNumQueryCulledNodes = 0; 
    2121        mNumFrustumCulledNodes = 0; 
     22         
    2223        mNumRenderedGeometry = 0; 
    2324        mNumRenderedTriangles = 0; 
     25        mNumRenderedNodes = 0; 
     26 
    2427        mNumPreviouslyVisibleNodeQueries = 0; 
    2528        mNumIssuedQueries = 0; 
     29        mNumStateChanges = 0; 
     30 
    2631        mRenderTime = 0; 
    27         mNumStateChanges = 0; 
    2832} 
    2933 
    … …  
    8387        if (node->GetLastRenderedFrame() != mFrameId) 
    8488        { 
    85                 //cout << "big error!!" << endl; 
     89                if (mUseRenderQueue && mRenderState->SetState(RenderState::RENDER)) 
     90                        ++ mStats.mNumStateChanges; 
     91 
    8692                node->SetLastRenderedFrame(mFrameId); 
    8793 
    88                 if (mUseRenderQueue) 
     94                int geometrySize; 
     95                SceneEntity **entities = mBvh->GetGeometry(node, geometrySize); 
     96 
     97                mStats.mNumRenderedGeometry += geometrySize; 
     98                ++ mStats.mNumRenderedNodes; 
     99                 
     100                for (int i = 0; i < geometrySize; ++ i) 
    89101                { 
    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); 
     102                        SceneEntity *ent = entities[i]; 
     103                        mStats.mNumRenderedTriangles += ent->GetGeometry()->GetNumTriangles(); 
     104 
     105                        if (mUseRenderQueue) 
     106                                mRenderQueue.Enqueue(ent); 
     107                        else 
     108                                ent->Render(mRenderState); 
    101109                }                
    102110        } 
    … …  
    114122        mRenderState = state; 
    115123        mRenderQueue.SetRenderState(state); 
    116 } 
    117  
    118  
    119 OcclusionQuery *RenderTraverser::IssueOcclusionQuery(BvhNode *node, bool wasVisible) 
    120 { 
    121         ++ mStats.mNumIssuedQueries; 
    122  
    123         if (mUseRenderQueue && (mRenderState->GetMode() == RenderState::RENDER)) 
    124         { 
    125                 mRenderQueue.Render(); 
    126                 mRenderQueue.Clear(); 
    127         } 
    128  
    129         OcclusionQuery *query = mQueryHandler.RequestQuery(); 
    130  
    131         query->SetNode(node); 
    132  
    133         query->BeginQuery(); 
    134  
    135         if (wasVisible) 
    136                 ++ mStats.mNumPreviouslyVisibleNodeQueries; 
    137  
    138         // if this node is a previous visible leaf: 
    139         // leaves will be rendered anyway => we can also test with the real geometry  
    140         if (wasVisible && mUseOptimization) 
    141         { 
    142                 RenderNode(node); 
    143         } 
    144         else 
    145         { 
    146                 // change to query mode and render box 
    147                 if (mRenderState->SetState(RenderState::QUERY)) 
    148                         ++ mStats.mNumStateChanges; 
    149  
    150                 mBvh->RenderBoundingBox(node); 
    151         } 
    152  
    153         query->EndQuery(); 
    154  
    155         return query; 
    156124} 
    157125 
    … …  
    213181 
    214182 
    215 } 
     183 
     184 
     185OcclusionQuery *RenderTraverser::IssueOcclusionQuery(BvhNode *node, bool wasVisible) 
     186{ 
     187        OcclusionQuery *query = mQueryHandler.RequestQuery(); 
     188        query->AddNode(node); 
     189 
     190        IssueOcclusionQuery(*query, wasVisible); 
     191 
     192        return query; 
     193} 
     194 
     195 
     196void RenderTraverser::IssueOcclusionQuery(const OcclusionQuery &query, bool wasVisible) 
     197{ 
     198        ++ mStats.mNumIssuedQueries; 
     199 
     200        if (mUseRenderQueue && (mRenderState->GetMode() == RenderState::RENDER)) 
     201        { 
     202                mRenderQueue.Render(); 
     203                mRenderQueue.Clear(); 
     204        } 
     205 
     206        query.BeginQuery(); 
     207 
     208        if (wasVisible) 
     209                ++ mStats.mNumPreviouslyVisibleNodeQueries; 
     210 
     211        // if this node is a previous visible leaf: 
     212        // leaves will be rendered anyway => we can also test with the real geometry  
     213        if (wasVisible && mUseOptimization) 
     214        { 
     215                for (size_t i = 0; i < query.GetNodes().size(); ++ i) 
     216                        RenderNode(query.GetNodes()[i]); 
     217        } 
     218        else 
     219        { 
     220                // change to query mode and render box 
     221                if (mRenderState->SetState(RenderState::QUERY)) 
     222                        ++ mStats.mNumStateChanges; 
     223 
     224                mBvh->RenderBoundingBoxes(query.GetNodes(), mRenderState); 
     225        } 
     226 
     227        query.EndQuery(); 
     228} 
     229 
     230 
     231} 

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

    r2771 r2773  
    3030        int mNumQueryCulledNodes; 
    3131        int mNumFrustumCulledNodes; 
     32         
    3233        int mNumRenderedGeometry; 
    3334        int mNumRenderedTriangles; 
     35        int mNumRenderedNodes; 
     36 
    3437        int mNumIssuedQueries; 
    3538        int mNumStateChanges; 
    3639        int mNumPreviouslyVisibleNodeQueries; 
    37  
     40         
    3841        long mRenderTime; 
    3942}; 
    … …  
    114117        */ 
    115118        void TraverseNode(BvhNode *node); 
    116         /** Issues occlusion query for specified node 
     119        /** Issues occlusion query for a single node 
    117120        */ 
    118121        OcclusionQuery *IssueOcclusionQuery(BvhNode *node, bool wasVisible); 
     122        /** Issue multiquery. 
     123        */ 
     124        void IssueOcclusionQuery(const OcclusionQuery &query, bool wasVisible); 
    119125        /** Retunrs true if the current bvh node intersects the near plane. 
    120126        */ 

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

    r2769 r2773  
    2626                glPushMatrix(); 
    2727                glMultMatrixf((float *)mTransform->x); 
    28                 mGeometry->Render(); 
     28                mGeometry->Render(state); 
    2929 
    3030                glPopMatrix(); 
    … …  
    3232        else 
    3333        { 
    34                 mGeometry->Render(); 
     34                mGeometry->Render(state); 
    3535        } 
    3636} 

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

    r2771 r2773  
    6262 
    6363int renderedObjects = 0; 
     64int renderedNodes = 0; 
     65int renderedTriangles = 0; 
     66 
    6467int issuedQueries = 0; 
    6568int traversedNodes = 0; 
    … …  
    869872 
    870873                renderedObjects = traverser->GetStats().mNumRenderedGeometry; 
     874                renderedNodes = traverser->GetStats().mNumRenderedNodes; 
     875                renderedTriangles = traverser->GetStats().mNumRenderedTriangles; 
     876 
    871877                traversedNodes = traverser->GetStats().mNumTraversedNodes; 
    872878                frustumCulledNodes = traverser->GetStats().mNumFrustumCulledNodes; 
    … …  
    881887        string str2; 
    882888 
    883         int dummy = 0; 
    884         CalcDecimalPoint(str, dummy); 
    885         CalcDecimalPoint(str2, traverser->GetStats().mNumRenderedTriangles); 
    886  
    887         sprintf_s(msg3, "rendered objects: %6d (of %6d), rendered triangles: %s (of %s)",  
    888                           renderedObjects, sceneEntities.size(), str.c_str(), str2.c_str());  
    889  
    890         sprintf_s(msg4, "nodes: %5d, traversed: %5d, frustum culled: %5d, query culled: %5d, issued queries: %5d, state changes: %5d", 
    891                           bvh->GetNumVirtualNodes(), traversedNodes, frustumCulledNodes, 
    892                           queryCulledNodes, issuedQueries, stateChanges); 
     889        CalcDecimalPoint(str, renderedTriangles); 
     890        CalcDecimalPoint(str2, bvh->GetBvhStats().mTriangles); 
     891 
     892        sprintf_s(msg3, "rendered nodes: %6d (of %6d), rendered triangles: %s (of %s)",  
     893                          renderedNodes, bvh->GetNumVirtualNodes(), str.c_str(), str2.c_str());  
     894 
     895        sprintf_s(msg4, "traversed: %5d, frustum culled: %5d, query culled: %5d, issued queries: %5d, state changes: %5d", 
     896                          traversedNodes, frustumCulledNodes, queryCulledNodes, issuedQueries, stateChanges); 
    893897 
    894898        sprintf_s(msg5, "fps: %6.1f", fps); 
    895899 
    896         cout << "previously visible node queries: " << traverser->GetStats().mNumPreviouslyVisibleNodeQueries << endl; 
     900        //cout << "previously visible node queries: " << traverser->GetStats().mNumPreviouslyVisibleNodeQueries << endl; 
    897901 
    898902        begin2D(); 
    … …  
    906910                glColor3f(1.0f, 1.0f, 1.0f); 
    907911                 
    908                 Output(800, 30, msg[renderMode]); 
     912                Output(850, 30, msg[renderMode]); 
    909913 
    910914                if(showStatistics) 
Note: See TracChangeset for help on using the changeset viewer.