Changeset 87


Ignore:
Timestamp:
05/09/05 01:24:02 (20 years ago)
Author:
mattausch
Message:
 
Location:
trunk/VUT
Files:
33 edited

Legend:

Unmodified
Added
Removed

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

    r74 r87  
    3838        */ 
    3939        unsigned int GetNumQueryCulledNodes(); 
     40        /** Returns number of issued occlusion queries. 
     41        */ 
     42        unsigned int GetNumQueriesIssued(); 
     43        /** basic initializations on beginning of each frame, e.g.,  
     44                resets statistics. 
     45        */ 
     46        void InitFrame(); 
    4047 
    4148protected: 
    42  
     49         
    4350        unsigned int mNumQueryCulledNodes; 
    4451        unsigned int mNumFrustumCulledNodes; 
    4552        unsigned int mVisibilityThreshold; 
     53        unsigned int mNumQueriesIssued; 
    4654 
    4755        HierarchyInterface *mHierarchyInterface; 

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

    r59 r87  
    2525        bool operator() (T v1, T v2) const 
    2626        { 
    27                 return mHierarchyInterface->HasGreaterDistance(v1, v2); 
     27                return mHierarchyInterface->GetSquaredDistance(v1) > mHierarchyInterface->GetSquaredDistance(v2); 
    2828        } 
    2929                 

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

    r86 r87  
    5959        */ 
    6060        DistanceQueue *GetQueue(); 
    61         /** Returns true if node 1 has greater distance to the view 
    62                 plane than node 2. 
    63                 @param node1 the first node to be compared 
    64                 @param node2 the second node to be compared 
     61        /** Returns distance of the node to the view plane. 
     62                @param node1 the hierarchy node 
    6563        */                       
    66         virtual bool HasGreaterDistance(HierarchyNode *node1, HierarchyNode *node2) const = 0; 
     64        virtual float GetSquaredDistance(HierarchyNode *node) const = 0; 
    6765        /** Checks if the node is visible from the current view frustum. 
    6866                @param node the current node 

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

    r86 r87  
    2020                @remark the query counts the number of visible pixels between it's begin and end 
    2121        */ 
    22         virtual void BeginQuery() const = 0; 
     22        virtual void BeginQuery() = 0; 
    2323        /** Ends occlusion query. 
    2424        */ 
    25         virtual void EndQuery() const = 0; 
     25        virtual void EndQuery() = 0; 
    2626}; 
    2727 

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

    r86 r87  
    77void CoherentHierarchicalCullingManager::RenderScene() 
    88{ 
    9         mNumFrustumCulledNodes = mNumQueryCulledNodes = 0; 
    10 //      OutputDebugString("Coherent Culling\n"); 
     9        InitFrame(); 
    1110 
    1211        QueryQueue queryQueue; 
    1312        unsigned int visiblePixels = 0; 
    1413        bool isAvailable = false; 
    15  
     14         
    1615        //-- PART 1: process finished occlusion queries 
    1716        while (!mHierarchyInterface->GetQueue()->empty() || !queryQueue.empty()) 
    … …  
    2120                                                                        mHierarchyInterface->GetQueue()->empty())) 
    2221                { 
     22            //if (mHierarchyInterface->GetQueue()->empty())OutputDebugString("empty\n"); 
     23                                                                 
    2324                        HierarchyNode *node = queryQueue.front().first; 
    2425                                                 
    … …  
    3536                        } 
    3637                } 
    37  
     38                 
    3839                //-- PART 2: hierarchical traversal 
    3940                if (!mHierarchyInterface->GetQueue()->empty()) 
    … …  
    6768                                 
    6869                                // identify nodes that we cannot skip queries for 
    69                                 bool mustQuery = !wasVisible || mHierarchyInterface->HasGeometry(node) ||  
    70                                         mHierarchyInterface->IsLeaf(node); 
     70                                // geometry not only in leaves => test for renderable geometry 
     71                                bool issueQuery = !wasVisible || mHierarchyInterface->HasGeometry(node); 
     72                                        //mHierarchyInterface->IsLeaf(node); 
    7173 
    7274                                // reset node's visibility classification  
    … …  
    7678                                mHierarchyInterface->SetLastVisited(node, mHierarchyInterface->GetFrameId()); 
    7779                         
    78                                 // skip testing previously visible interior nodes 
    79                                 if (mustQuery) 
     80                                // skip testing previously visible nodes without geometry 
     81                                if (issueQuery) 
    8082                                { 
    81                                         queryQueue.push(QueryPair(node,  
    82                                                 mHierarchyInterface->IssueOcclusionQuery(node, wasVisible))); 
     83                                        mNumQueriesIssued ++; 
     84 
     85                                        queryQueue.push(QueryPair(node, mHierarchyInterface-> 
     86                                                IssueOcclusionQuery(node, wasVisible))); 
    8387                                } 
    8488                                         

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

    r74 r87  
    66CullingManager::CullingManager(): 
    77mHierarchyInterface(NULL), mVisibilityThreshold(0), mNumQueryCulledNodes(0),  
    8 mNumFrustumCulledNodes(0) 
     8mNumFrustumCulledNodes(0), mNumQueriesIssued(0) 
    99{ 
    1010} 
    … …  
    2929        return mNumQueryCulledNodes; 
    3030} 
     31//----------------------------------------------------------------------- 
     32unsigned int CullingManager::GetNumQueriesIssued() 
     33{ 
     34        return mNumQueriesIssued; 
     35} 
     36//----------------------------------------------------------------------- 
     37void CullingManager::InitFrame() 
     38{ 
     39        mNumFrustumCulledNodes = mNumQueryCulledNodes = mNumQueriesIssued = 0; 
     40} 
    3141} // namespace GtpVisibility 

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

    r86 r87  
    77void FrustumCullingManager::RenderScene() 
    88{ 
    9         mNumFrustumCulledNodes = mNumQueryCulledNodes = 0; 
    10         //OutputDebugString("Frustum Culling\n"); 
     9        InitFrame(); 
    1110 
    1211        while (!mHierarchyInterface->GetQueue()->empty()) 

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

    r86 r87  
    77void StopAndWaitCullingManager::RenderScene() 
    88{ 
    9         mNumFrustumCulledNodes = mNumQueryCulledNodes = 0; 
    10         //OutputDebugString("Stop and Wait Culling\n"); 
    11  
     9        InitFrame(); 
     10                         
    1211        while (!mHierarchyInterface->GetQueue()->empty()) 
    1312        { 
    1413                HierarchyNode *node = mHierarchyInterface->GetQueue()->top(); 
    1514                mHierarchyInterface->GetQueue()->pop(); 
    16                  
     15                         
    1716                // interesting for visualization purpose 
    1817                mHierarchyInterface->SetNodeVisible(node, false); 
    … …  
    3534                        } 
    3635 
     36                        mNumQueriesIssued ++; 
     37 
    3738                        unsigned int visiblePixels = 0; 
    3839 

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

    r74 r87  
    2828        bool IsLeaf(GtpVisibility::HierarchyNode *node) const; 
    2929        bool HasGeometry(GtpVisibility::HierarchyNode *node) const; 
    30         bool HasGreaterDistance(GtpVisibility::HierarchyNode *node1,  
    31                                                     GtpVisibility::HierarchyNode *node2) const; 
     30        float GetSquaredDistance(GtpVisibility::HierarchyNode *node) const; 
    3231         
    3332        void SetNodeVisible(GtpVisibility::HierarchyNode *node, const bool visible); 
    … …  
    4443        */ 
    4544        AxisAlignedBox *GetBoundingBox(GtpVisibility::HierarchyNode *node); 
    46         /** Returns squared distance of center of box with respect to the camera . 
    47                 @param cam current camera 
    48                 @param box axis aligned box 
    49         */ 
    50         Real GetSquaredViewDepth(const Camera* cam, const AxisAlignedBox* box) const; 
     45         
    5146        unsigned int mNumOctreeNodes; 
    5247}; 

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

    r74 r87  
    3535        bool IsLeaf(GtpVisibility::HierarchyNode *node) const; 
    3636        bool HasGeometry(GtpVisibility::HierarchyNode *node) const; 
    37         bool HasGreaterDistance(GtpVisibility::HierarchyNode *node1,  
    38                                                     GtpVisibility::HierarchyNode *node2) const; 
     37        float GetSquaredDistance(GtpVisibility::HierarchyNode *node) const; 
    3938         
    4039        void SetNodeVisible(GtpVisibility::HierarchyNode *node, const bool visible); 

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

    r86 r87  
    2222        virtual bool GetQueryResult(unsigned int &queryResult, 
    2323                const bool waitForResult) const; 
    24         virtual void BeginQuery() const; 
    25         virtual void EndQuery() const; 
     24        virtual void BeginQuery(); 
     25        virtual void EndQuery(); 
    2626 
    2727protected: 

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

    r85 r87  
    2525        void PullUpVisibility(GtpVisibility::HierarchyNode *node); 
    2626        bool HasGeometry(GtpVisibility::HierarchyNode *node) const; 
    27         bool HasGreaterDistance(GtpVisibility::HierarchyNode *node1,  
    28                                                     GtpVisibility::HierarchyNode *node2) const; 
     27        float GetSquaredDistance(GtpVisibility::HierarchyNode *node) const; 
    2928 
    3029        void SetNodeVisible(GtpVisibility::HierarchyNode *node, const bool visible); 

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

    r78 r87  
    5454        OctreeHierarchyInterface *mHierarchyInterface; 
    5555        GtpVisibility::VisibilityManager *mVisibilityManager; 
     56        bool mUseCulling; 
    5657}; 
    5758 

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

    r59 r87  
    5656        SceneNodeHierarchyInterface *mHierarchyInterface; 
    5757        GtpVisibility::VisibilityManager *mVisibilityManager; 
     58        bool mUseCulling; 
    5859}; 
    5960} // namespace Ogre 

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

    r59 r87  
    5757        OctreeHierarchyInterface *mHierarchyInterface; 
    5858        GtpVisibility::VisibilityManager *mVisibilityManager; 
     59        bool mUseCulling; 
    5960}; 
    6061 

  • trunk/VUT/Ogre/resources/VisibilityDemo.overlay

    r86 r87  
    99                left 5  
    1010                top 5 
    11                 width 450 
     11                width 400 
    1212                height 60 
    1313                material Core/StatsBlockCenter 
    … …  
    3333                        font_name TrebuchetMSBold 
    3434                        char_height 16 
    35                         caption [A] Algorithm 
     35                        caption [SPACE] Algorithm 
    3636                        colour_top 0.5 0.7 0.5 
    3737                        colour_bottom 0.3 0.5 0.3 
    … …  
    110110                vert_align top 
    111111                horz_align right 
    112                 left -355  
     112                left -250  
    113113                top 5 
    114                 width 450 
    115                 height 105 
     114                width 320 
     115                height 120 
    116116                material Core/StatsBlockCenter 
    117117                border_size 1 1 1 1 
    … …  
    256256                        colour_bottom 0.3 0.5 0.3 
    257257                } 
    258                 element TextArea(Example/Visibility/NumObjects) 
     258                element TextArea(Example/Visibility/Objects) 
    259259                { 
    260260                        metrics_mode pixels 
    … …  
    269269                        colour_bottom 0.3 0.5 0.3 
    270270                }        
    271                 element TextArea(Example/Visibility/NumObjectsInfo) 
     271                element TextArea(Example/Visibility/ObjectsInfo) 
    272272                { 
    273273                        metrics_mode pixels 
    … …  
    282282                        colour_bottom 0.3 0.5 0.3 
    283283                } 
    284  
    285  
     284                element TextArea(Example/Visibility/QueriesIssued) 
     285                { 
     286                        metrics_mode pixels 
     287                        left 5 
     288                        top 95 
     289                        width 180 
     290                        height 30 
     291                        font_name TrebuchetMSBold 
     292                        char_height 16 
     293                        caption Queries issued 
     294                        colour_top 0.5 0.7 0.5 
     295                        colour_bottom 0.3 0.5 0.3 
     296                }        
     297                element TextArea(Example/Visibility/QueriesIssuedInfo) 
     298                { 
     299                        metrics_mode pixels 
     300                        left 180 
     301                        top 95 
     302                        width 90 
     303                        height 30 
     304                        font_name TrebuchetMSBold 
     305                        char_height 16 
     306                        caption : 
     307                        colour_top 0.5 0.7 0.5 
     308                        colour_bottom 0.3 0.5 0.3 
     309                }                        
    286310        } 
    287311} 

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

    r74 r87  
    2626} 
    2727//----------------------------------------------------------------------- 
    28 bool BspHierarchyInterface::HasGreaterDistance(GtpVisibility::HierarchyNode *node1,  
    29                                                                                            GtpVisibility::HierarchyNode *node2) const 
     28float BspHierarchyInterface::GetSquaredDistance(GtpVisibility::HierarchyNode *node) const 
    3029{ 
    31         return true; 
    32 } 
    33 //----------------------------------------------------------------------- 
    34 Real BspHierarchyInterface::GetSquaredViewDepth(const Camera* cam, const AxisAlignedBox* box) const 
    35 {                                                             
    3630        return 0.0f; 
    3731} 

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

    r86 r87  
    1616        mNumTraversedNodes ++; 
    1717 
     18        Octree *octree = static_cast<Octree *>(node); 
     19 
    1820        // if we come across some renderable geometry => render it 
    19         RenderNode(node); 
     21        if (octree->mNodes.size() > 0) 
     22        { 
     23                RenderNode(node); 
     24        } 
    2025         
    21         for(int i=0; i<8; ++i) 
     26        // if not all subtrees are empty 
     27        if (octree->numNodes() > (int)octree->mNodes.size()) 
    2228        { 
    23                 Octree *nextChild =  
    24                         static_cast<Octree *>(node)->mChildren[(i & 4) >> 2][(i & 2) >> 1][i & 1]; 
     29                for(int i=0; i<8; ++i) 
     30                { 
     31                        Octree *nextChild =  
     32                                octree->mChildren[(i & 4) >> 2][(i & 2) >> 1][i & 1]; 
    2533 
    26         if (nextChild) 
    27                 { 
    28                         mDistanceQueue->push(nextChild); 
     34                        if (nextChild) 
     35                        { 
     36                                mDistanceQueue->push(nextChild); 
     37                        } 
    2938                } 
    3039        } 
    … …  
    4655bool OctreeHierarchyInterface::HasGeometry(GtpVisibility::HierarchyNode *node) const 
    4756{ 
    48         return static_cast<Octree *>(node)->numNodes() > 0; 
     57        return static_cast<Octree *>(node)->mNodes.size() > 0; 
    4958} 
    5059//----------------------------------------------------------------------- 
    … …  
    5463} 
    5564//----------------------------------------------------------------------- 
    56 bool OctreeHierarchyInterface::HasGreaterDistance(GtpVisibility::HierarchyNode *node1,  
    57                                                                                                   GtpVisibility::HierarchyNode *node2) const 
     65float OctreeHierarchyInterface::GetSquaredDistance(GtpVisibility::HierarchyNode *node) const 
    5866{ 
    59         return GetSquaredViewDepth(mCamera, &static_cast<Octree *>(node1)->mBox) >  
    60                    GetSquaredViewDepth(mCamera, &static_cast<Octree *>(node2)->mBox); 
    61 } 
    62 //----------------------------------------------------------------------- 
    63 Real OctreeHierarchyInterface::GetSquaredViewDepth(const Camera* cam,  
    64                                                                                                    const AxisAlignedBox* box) const 
    65 { 
     67        AxisAlignedBox *box = &static_cast<Octree *>(node)->mBox; 
    6668        Vector3 mid = ((box->getMinimum() - box->getMaximum()) * 0.5) + box->getMinimum(); 
    67         // use nearest point rather than midpoint 
    68         Vector3 camPos = cam->getDerivedPosition(); 
    6969 
    70         Vector3 minPos(camPos.x < mid.x ? box->getMinimum().x : box->getMaximum().x, 
    71                                    camPos.y < mid.y ? box->getMinimum().y : box->getMaximum().y, 
    72                                    camPos.z < mid.z ? box->getMinimum().z : box->getMaximum().z); 
    73          
    74         return (camPos - minPos).squaredLength();                                                                    
     70        return (mCamera->getDerivedPosition() - mid).squaredLength(); 
    7571} 
    7672//----------------------------------------------------------------------- 
    … …  
    113109                octant->setLastRendered(mFrameId); 
    114110 
    115                 if (!HasGeometry(octant)) return; 
    116  
    117111                static_cast<OctreeSceneManager *>(mSceneManager)->_renderOctant(mCamera, octant); 
    118112 

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

    r86 r87  
    2626void PlatformHierarchyInterface::DeleteQueries() 
    2727{ 
    28         for(unsigned int i=0; i < (unsigned int)mOcclusionQueries.size(); ++i) 
     28        for(int i=0; i < (int)mOcclusionQueries.size(); ++i) 
    2929                delete mOcclusionQueries[i]; 
    3030 
    … …  
    105105        query->BeginQuery(); 
    106106                         
    107         // if leaf and was visible => will be rendered anyway, thus we 
    108         // can also test with the real geometry  
    109         if(mUseOptimization && wasVisible && IsLeaf(node)) 
     107        // if node is leaf and was visible =>  
     108        // will be rendered anyway. 
     109        // In this case we can also test with the real geometry. 
     110        /*if(mUseOptimization && wasVisible && IsLeaf(node)) 
    110111        { 
    111         //      OutputDebugString("Using optimization!!\n"); 
    112112                RenderNode(node); 
    113113        } 
    114114        else 
    115         { 
    116         //      OutputDebugString("Not optimized!!\n"); 
     115        {*/ 
    117116                RenderBoundingBox(GetBoundingBox(node)); 
    118         } 
     117        //} 
    119118 
    120119        query->EndQuery(); 

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

    r86 r87  
    1414} 
    1515//----------------------------------------------------------------------- 
    16 void PlatformOcclusionQuery::BeginQuery() const 
     16void PlatformOcclusionQuery::BeginQuery() 
    1717{ 
    1818        mHardwareOcclusionQuery->beginOcclusionQuery(); 
    1919} 
    2020//----------------------------------------------------------------------- 
    21 void PlatformOcclusionQuery::EndQuery() const 
     21void PlatformOcclusionQuery::EndQuery() 
    2222{ 
    2323        mHardwareOcclusionQuery->endOcclusionQuery(); 

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

    r85 r87  
    5656bool SceneNodeHierarchyInterface::HasGeometry(GtpVisibility::HierarchyNode *node) const 
    5757{ 
    58         SceneNode *sceneNode = static_cast<SceneNode *>(node); 
    59          
    60         return sceneNode->numAttachedObjects() > 0; 
     58        return static_cast<SceneNode *>(node)->numAttachedObjects() > 0; 
    6159} 
    6260//----------------------------------------------------------------------- 
    … …  
    7472} 
    7573//----------------------------------------------------------------------- 
    76 bool SceneNodeHierarchyInterface::HasGreaterDistance(GtpVisibility::HierarchyNode *node1,  
    77                                                                                                          GtpVisibility::HierarchyNode *node2) const 
     74float SceneNodeHierarchyInterface::GetSquaredDistance(GtpVisibility::HierarchyNode *node) const 
    7875{ 
    79         SceneNode *sceneNode1 = static_cast<SceneNode *>(node1); 
    80         SceneNode *sceneNode2 = static_cast<SceneNode *>(node2); 
    81  
    82         return sceneNode1->getSquaredViewDepth(mCamera) > sceneNode2->getSquaredViewDepth(mCamera); 
     76        return static_cast<SceneNode *>(node)->getSquaredViewDepth(mCamera); 
    8377} 
    8478//----------------------------------------------------------------------- 

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

    r86 r87  
    1212//----------------------------------------------------------------------- 
    1313VisibilityOctreeSceneManager::VisibilityOctreeSceneManager( 
    14         GtpVisibility::VisibilityManager *visManager): mVisibilityManager(visManager) 
     14        GtpVisibility::VisibilityManager *visManager) 
     15: mVisibilityManager(visManager), mUseCulling(true) 
    1516{ 
    1617        mHierarchyInterface =  
    1718                new OctreeHierarchyInterface(this, mDestRenderSystem); 
    18  
     19//      visManager->SetCullingManager(GtpVisibility::VisibilityEnvironment::STOP_AND_WAIT_CULLING); 
    1920        //mDisplayNodes = true; 
    2021        //mShowBoundingBoxes = true; 
    2122        //mShowBoxes = true; 
     23 
    2224        mMaxDepth = 20; 
    2325} 
    … …  
    3032void VisibilityOctreeSceneManager::_renderVisibleObjects() 
    3133{ 
     34        mHierarchyInterface->InitFrame(mOctree, mCameraInProgress); 
     35        mVisibilityManager->GetCullingManager()->InitFrame(); 
     36 
     37        if(!mUseCulling) 
     38        {        
     39                OctreeSceneManager::_renderVisibleObjects(); 
     40                return; 
     41        }  
     42     
     43        //-- hierarchical culling 
     44        // the objects of different layers (e.g., background, scene,  
     45        // overlay) must be identified and rendered one after another 
     46 
    3247        //-- render background 
    3348        clearSpecialCaseRenderQueues(); 
    … …  
    3651 
    3752        setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE); 
    38         SceneManager::_renderVisibleObjects( ); 
     53        SceneManager::_renderVisibleObjects(); 
     54 
    3955#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    4056        _deleteRenderedQueueGroups(); 
    … …  
    4662        setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE); 
    4763 
    48         mHierarchyInterface->InitFrame(mOctree, mCameraInProgress); 
     64        //-- the hierarchical culling algorithm 
    4965        mVisibilityManager->ApplyVisibilityCulling(); 
    5066 
    … …  
    5369#endif 
    5470 
    55         //-- render rest, e.g., overlay 
     71        //-- render remaining objects, e.g., overlay 
    5672        clearSpecialCaseRenderQueues(); 
    5773        SceneManager::_renderVisibleObjects(); 
    58         //_deleteRenderedQueueGroups(); 
    5974} 
    6075//----------------------------------------------------------------------- 
    6176void VisibilityOctreeSceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters) 
    6277{ 
    63         // must be empty because objects are found and rendered in an interleaved fashion 
     78        // empty if hierarchical culling is used => 
     79        // we interleave identification and rendering of objects  
    6480        // in _renderVisibibleObjects  
     81        if(!mUseCulling) 
     82        { 
     83                OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters); 
     84        } 
    6585} 
    6686//----------------------------------------------------------------------- 
    … …  
    7898bool VisibilityOctreeSceneManager::setOption(const String & key, const void * val) 
    7999{ 
     100        if (key == "UseCulling") 
     101        { 
     102                mUseCulling = (*static_cast<const bool *>(val)); 
     103                return true; 
     104        } 
     105 
    80106        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface). 
    81107                setOption(key, val) || OctreeSceneManager::setOption(key, val); 

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

    r86 r87  
    5757                return true; 
    5858        } 
     59        if (key == "NumQueriesIssued") 
     60        { 
     61                * static_cast<unsigned int *>(val) =  
     62                        mVisibilityManager->GetCullingManager()->GetNumQueriesIssued(); 
     63                return true; 
     64        } 
    5965         
    6066        return false; 

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

    r74 r87  
    1313//----------------------------------------------------------------------- 
    1414VisibilitySceneManager::VisibilitySceneManager(GtpVisibility::VisibilityManager *visManager) 
    15 :mVisibilityManager(visManager) 
     15:mVisibilityManager(visManager), mUseCulling(true) 
    1616{ 
    1717        mHierarchyInterface = new SceneNodeHierarchyInterface(this, mDestRenderSystem); 
    … …  
    2525void VisibilitySceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters) 
    2626{ 
    27         // empty because we have to find objects in _renderVisibleObjects 
     27        // empty if hierarchical culling is used => 
     28        // we interleave identification and rendering of objects  
     29        // in _renderVisibibleObjects  
     30        if(!mUseCulling) 
     31        { 
     32                SceneManager::_findVisibleObjects(cam, onlyShadowCasters); 
     33        } 
    2834} 
    2935//----------------------------------------------------------------------- 
    3036void VisibilitySceneManager::_renderVisibleObjects() 
    3137{ 
    32                 //-- render background 
     38        mHierarchyInterface->InitFrame(mSceneRoot, mCameraInProgress); 
     39        mVisibilityManager->GetCullingManager()->InitFrame(); 
     40 
     41        if(!mUseCulling) 
     42        {        
     43                SceneManager::_renderVisibleObjects(); 
     44                return; 
     45        }  
     46         
     47        //-- hierarchical culling 
     48        // the objects of different layers (e.g., background, scene,  
     49        // overlay) must be identified and rendered one after another 
     50 
     51        //-- render background 
    3352        clearSpecialCaseRenderQueues(); 
    3453        addSpecialCaseRenderQueue(RENDER_QUEUE_BACKGROUND); 
    … …  
    3655 
    3756        setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE); 
    38         SceneManager::_renderVisibleObjects( ); 
     57        SceneManager::_renderVisibleObjects(); 
    3958#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    4059        _deleteRenderedQueueGroups(); 
    4160#endif 
     61 
    4262        //-- render visible objects (i.e., all but overlay) 
    4363        clearSpecialCaseRenderQueues(); 
    … …  
    4565        setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE); 
    4666 
    47         mHierarchyInterface->InitFrame(mSceneRoot, mCameraInProgress); 
     67        //-- the hierarchical culling algorithm 
    4868        mVisibilityManager->ApplyVisibilityCulling(); 
    4969 
    … …  
    5474        //-- render overlay 
    5575        clearSpecialCaseRenderQueues(); 
    56         SceneManager::_renderVisibleObjects( ); 
    57  
    58         clearSpecialCaseRenderQueues(); 
     76        SceneManager::_renderVisibleObjects(); 
    5977} 
    6078//----------------------------------------------------------------------- 

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

    r86 r87  
    77#include <OgreCamera.h> 
    88 
    9 //#include <windows.h> 
     9#include <windows.h> 
    1010 
    1111namespace Ogre { 
    12 //namespace GtpVisibility { 
     12 
    1313//----------------------------------------------------------------------- 
    1414VisibilityTerrainSceneManager::VisibilityTerrainSceneManager( 
    15         GtpVisibility::VisibilityManager *visManager): mVisibilityManager(visManager) 
     15        GtpVisibility::VisibilityManager *visManager) 
     16: mVisibilityManager(visManager), mUseCulling(true) 
    1617{ 
    1718        mHierarchyInterface =  
    1819                new OctreeHierarchyInterface(this, mDestRenderSystem); 
    1920 
    20         //mShowBoxes = true; 
    2121        //mDisplayNodes = true; 
    2222        //mShowBoundingBoxes = true; 
    … …  
    3131void VisibilityTerrainSceneManager::_renderVisibleObjects() 
    3232{ 
     33        mHierarchyInterface->InitFrame(mOctree, mCameraInProgress); 
     34        mVisibilityManager->GetCullingManager()->InitFrame(); 
     35 
     36        if(!mUseCulling) 
     37        {        
     38                OctreeSceneManager::_renderVisibleObjects(); 
     39                return; 
     40        }  
     41         
     42        //-- hierarchical culling 
     43        // the objects of different layers (e.g., background, scene,  
     44        // overlay) must be identified and rendered one after another 
     45 
    3346        //-- render background 
    3447        clearSpecialCaseRenderQueues(); 
    … …  
    4760        setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE); 
    4861 
    49         mHierarchyInterface->InitFrame(mOctree, mCameraInProgress); 
     62        //-- the hierarchical culling algorithm 
    5063        mVisibilityManager->ApplyVisibilityCulling(); 
    5164 
    … …  
    5669        //-- render overlay 
    5770        clearSpecialCaseRenderQueues(); 
    58         SceneManager::_renderVisibleObjects( ); 
     71        SceneManager::_renderVisibleObjects(); 
    5972} 
    6073//----------------------------------------------------------------------- 
    6174void VisibilityTerrainSceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters) 
    6275{ 
    63         // must be empty because objects are found and rendered in an interleaved fashion 
     76        // empty if hierarchical culling is used => 
     77        // we interleave identification and rendering of objects  
    6478        // in _renderVisibibleObjects  
     79        if(!mUseCulling) 
     80        { 
     81                OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters); 
     82        } 
    6583} 
    6684//----------------------------------------------------------------------- 
    … …  
    7997bool VisibilityTerrainSceneManager::setOption(const String & key, const void * val) 
    8098{ 
     99        if (key == "UseCulling") 
     100        { 
     101                mUseCulling = (*static_cast<const bool *>(val)); 
     102                return true; 
     103        } 
     104 
    81105        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface). 
    82106                setOption(key, val) || TerrainSceneManager::setOption(key, val); 
    … …  
    115139        return mVisibilityManager; 
    116140} 
    117 //} // namespace GtpVisibility 
    118141} // namespace Ogre 

  • trunk/VUT/chcdemo/HierarchyNode.h

    r86 r87  
    109109        static void InitKdTree(HierarchyNode *root); 
    110110 
    111         float GetDistance(); 
     111        float GetSquaredDistance(); 
    112112        void SetDistance(float distance); 
    113113 

  • trunk/VUT/work/TestCulling/SceneContentGenerator.cpp

    r86 r87  
    2121mMinAngle(Vector3(0.0f, 0.0f, 0.0f)), 
    2222mMaxAngle(Vector3(360, 360, 360)), 
    23 mScale(0.05, 0.05, 0.05) 
     23mScale(0.1, 0.1, 0.1) 
    2424{ 
    2525} 

  • trunk/VUT/work/TestCulling/TestCullingApplication.cpp

    r86 r87  
    110110mSceneContentGenerator(sceneContentGenerator), 
    111111mVisibilityThreshold(0), 
    112 mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING) 
     112mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING), 
     113mShowOctree(true), 
     114mUseCulling(false) 
    113115{ 
    114116    // Reduce move speed 
    … …  
    132134        mHierarchyNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/HierarchyNodesInfo"); 
    133135        mRenderedNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/RenderedNodesInfo"); 
    134         mNumObjectsInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/NumObjectsInfo"); 
     136        mObjectsInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/ObjectsInfo"); 
    135137        mUseOptimizationInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/UseOptimizationInfo"); 
     138        mQueriesIssuedInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/QueriesIssuedInfo"); 
    136139 
    137140        mAlgorithmInfo->setCaption(": " + mCurrentAlgorithmCaptions[mCurrentAlgorithm]); 
    … …  
    142145        mHierarchyNodesInfo->setCaption(": 0"); 
    143146        mRenderedNodesInfo->setCaption(": 0"); 
    144         mNumObjectsInfo->setCaption(": 0"); 
     147        mObjectsInfo->setCaption(": 0"); 
    145148        mUseOptimizationInfo->setCaption(": true"); 
     149        mQueriesIssuedInfo->setCaption(": 0"); 
    146150 
    147151        setAlgorithm(mCurrentAlgorithm); 
    … …  
    226230        KEY_PRESSED(KC_ADD, 0, changeThreshold(10)); 
    227231        KEY_PRESSED(KC_O, 0.3, toggleUseOptimization()); 
    228         //KEY_PRESSED(KC_T, 1, change); 
    229        
    230         changeStats(); 
     232        KEY_PRESSED(KC_C, 0.3, toggleUseCulling()); 
     233               
     234        updateStats(); 
    231235 
    232236    return ExampleFrameListener::frameStarted(evt) && ExampleFrameListener::frameEnded(evt);         
    … …  
    271275} 
    272276//----------------------------------------------------------------------- 
     277void MouseQueryListener::toggleUseCulling() 
     278{ 
     279        mUseCulling = !mUseCulling; 
     280 
     281        mSceneMgr->setOption("UseCulling", &mUseCulling); 
     282} 
     283//----------------------------------------------------------------------- 
    273284void MouseQueryListener::setAlgorithm(int algorithm) 
    274285{ 
    … …  
    277288} 
    278289//----------------------------------------------------------------------- 
    279 void MouseQueryListener::changeStats() 
     290void MouseQueryListener::updateStats() 
    280291{ 
    281292        unsigned int opt = 0; 
    … …  
    285296        mFrustumCulledNodesInfo->setCaption(str); 
    286297         
     298        mSceneMgr->getOption("NumQueriesIssued", &opt); sprintf(str,": %d", opt);  
     299        mQueriesIssuedInfo->setCaption(str); 
     300 
    287301        mSceneMgr->getOption("NumQueryCulledNodes", &opt); sprintf(str,": %d", opt);  
    288302        mQueryCulledNodesInfo->setCaption(str); 
    … …  
    298312 
    299313        sprintf(str,": %d", mSceneContentGenerator->GetObjectCount());  
    300         mNumObjectsInfo->setCaption(str); 
     314        mObjectsInfo->setCaption(str); 
    301315} 
    302316//----------------------------------------------------------------------- 

  • trunk/VUT/work/TestCulling/TestCullingApplication.h

    r86 r87  
    6363        void setAlgorithm(int algorithm); 
    6464        void changeThreshold(int incr); 
    65         void changeStats(); 
     65        void updateStats(); 
    6666        void toggleUseOptimization(); 
    6767        void toggleShowOctree(); 
     68        void toggleUseCulling(); 
    6869 
    6970protected: 
    … …  
    8485        OverlayElement *mHierarchyNodesInfo; 
    8586        OverlayElement *mRenderedNodesInfo; 
    86         OverlayElement *mNumObjectsInfo; 
     87        OverlayElement *mObjectsInfo; 
    8788        OverlayElement *mUseOptimizationInfo; 
     89        OverlayElement *mQueriesIssuedInfo; 
    8890 
    8991        SceneContentGenerator *mSceneContentGenerator; 
    … …  
    9193        bool mUseOptimization; 
    9294        bool mShowOctree; 
     95        bool mUseCulling; 
    9396}; 
    9497 

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

    r85 r87  
    5050//----------------------------------------------------------------------- 
    5151TerrainContentGenerator::TerrainContentGenerator(SceneManager *sm): 
    52 SceneContentGenerator(sm), mMaxHeight(100) 
     52SceneContentGenerator(sm), mMaxHeight(50) 
    5353{ 
    5454        mMinPos = Vector3(0.0f, 5000.0f, 0.0f); 

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

    r86 r87  
    9696 
    9797        mTerrainContentGenerator = new TerrainContentGenerator(mSceneMgr); 
    98          
    99         mTerrainContentGenerator->GenerateScene(500, "ninja.mesh"); 
    100         mTerrainContentGenerator->GenerateScene(500, "robot.mesh"); 
     98//      mTerrainContentGenerator->GenerateScene(500, "ninja.mesh"); 
     99        mTerrainContentGenerator->GenerateScene(1000, "robot.mesh"); 
    101100 
    102101        // no limitations needed anymore: the user can set  
    … …  
    150149mTerrainContentGenerator(sceneGenerator), 
    151150mVisibilityThreshold(0), 
    152 mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING) 
     151mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING), 
     152mShowOctree(true), 
     153mUseCulling(false) 
    153154{ 
    154155        // Reduce move speed 
    … …  
    174175        mHierarchyNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/HierarchyNodesInfo"); 
    175176        mRenderedNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/RenderedNodesInfo"); 
    176         mNumObjectsInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/NumObjectsInfo"); 
     177        mObjectsInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/ObjectsInfo"); 
    177178        mUseOptimizationInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/UseOptimizationInfo"); 
    178  
     179        mQueriesIssuedInfo = OverlayManager::getSingleton().getOverlayElement("Example/Visibility/QueriesIssuedInfo"); 
     180         
    179181        mAlgorithmInfo->setCaption(": " + mCurrentAlgorithmCaptions[mCurrentAlgorithm]); 
    180182        mThresholdInfo->setCaption(": 0"); 
    … …  
    184186        mHierarchyNodesInfo->setCaption(": 0"); 
    185187        mRenderedNodesInfo->setCaption(": 0"); 
    186         mNumObjectsInfo->setCaption(": 0"); 
     188        mObjectsInfo->setCaption(": 0"); 
    187189        mUseOptimizationInfo->setCaption(": true"); 
     190        mQueriesIssuedInfo->setCaption(": 0"); 
    188191 
    189192        setAlgorithm(mCurrentAlgorithm); 
    190193        toggleUseOptimization(); 
    191194        toggleShowOctree(); 
     195        toggleUseCulling(); 
    192196 
    193197    pOver->show(); 
    … …  
    301305        KEY_PRESSED(KC_O, 0.3, toggleUseOptimization()); 
    302306        KEY_PRESSED(KC_S, 0.3, toggleShowOctree()); 
    303         //KEY_PRESSED(KC_T, 1, change); 
    304        
    305         changeStats(); 
     307        KEY_PRESSED(KC_C, 0.3, toggleUseCulling()); 
     308               
     309        updateStats(); 
    306310 
    307311    return ExampleFrameListener::frameStarted(evt) && ExampleFrameListener::frameEnded(evt);         
    … …  
    329333void MouseQueryListener::setAlgorithm(int algorithm) 
    330334{ 
    331         //OutputDebugString("changing algorithm\n"); 
    332335        mAlgorithmInfo->setCaption(": " + mCurrentAlgorithmCaptions[mCurrentAlgorithm]); 
    333336        mSceneMgr->setOption("Algorithm", &mCurrentAlgorithm); 
    334337} 
    335338//----------------------------------------------------------------------- 
    336 void MouseQueryListener::changeStats() 
     339void MouseQueryListener::updateStats() 
    337340{ 
    338341        unsigned int opt = 0; 
    … …  
    342345        mFrustumCulledNodesInfo->setCaption(str); 
    343346         
     347        mSceneMgr->getOption("NumQueriesIssued", &opt); sprintf(str,": %d", opt);  
     348        mQueriesIssuedInfo->setCaption(str); 
     349         
    344350        mSceneMgr->getOption("NumQueryCulledNodes", &opt); sprintf(str,": %d", opt);  
    345351        mQueryCulledNodesInfo->setCaption(str); 
    … …  
    355361 
    356362        sprintf(str,": %d", mTerrainContentGenerator->GetObjectCount());  
    357         mNumObjectsInfo->setCaption(str); 
     363        mObjectsInfo->setCaption(str); 
    358364} 
    359365//----------------------------------------------------------------------- 
    … …  
    375381 
    376382        mSceneMgr->setOption("ShowOctree", &mShowOctree); 
     383} 
     384//----------------------------------------------------------------------- 
     385void MouseQueryListener::toggleUseCulling() 
     386{ 
     387        mUseCulling = !mUseCulling; 
     388 
     389        mSceneMgr->setOption("UseCulling", &mUseCulling); 
    377390} 
    378391//----------------------------------------------------------------------- 

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

    r86 r87  
    6262        void setAlgorithm(int algorithm); 
    6363        void changeThreshold(int incr); 
    64         void changeStats(); 
     64        void updateStats(); 
    6565        void toggleUseOptimization(); 
    6666        void toggleShowOctree(); 
     67        void toggleUseCulling(); 
    6768 
    6869protected: 
    … …  
    8485        OverlayElement *mUseOptimizationInfo; 
    8586        OverlayElement *mRenderedNodesInfo; 
    86         OverlayElement *mNumObjectsInfo; 
     87        OverlayElement *mObjectsInfo; 
     88        OverlayElement *mQueriesIssuedInfo; 
    8789 
    8890        SceneNode *mCurrentObject;         // The newly created object 
    … …  
    9496        bool mUseOptimization; 
    9597        bool mShowOctree; 
     98        bool mUseCulling; 
    9699}; 
    97100 
Note: See TracChangeset for help on using the changeset viewer.