Ignore:
Timestamp:
04/06/05 18:36:40 (19 years ago)
Author:
mattausch
Message:
 
Location:
trunk/VUT/OcclusionCullingSceneManager
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/OcclusionCullingSceneManager/include/OgreOcclusionCullingTerrainSceneManager.h

    r39 r40  
    1010 
    1111#include "OgrePrerequisites.h" 
    12 #include "OgreOcclusionCullingSceneTraverser.h" 
     12#include "OgreOcclusionCullingTerrainSceneTraverser.h" 
    1313//#include "OgreSolidHalfBoundingBox.h" 
    1414 
    … …  
    1616 
    1717namespace Ogre { 
    18         template <typename T> class octreeless 
    19         { 
    20         public: 
    21                 myless(Camera *cam) { mCamera = cam; } 
    22                 //bool operator() (HierarchyNode *v1, HierarchyNode *v2) const 
    23                 bool operator() (T v1, T v2) const 
    24                 { 
    25                         v1->getCullBounds(&mAabb); 
    26                         return mAabb->getSquaredViewDepth(mCamera) > v2->getSquaredViewDepth(mCamera); 
    27                 } 
    28  
    29         private: 
    30                 Camera *mCamera; 
    31                 AxisAlignedBox mAabb; 
    32         }; 
    33  
    3418        /** 
    3519                Class which implements a scene mangager which uses occlusion queries for culling occluded objects 
    … …  
    4125                ~OcclusionCullingTerrainSceneManager(); 
    4226         
    43                 //void _renderVisibleObjects(void); 
    44                 //void _findVisibleObjects(Camera* cam, bool onlyShadowCasters); 
    45                  
    46                 //void _updateSceneGraph(Camera* cam); 
     27                void _renderVisibleObjects(void); 
     28                void _findVisibleObjects(Camera* cam, bool onlyShadowCasters); 
     29                void _updateSceneGraph(Camera* cam); 
    4730 
    4831                /** Sets the given option for the SceneManager 
    … …  
    6245                bool getOptionKeys( StringVector &refKeys ); 
    6346 
     47                /** Renders one octant of an octree, i.e., renders current octant 
     48                        node and does not traverse deeper into the tree. 
     49                        @remark Note that OctreeNode instances are NOT part of the octree  
     50                        hierarchy, instead one octant of an Octree contains many OctreeNode instances. 
     51                        @param octree the octree to be rendered 
     52                        @param cam current camera 
     53                */ 
     54                void _renderOctant(Camera* cam, Octree *octree); 
     55 
    6456        protected: 
    65                 OcclusionCullingSceneTraverser *mOcclusionCullingSceneTraverser; 
     57                //OcclusionCullingTerrainSceneTraverser *mOcclusionCullingTerrainSceneTraverser; 
     58                OcclusionCullingSceneTraverser *mOcclusionCullingTerrainSceneTraverser; 
    6659        }; 
    6760 

  • trunk/VUT/OcclusionCullingSceneManager/include/OgreOcclusionCullingTerrainSceneTraverser.h

    r39 r40  
    88 
    99namespace Ogre { 
    10 void Octree::_getCullBounds( AxisAlignedBox *b ) 
     10        /** 
     11                This class implements the compare operator for the priority queue 
     12                especially for octree hierarchies using getCullBounds for bounding 
     13                box computation. A lower distance has a higher value in the queue. 
     14        */ 
     15        template <typename T> class octreeless  
     16        { 
     17        public: 
     18                octreeless(Camera *cam) { mCamera = cam; } 
     19                 
     20                bool operator() (T v1, T v2) const 
     21                { 
     22                        AxisAlignedBox box1, box2; 
     23                        v1->_getCullBounds(&box1); 
     24                        v2->_getCullBounds(&box2); 
     25 
     26                        return getSquaredViewDepth(mCamera, &box1) > getSquaredViewDepth(mCamera, &box2); 
     27                } 
     28 
     29        private: 
     30                Real getSquaredViewDepth(const Ogre::Camera* cam, const Ogre::AxisAlignedBox* box) const 
     31                { 
     32                        Vector3 mid  = ((box->getMinimum() - box->getMaximum()) * 0.5) + box->getMinimum(); 
     33                        return (cam->getDerivedPosition() - mid).squaredLength();                                                                    
     34                } 
     35 
     36                Camera *mCamera; 
     37                //AxisAlignedBox mBox1, mBox2; 
     38                //Ogre::Vector3 min, max, mid, dist; 
     39        }; 
     40 
    1141        typedef pair<Octree *, HardwareOcclusionQuery *> OctreeQueryPair; 
    12         typedef priority_queue<Octree *, vector<Octree *>, myless<vector<Octree *>::value_type> > OctreePriorityQueue; 
     42        typedef priority_queue<Octree *, vector<Octree *>, octreeless<vector<Octree *>::value_type> > OctreePriorityQueue; 
    1343        //typedef queue<QueryPair> QueryQueue; 
    1444 
    15         class OcclusionCullingTerrainSceneTraverser: OcclusionCullingSceneTraverser 
     45        class OcclusionCullingTerrainSceneTraverser: public OcclusionCullingSceneTraverser 
    1646        { 
     47        public: 
     48                OcclusionCullingTerrainSceneTraverser(SceneManager *sm, RenderSystem *rsys); 
    1749                void renderScene( Camera *cam, Octree *root ); 
     50                 
     51        protected: 
     52                /** Renders the scene with view frustum culling only. */ 
    1853                void renderCullFrustum( Camera *cam ); 
    19                 void pullUpVisibility( Octree *node ); 
    20                 void traverseNode( Camera *cam, Octree *node ); 
     54                /** Renders the scene with the hierarchical stop and wait algorithm. */ 
     55                void renderStopAndWait( Camera *cam ); 
     56                /** Renders the scene with the coherent hierarchical algorithm and the query queye. */ 
     57                void renderCoherentWithQueue( Camera *cam ); 
     58                /** Issue a occlusion query for this node. */ 
     59                 
     60                void pullUpVisibility( Octree *octree ); 
     61                void traverseOctree( Camera *cam, Octree *octree ); 
     62                void renderOctree( Camera *cam, Octree *octree ); 
    2163 
    22         protected: 
    2364                OctreePriorityQueue *mDistanceQueue; 
    2465        }; 

  • trunk/VUT/OcclusionCullingSceneManager/scripts/Plugin_OcclusionCullingSceneManager.vcproj

    r36 r40  
    145145                        Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm"> 
    146146                        <File 
    147                                 RelativePath="..\src\OgreOcclusionCullingDotSceneManager.cpp"> 
    148                         </File> 
    149                         <File 
    150147                                RelativePath="..\src\OgreOcclusionCullingResourceManager.cpp"> 
    151148                        </File> 
    … …  
    158155                        <File 
    159156                                RelativePath="..\src\OgreOcclusionCullingSceneTraverser.cpp"> 
    160                         </File> 
    161                         <File 
    162                                 RelativePath="..\src\OgreOcclusionCullingTerrainSceneManager.cpp"> 
    163                         </File> 
    164                         <File 
    165                                 RelativePath="..\src\OgreOcclusionCullingTerrainSceneTraverser.cpp"> 
    166157                        </File> 
    167158                        <File 
    … …  
    173164                        Filter="h;hpp;hxx;hm;inl;inc"> 
    174165                        <File 
    175                                 RelativePath="..\include\OgreOcclusionCullingDotSceneManager.h"> 
    176                         </File> 
    177                         <File 
    178166                                RelativePath="..\include\OgreOcclusionCullingResourceManager.h"> 
    179167                        </File> 
    … …  
    183171                        <File 
    184172                                RelativePath="..\include\OgreOcclusionCullingSceneTraverser.h"> 
    185                         </File> 
    186                         <File 
    187                                 RelativePath="..\include\OgreOcclusionCullingTerrainSceneManager.h"> 
    188                         </File> 
    189                         <File 
    190                                 RelativePath="..\include\OgreOcclusionCullingTerrainSceneTraverser.h"> 
    191173                        </File> 
    192174                        <File 
    … …  
    197179                        Name="Resource Files" 
    198180                        Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"> 
     181                </Filter> 
     182                <Filter 
     183                        Name="TerrainSceneManager" 
     184                        Filter=""> 
     185                        <Filter 
     186                                Name="Source Files" 
     187                                Filter=""> 
     188                                <File 
     189                                        RelativePath="..\src\OgreOcclusionCullingTerrainSceneManager.cpp"> 
     190                                </File> 
     191                                <File 
     192                                        RelativePath="..\src\OgreOcclusionCullingTerrainSceneTraverser.cpp"> 
     193                                </File> 
     194                        </Filter> 
     195                        <Filter 
     196                                Name="Header Files" 
     197                                Filter=""> 
     198                                <File 
     199                                        RelativePath="..\include\OgreOcclusionCullingTerrainSceneManager.h"> 
     200                                </File> 
     201                                <File 
     202                                        RelativePath="..\include\OgreOcclusionCullingTerrainSceneTraverser.h"> 
     203                                </File> 
     204                        </Filter> 
     205                </Filter> 
     206                <Filter 
     207                        Name="DotSceneManager" 
     208                        Filter=""> 
     209                        <Filter 
     210                                Name="Source Files" 
     211                                Filter=""> 
     212                                <File 
     213                                        RelativePath="..\src\OgreOcclusionCullingDotSceneManager.cpp"> 
     214                                </File> 
     215                        </Filter> 
     216                        <Filter 
     217                                Name="Header Files" 
     218                                Filter=""> 
     219                                <File 
     220                                        RelativePath="..\include\OgreOcclusionCullingDotSceneManager.h"> 
     221                                </File> 
     222                        </Filter> 
    199223                </Filter> 
    200224        </Files> 

  • trunk/VUT/OcclusionCullingSceneManager/src/OgreOcclusionCullingSceneTraverser.cpp

    r39 r40  
    4242                mCurrentTestIdx = 0; 
    4343 
    44 //mCurrentAlgorithm = RENDER_CULL_FRUSTUM; 
     44mCurrentAlgorithm = RENDER_CULL_FRUSTUM; 
    4545                switch(mCurrentAlgorithm) 
    4646                { 
    … …  
    148148                        { 
    149149                                // update node's visited flag  
     150                                char msg2[100]; 
     151                                sprintf(msg2,"yes, visible\n"); 
     152                                OutputDebugString(msg2); 
     153 
    150154                                node->setLastVisited(mFrameId); 
    151155                                node->setNodeVisible(true); 
    … …  
    154158                        else 
    155159                        {                        
     160                                char msg2[100]; 
     161                                sprintf(msg2,"no, invisible\n"); 
     162                                OutputDebugString(msg2); 
     163 
    156164                                mNumFrustumCulledNodes ++; 
    157165                        } 
    … …  
    252260                setRenderingMode(MODE_RENDER); 
    253261                 
    254                 //HACK (too slow) 
    255262                mSceneManager->_renderSceneNode(cam, node); 
    256263        } 
    … …  
    260267                //-- initialise occlusion queries. 
    261268                deleteQueries(); 
    262                  
    263                 //char str[100];sprintf(str, "num nodes: %d", mNumSceneNodes); 
    264                 //MessageBox( NULL, str, "this is my plugin", MB_OK | MB_ICONERROR | MB_TASKMODAL); 
    265269 
    266270                for(unsigned int i=0; i < mNumSceneNodes; i++) 

  • trunk/VUT/OcclusionCullingSceneManager/src/OgreOcclusionCullingTerrainSceneManager.cpp

    r34 r40  
    1414        OcclusionCullingTerrainSceneManager::OcclusionCullingTerrainSceneManager() 
    1515        { 
    16                 mOcclusionCullingSceneTraverser = new OcclusionCullingSceneTraverser(this, mDestRenderSystem); 
     16                //mOcclusionCullingTerrainSceneTraverser =  
     17                //      new OcclusionCullingTerrainSceneTraverser(this, mDestRenderSystem); 
     18 
     19                mOcclusionCullingTerrainSceneTraverser =  
     20                        new OcclusionCullingSceneTraverser(this, mDestRenderSystem); 
     21 
    1722                mDisplayNodes = true; 
    1823                //mShowBoundingBoxes = true; 
    … …  
    2227        OcclusionCullingTerrainSceneManager::~OcclusionCullingTerrainSceneManager() 
    2328        { 
    24                 delete mOcclusionCullingSceneTraverser; 
     29                delete mOcclusionCullingTerrainSceneTraverser; 
    2530        } 
    2631        //----------------------------------------------------------------------- 
    27         /*void OcclusionCullingTerrainSceneManager::_renderVisibleObjects(void) 
     32        void OcclusionCullingTerrainSceneManager::_renderVisibleObjects(void) 
    2833        { 
    29                 mOcclusionCullingSceneTraverser->renderScene(mCameraInProgress, mSceneRoot); 
     34                //-- render background 
     35                clearSpecialCaseRenderQueues(); 
     36                addSpecialCaseRenderQueue(RENDER_QUEUE_BACKGROUND); 
     37                addSpecialCaseRenderQueue(RENDER_QUEUE_SKIES_EARLY); 
     38         
     39                setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE); 
     40                SceneManager::_renderVisibleObjects( ); 
     41                _deleteRenderedQueueGroups(); 
     42 
     43                //-- render visible objects (i.e., all but overlay) 
     44                clearSpecialCaseRenderQueues(); 
     45                addSpecialCaseRenderQueue(RENDER_QUEUE_OVERLAY); 
     46                setSpecialCaseRenderQueueMode(SceneManager::SCRQM_EXCLUDE); 
     47 
     48                //mOcclusionCullingTerrainSceneTraverser->renderScene(mCameraInProgress, mOctree); 
     49                //mOcclusionCullingTerrainSceneTraverser->renderScene(mCameraInProgress, mTerrainRoot); 
     50                mOcclusionCullingTerrainSceneTraverser->renderScene(mCullCamera, mSceneRoot); 
     51                _deleteRenderedQueueGroups(); 
     52 
     53                //-- render overlay 
     54                clearSpecialCaseRenderQueues(); 
     55                SceneManager::_renderVisibleObjects( ); 
     56         
     57                clearSpecialCaseRenderQueues(); 
    3058        } 
    3159        //----------------------------------------------------------------------- 
    … …  
    3866        void OcclusionCullingTerrainSceneManager::_updateSceneGraph(Camera* cam) 
    3967        { 
    40         mOcclusionCullingSceneTraverser->preprocess(); 
     68        mOcclusionCullingTerrainSceneTraverser->setNumSceneNodes(mSceneNodes.size()); 
     69                mOcclusionCullingTerrainSceneTraverser->setRenderSystem(mDestRenderSystem); 
    4170 
     71        mOcclusionCullingTerrainSceneTraverser->preprocess(); 
     72                 
    4273                TerrainSceneManager::_updateSceneGraph(cam); 
    43         }*/ 
     74        } 
    4475        //----------------------------------------------------------------------- 
    4576        bool OcclusionCullingTerrainSceneManager::setOption( const String & key, const void * val ) 
    4677        { 
    47                 return mOcclusionCullingSceneTraverser->setOption( key, val) || TerrainSceneManager::setOption( key, val ); 
     78                return mOcclusionCullingTerrainSceneTraverser->setOption( key, val) || TerrainSceneManager::setOption( key, val ); 
    4879        } 
    4980        //----------------------------------------------------------------------- 
    5081        bool OcclusionCullingTerrainSceneManager::getOption( const String & key, void *val ) 
    5182        { 
    52                 return mOcclusionCullingSceneTraverser->getOption( key, val) || TerrainSceneManager::getOption( key, val ) ; 
     83                return mOcclusionCullingTerrainSceneTraverser->getOption( key, val) || TerrainSceneManager::getOption( key, val ) ; 
    5384        } 
    5485        //----------------------------------------------------------------------- 
    … …  
    6091        bool OcclusionCullingTerrainSceneManager::getOptionKeys( StringVector & refKeys ) 
    6192        { 
    62                 return mOcclusionCullingSceneTraverser->getOptionKeys ( refKeys ) || TerrainSceneManager::getOptionKeys( refKeys ); 
     93                return mOcclusionCullingTerrainSceneTraverser->getOptionKeys ( refKeys ) || TerrainSceneManager::getOptionKeys( refKeys ); 
     94        } 
     95        //----------------------------------------------------------------------- 
     96        void OcclusionCullingTerrainSceneManager::_renderOctant(Camera *cam, Octree *octant) 
     97        { 
     98                //Add stuff to be rendered; 
     99        NodeList::iterator it = octant->mNodes.begin(); 
     100 
     101        if ( mShowBoxes ) 
     102        { 
     103            mBoxes.push_back( octant->getWireBoundingBox() ); 
     104        } 
     105 
     106        while ( it != octant->mNodes.end() ) 
     107        { 
     108            OctreeNode *sn = *it; 
     109 
     110            mNumObjects++; 
     111 
     112                        // check bounding box visibility of scene nodes 
     113                        if( cam->isVisible( sn->_getWorldAABB() ) ) 
     114                        { 
     115                                sn->_addToRenderQueue(cam, getRenderQueue(), false ); 
     116                                //node->_findVisibleObjects(cam, getRenderQueue(), false, mDisplayNodes, false); 
     117                                mVisible.push_back( sn ); 
     118 
     119                                if ( mDisplayNodes ) 
     120                                { 
     121                                        getRenderQueue()->addRenderable( sn ); 
     122 
     123                                        // check if the scene manager or this node wants the bounding box shown. 
     124                                        if (sn->getShowBoundingBox() || mShowBoundingBoxes) 
     125                                                sn->_addBoundingBoxToQueue(getRenderQueue()); 
     126                                } 
     127                        } 
     128            ++it; 
     129        } 
     130 
     131                SceneManager::_renderVisibleObjects(); 
     132         
     133                // delete all rendered objects from renderqueue 
     134                _deleteRenderedQueueGroups(); 
    63135        } 
    64136}        

  • trunk/VUT/OcclusionCullingSceneManager/src/OgreOcclusionCullingTerrainSceneTraverser.cpp

    r39 r40  
    11#include "OgreOcclusionCullingTerrainSceneTraverser.h" 
    2 //#include <windows.h> 
     2#include "OgreOcclusionCullingTerrainSceneManager.h" 
     3 
     4#include <windows.h> 
    35 
    46namespace Ogre { 
    57        //----------------------------------------------------------------------- 
    6         void OcclusionCullingTerrainSceneTraverser::traverseNode( Camera *cam, Octree *node ) 
     8        OcclusionCullingTerrainSceneTraverser::OcclusionCullingTerrainSceneTraverser(SceneManager *sm, RenderSystem *rsys):  
     9        OcclusionCullingSceneTraverser(sm, rsys) 
     10        { 
     11        } 
     12        //----------------------------------------------------------------------- 
     13        void OcclusionCullingTerrainSceneTraverser::traverseOctree( Camera *cam, Octree *octree ) 
    714        { 
    815                mNumTraversedNodes ++; 
    916         
    10         /*      if(node->numAttachedObjects() > 0) 
     17                if(octree->numNodes() > 0) 
    1118                { 
    12                         renderSceneNode(cam, node); 
    13                 }*/ 
     19                        renderOctree(cam, octree); 
     20                } 
    1421 
    1522                for(int i=0; i<8; i++) 
    1623                { 
    17                         if(node->mChildren[i & 4][i & 2][i & 1] != 0) 
    18                                 traverseNode(cam, node->mChildren[i & 4][i & 2][i & 1]); 
     24                        char msg[100]; 
     25                        sprintf(msg,"current node: %d\n", i); 
     26                        OutputDebugString(msg); 
     27 
     28                        if(octree->mChildren[i & 4][i & 2][i & 1] != 0) 
     29                                traverseOctree(cam, octree->mChildren[i & 4][i & 2][i & 1]);                     
    1930                } 
    2031        } 
    2132        //----------------------------------------------------------------------- 
    2233        void OcclusionCullingTerrainSceneTraverser::renderScene( Camera *cam, Octree *root ) 
     34                //TODO: Renderscene independent from hierarchynode => implement only once 
    2335        { 
    2436                mNumTraversedNodes = 0; 
    … …  
    2739                mNumRenderedGeometry = 0; 
    2840                 
    29                 mDistanceQueue = new OctreePriorityQueue(myless<Octree *>(cam)); 
    30 //              mDistanceQueue->push(root); 
     41                mDistanceQueue = new OctreePriorityQueue(octreeless<Octree *>(cam)); 
     42                mDistanceQueue->push(root); 
    3143                mCurrentTestIdx = 0; 
    32  
     44                 
    3345mCurrentAlgorithm = RENDER_CULL_FRUSTUM; 
    3446                switch(mCurrentAlgorithm) 
    … …  
    3749                                renderCullFrustum(cam); 
    3850                        break; 
    39                 /*      case RENDER_STOP_AND_WAIT: 
     51                        case RENDER_STOP_AND_WAIT: 
    4052                                renderStopAndWait(cam); 
    4153                                break; 
    4254                        case RENDER_COHERENT: 
    4355                                renderCoherentWithQueue(cam); 
    44                                 break;*/ 
     56                                break; 
    4557                        default: 
    4658                                renderCullFrustum(cam); 
    … …  
    4860                }        
    4961                 
    50 //              delete mDistanceQueue; 
     62                delete mDistanceQueue; 
    5163 
    5264                mFrameId ++; 
    … …  
    5567        void OcclusionCullingTerrainSceneTraverser::renderCullFrustum(Camera *cam) 
    5668        { 
    57                 /*while(!mDistanceQueue->empty()) 
     69                AxisAlignedBox box; 
     70                FrustumPlane plane; 
     71 
     72                while(!mDistanceQueue->empty()) 
    5873                { 
    59                         SceneNode *node = mDistanceQueue->top(); 
     74                        Octree *octree = mDistanceQueue->top(); 
    6075                        mDistanceQueue->pop(); 
    6176         
    6277                        // interesting for visualization purpose 
    63                         node->setNodeVisible(false); 
    64                                  
    65                         if(cam->isVisible(node->_getWorldAABB())) 
    66                         { 
     78                        //TODO: octree->setNodeVisible(false); 
     79                        octree->_getCullBounds(&box); 
     80 
     81                        //if(cam->isVisible(box, &plane)) 
     82                        //{ 
    6783                                // update node's visited flag  
    68                                 node->setLastVisited(mFrameId); 
    69                                 node->setNodeVisible(true); 
    70                                 traverseNode(cam, node); 
    71                         } 
     84                                //TODO: octree->setLastVisited(mFrameId); 
     85                                //TODO: octree->setNodeVisible(true); 
     86                                traverseOctree(cam, octree); 
     87                        /*} 
    7288                        else 
    7389                        {                        
    7490                                mNumFrustumCulledNodes ++; 
    75                         } 
    76                 }*/ 
     91                        }*/ 
     92                } 
    7793        }        
     94         
     95        /** Renders the scene with the hierarchical stop and wait algorithm. */ 
     96        void OcclusionCullingTerrainSceneTraverser::renderStopAndWait( Camera *cam ) 
     97        { 
     98        } 
     99 
     100        /** Renders the scene with the coherent hierarchical algorithm and the query queye. */ 
     101        void OcclusionCullingTerrainSceneTraverser::renderCoherentWithQueue( Camera *cam ) 
     102        { 
     103        } 
     104         
    78105        //----------------------------------------------------------------------- 
    79106/*      bool OcclusionCullingTerrainSceneTraverser::isLeaf( SceneNode *node ) 
    … …  
    85112        { 
    86113        } 
     114        //----------------------------------------------------------------------- 
     115        void OcclusionCullingTerrainSceneTraverser::renderOctree( Camera *cam, Octree *octree ) 
     116        { 
     117                setRenderingMode(MODE_RENDER); 
     118                ((OcclusionCullingTerrainSceneManager *)mSceneManager)->_renderOctant(cam, octree); 
     119        } 
    87120}        
Note: See TracChangeset for help on using the changeset viewer.