Changeset 22


Ignore:
Timestamp:
03/21/05 01:59:03 (20 years ago)
Author:
gametools
Message:
 
Location:
trunk/VUT
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/VUT/OcclusionCullingSceneManager/TestCulling/TestCulling.vcproj

    r18 r22  
    2222                                Optimization="0" 
    2323                                AdditionalIncludeDirectories=""$(OGRE_PATH)\Dependencies\include";"$(OGRE_PATH)\OgreMain\include";"$(OGRE_PATH)\Samples\Common\include";"$(OGRE_PATH)\Dependencies\include\CEGUI";"$(OGRE_PATH)\Samples\Common\CEGUIRenderer\include"" 
    24                                 PreprocessorDefinitions="_WINDOWS,_STLP_USE_DYNAMIC_LIB,OGRE_LIBRARY_IMPORTS,_DEBUG,WIN32,_STLP_DEBUG" 
     24                                PreprocessorDefinitions="_WINDOWS;_STLP_USE_DYNAMIC_LIB;OGRE_LIBRARY_IMPORTS;_DEBUG;WIN32;_STLP_DEBUG;OGRE_COHERENT_OCCLUSION_CULLING" 
    2525                                MinimalRebuild="TRUE" 
    2626                                BasicRuntimeChecks="3" 

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

    r21 r22  
    2828 
    2929        typedef priority_queue<SceneNode *, vector<SceneNode *>, myless<vector<SceneNode *>::value_type> > PriorityQueue; 
    30  
     30        typedef queue<SceneNode *> QueryQueue; 
    3131        /** 
    3232                Class which implements a scene mangager which uses occlusion queries for culling occluded objects 
    … …  
    3636        public: 
    3737                enum {RENDER_CULL_FRUSTUM, RENDER_STOP_AND_WAIT, RENDER_COHERENT, NUM_RENDERMODES}; 
    38  
     38                 
    3939                OcclusionCullingSceneManager(); 
     40                ~OcclusionCullingSceneManager(); 
    4041         
    4142                /** Overriden from SceneManager. */ 
    4243                void _renderVisibleObjects(void); 
    4344                void _findVisibleObjects(Camera* cam, bool onlyShadowCasters); 
    44          
     45                void _updateSceneGraph(Camera* cam); 
     46 
    4547        protected: 
     48                enum {MODE_QUERY, MODE_RENDER}; 
    4649 
     50                int isLeaf(SceneNode *node); 
     51                int countSceneNodes(SceneNode *node); 
    4752                void renderZPass(); 
    4853                void traverseNode(SceneNode *node); 
    49                 void renderSceneNode(SceneNode *node); 
    50                 void switchMode(bool switch2QueryMode); 
     54                /** Renders current node */ 
     55                void render(SceneNode *node); 
     56                /** Sets rendering mode, e.g. query mode or render mode*/ 
     57                void setRenderingMode(int mode); 
    5158                 
     59                /** Renders the scene with view frustum culling only. */ 
     60                void renderCullFrustum(); 
     61                /** Renders the scene with the hierarchical stop and wait algorithm. */ 
    5262                void renderStopAndWait(); 
    53                 /** renders the scene with view frustum culling only */ 
    54                 void renderCullFrustum(); 
     63                /** Renders the scene with the coherent hierarchical algorithm and the query queye. */ 
     64                void renderCoherentWithQueue(); 
     65                /** Issue a occlusion query for this node. */ 
     66                void issueOcclusionQuery(SceneNode *node, bool wasVisible); 
     67                /** Pulls up the visibility from the child nodes. */ 
     68                void pullUpVisibility(SceneNode *node); 
    5569 
    56                 void issueOcclusionQuery(SceneNode *node, bool wasVisible); 
     70                void deleteQueries(); 
    5771 
    5872                /** we use a priority queue rather than a renderstack */ 
    5973                PriorityQueue *mDistanceQueue;  
    60                 // RenderQueue* mDistanceQueue; 
    6174 
    62                 int mFrameID; 
    63                 int mVisibilityThreshold; 
     75                unsigned int mFrameID; 
     76                unsigned int mVisibilityThreshold; 
     77                unsigned int mNumSceneNodes; 
    6478                int mCurrentTestIdx; 
    65                 bool mIsQueryMode; 
    66  
     79                int mQueryMode; 
     80                 
    6781                std::vector<HardwareOcclusionQuery *> mOcclusionQueries; 
    6882        }; 

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

    r18 r22  
    2121                                Optimization="0" 
    2222                                AdditionalIncludeDirectories="&quot;$(OGRE_PATH)\Samples\Common\include&quot;;&quot;$(OGRE_PATH)\Dependencies\include\CEGUI&quot;;&quot;$(OGRE_PATH)\Samples\Common\CEGUIRenderer\include&quot;;&quot;$(OGRE_PATH)\OgreMain\include&quot;;&quot;$(OGRE_PATH)\Dependencies\include&quot;;..\include" 
    23                                 PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;PLUGIN_OCCLUSIONCULLINGSCENEMANAGER_EXPORTS" 
     23                                PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;_USRDLL;PLUGIN_OCCLUSIONCULLINGSCENEMANAGER_EXPORTS;OGRE_COHERENT_OCCLUSION_CULLING" 
    2424                                MinimalRebuild="TRUE" 
    2525                                BasicRuntimeChecks="3" 

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

    r21 r22  
    1313        OcclusionCullingSceneManager::OcclusionCullingSceneManager():  
    1414        mFrameID(1), mDistanceQueue(NULL), mVisibilityThreshold(0), mCurrentTestIdx(0), 
    15         mIsQueryMode(false) 
     15        mQueryMode(MODE_RENDER), mNumSceneNodes(0) 
    1616        {                
    1717        } 
    18  
     18        //----------------------------------------------------------------------- 
    1919        void OcclusionCullingSceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters) 
    2020        { 
    2121                // empty because we have to find in _renderVisibleObjects 
    2222        } 
    23  
     23        //----------------------------------------------------------------------- 
     24        OcclusionCullingSceneManager::~OcclusionCullingSceneManager() 
     25        {                
     26                deleteQueries(); 
     27                SceneManager::~SceneManager(); 
     28        } 
    2429        //----------------------------------------------------------------------- 
    2530        void OcclusionCullingSceneManager::_renderVisibleObjects(void) 
    2631        { 
    2732                mDistanceQueue = new PriorityQueue(myless<SceneNode *>(mCameraInProgress)); 
     33                 
    2834                mDistanceQueue->push(mSceneRoot); 
    2935                //renderZPass(); 
    30                 renderCullFrustum(); 
     36                //renderCullFrustum(); 
     37                renderCoherentWithQueue(); 
    3138                delete mDistanceQueue; 
    32                 //mDestRenderSystem->_setDepthBufferParams(true, false, CMPF_LESS); 
    33                 //SceneManager::_renderVisibleObjects(); 
    34                 //mDestRenderSystem->_setDepthBufferParams(); 
    35         //mDistanceQueue.push(mSceneRoot); 
    36                 //Preprocess(); 
    37                  
    38                 //renderCullFrustum(); 
    39  
    40                 //mFrameID ++; 
    41                 //ResetQueries(); 
    42         } 
    43  
     39 
     40                /*mDestRenderSystem->_setDepthBufferParams(true, false, CMPF_LESS); 
     41                  SceneManager::_renderVisibleObjects(); 
     42                  mDestRenderSystem->_setDepthBufferParams(); 
     43          mDistanceQueue.push(mSceneRoot); 
     44                  Preprocess(); 
     45                  //ResetQueries(); 
     46                */ 
     47                 
     48                mFrameID ++; 
     49        } 
    4450        //----------------------------------------------------------------------- 
    4551        void OcclusionCullingSceneManager::renderZPass() 
    … …  
    4753                traverseNode(mSceneRoot); 
    4854        } 
    49  
     55        //----------------------------------------------------------------------- 
     56        void OcclusionCullingSceneManager::renderCoherentWithQueue() 
     57        { 
     58                QueryQueue queryQueue; 
     59 
     60                //-- PART 1: process finished occlusion queries 
     61                while(!mDistanceQueue->empty() || !queryQueue.empty()) 
     62                { 
     63                        while(!queryQueue.empty() &&  
     64                                  (queryQueue.front()->getOcclusionQuery()->resultAvailable() || mDistanceQueue->empty())) 
     65                        { 
     66                                SceneNode *node = queryQueue.front(); 
     67                                queryQueue.pop(); 
     68                         
     69                                // wait until result available 
     70                                unsigned int visiblePixels; 
     71                                node->getOcclusionQuery()->pullOcclusionQuery(&visiblePixels); 
     72 
     73                                if(visiblePixels > mVisibilityThreshold) 
     74                                { 
     75                                        pullUpVisibility(node); 
     76                                        traverseNode(node); 
     77                                } 
     78                        }        
     79 
     80                        //-- PART 2: hierarchical traversal 
     81                        if(!mDistanceQueue->empty()) 
     82                        { 
     83                                SceneNode *node = mDistanceQueue->top(); 
     84 
     85                                mDistanceQueue->pop(); 
     86         
     87                                if(mCameraInProgress->isVisible(node->_getWorldAABB())) 
     88                                { 
     89                                        // identify previously visible nodes 
     90                                        bool wasVisible = node->isNodeVisible() && (node->lastVisited() == mFrameID - 1); 
     91                                         
     92                                        // identify nodes that we cannot skip queries for 
     93                                        bool leafOrWasInvisible = !wasVisible || isLeaf(node); 
     94 
     95                                        // reset node's visibility classification  
     96                                        node->setVisible(false); 
     97 
     98                                        // update node's visited flag 
     99                                        node->setLastVisited(mFrameID); 
     100                                 
     101                                        // skip testing previously visible interior nodes 
     102                                        if(leafOrWasInvisible) 
     103                                        { 
     104                                                issueOcclusionQuery(node, wasVisible); 
     105                                                queryQueue.push(node); 
     106                                        } 
     107                                         
     108                                        // always traverse a node if it was visible 
     109                                        if(wasVisible) 
     110                                                traverseNode(node); 
     111                                } 
     112                        } 
     113                } 
     114        } 
    50115        //----------------------------------------------------------------------- 
    51116        void OcclusionCullingSceneManager::renderCullFrustum() 
    … …  
    67132                                traverseNode(node); 
    68133                        } 
    69                         //else 
    70                         //MessageBox( NULL, "myplugin registered", "this is my plugin", MB_OK | MB_ICONERROR | MB_TASKMODAL); 
    71                 } 
    72         } 
    73          
    74          
     134                } 
     135        }        
    75136        //----------------------------------------------------------------------- 
    76137        void OcclusionCullingSceneManager::renderStopAndWait() 
    … …  
    81142                        mDistanceQueue->pop(); 
    82143                 
    83                         // interesting for the visualization, so rest and set 
     144                        // interesting for the visualization 
    84145                        //node->SetVisible(false); 
     146                        node->setLastVisited(15); 
    85147 
    86148                        if(mCameraInProgress->isVisible(node->_getWorldAABB())) 
    … …  
    100162                } 
    101163        } 
    102  
     164        //----------------------------------------------------------------------- 
    103165        void OcclusionCullingSceneManager::issueOcclusionQuery(SceneNode *node, bool wasVisible) 
    104166        { 
    … …  
    107169         
    108170                // change state so the bounding box gets not actually rendered on the screen 
    109                 switchMode(false); 
    110                 node->_addBoundingBoxToQueue(getRenderQueue()); 
     171                setRenderingMode(MODE_QUERY); 
     172                //HACK: too slow 
     173        node->_addBoundingBoxToQueue(getRenderQueue()); 
    111174                SceneManager::_renderVisibleObjects(); 
    112175                getRenderQueue()->clear(); 
    113                 switchMode(true); 
    114  
     176                /* static RenderOperation ro; 
     177                   node->getRenderOperation(ro); 
     178                   ro.srcRenderable = node;  
     179                   mDestRenderSystem->_render(ro); */ 
     180                 
    115181                mOcclusionQueries[mCurrentTestIdx++]->endOcclusionQuery(); 
    116182        } 
    117183 
    118  
    119         //----------------------------------------------------------------------- 
    120         void OcclusionCullingSceneManager::switchMode(bool switch2QueryMode) 
     184        //----------------------------------------------------------------------- 
     185        void OcclusionCullingSceneManager::setRenderingMode(int mode) 
    121186        {        
    122                 // boolean used to avoid unnecessary state changes 
    123                 if(switch2QueryMode != mIsQueryMode) 
    124                 { 
    125                         mDestRenderSystem->_setColourBufferWriteEnabled(switch2QueryMode,  
    126                                 switch2QueryMode, switch2QueryMode, switch2QueryMode); 
    127                         mDestRenderSystem->_setDepthBufferWriteEnabled(switch2QueryMode); 
    128                         mDestRenderSystem->setLightingEnabled(switch2QueryMode); 
    129                         mIsQueryMode = switch2QueryMode; 
    130                 } 
    131         } 
    132          
    133  
     187                // avoid unnecessary state changes 
     188                if(mode != mQueryMode) 
     189                { 
     190                        bool enabled = (mode == MODE_RENDER); 
     191 
     192                        mDestRenderSystem->_setColourBufferWriteEnabled(enabled,  
     193                                enabled, enabled, enabled); 
     194                        mDestRenderSystem->_setDepthBufferWriteEnabled(enabled); 
     195                        mDestRenderSystem->setLightingEnabled(enabled); 
     196                        mQueryMode = mode; 
     197                } 
     198        } 
    134199        //----------------------------------------------------------------------- 
    135200        void OcclusionCullingSceneManager::traverseNode(SceneNode *node) 
    136201        { 
    137                 if(node->numChildren() == 0) // reached leaf 
    138                 { 
    139                         renderSceneNode(node); 
     202                if(isLeaf(node)) // reached leaf 
     203                { 
     204                        render(node); 
    140205                } 
    141206                else // internal node: add children to priority queue for further processing 
    142207                { 
    143208                        Node::ChildNodeIterator it = node->getChildIterator(); 
    144                         char str[100]; sprintf(str, "number of children: %d", node->numChildren()); 
    145                  
     209                                         
    146210                        while (it.hasMoreElements()) 
    147211                        {  
    … …  
    151215                        } 
    152216                 } 
    153  
    154                  /* 
    155                  static RenderOperation ro; 
    156                  node->getRenderOperation(ro); 
    157                  ro.srcRenderable = node;  
    158                  mDestRenderSystem->_render(ro); 
    159                  Pass pass(); 
    160                  renderSingleObject(node, &pass, true); 
    161                  */ 
    162         } 
    163  
    164         void OcclusionCullingSceneManager::renderSceneNode(SceneNode *node) 
    165         { 
     217        } 
     218        //----------------------------------------------------------------------- 
     219        void OcclusionCullingSceneManager::render(SceneNode *node) 
     220        { 
     221                setRenderingMode(MODE_RENDER); 
     222 
     223                //HACK (too slow) 
    166224                node->_findVisibleObjects(mCameraInProgress, getRenderQueue(), false,  
    167225                                                                  mDisplayNodes, false); 
    … …  
    169227                getRenderQueue()->clear(); 
    170228        } 
     229        //----------------------------------------------------------------------- 
     230        void OcclusionCullingSceneManager::_updateSceneGraph(Camera* cam) 
     231        { 
     232                int numnodes = countSceneNodes(mSceneRoot); 
     233                //char str[100]; sprintf(str, "number: %d", mNumSceneNodes); 
     234                //MessageBox( NULL, str, "this is my plugin", MB_OK | MB_ICONERROR | MB_TASKMODAL); 
     235                 
     236                //-- initialise occlusion queries. 
     237                if(numnodes != mNumSceneNodes) 
     238                { 
     239                        mNumSceneNodes = numnodes; 
     240 
     241                        deleteQueries(); 
     242 
     243                        for(int i=0; i < mNumSceneNodes; i++) 
     244                        { 
     245                                HardwareOcclusionQuery *hw = mDestRenderSystem->createHardwareOcclusionQuery(); 
     246                                mOcclusionQueries.push_back(hw); 
     247                        } 
     248                } 
     249 
     250                SceneManager::_updateSceneGraph(cam); 
     251        } 
     252        //----------------------------------------------------------------------- 
     253        int OcclusionCullingSceneManager::countSceneNodes(SceneNode *node) 
     254        { 
     255                int num = 1; 
     256                if(isLeaf(node)) 
     257                { 
     258                        return num; 
     259                } 
     260 
     261                Node::ChildNodeIterator it = node->getChildIterator(); 
     262                 
     263                while (it.hasMoreElements()) 
     264                {  
     265                        SceneNode* sceneChild = static_cast<SceneNode*>(it.getNext()); 
     266                        num += countSceneNodes(sceneChild); 
     267        } 
     268 
     269                return num; 
     270        } 
     271        //----------------------------------------------------------------------- 
     272        int OcclusionCullingSceneManager::isLeaf(SceneNode *node) 
     273        { 
     274                return (node->numChildren() == 0); 
     275        } 
     276        //----------------------------------------------------------------------- 
     277        void OcclusionCullingSceneManager::pullUpVisibility(SceneNode *node) 
     278        { 
     279                while(node && !node->isNodeVisible()) 
     280                { 
     281                        node->setNodeVisible(true); 
     282                        node = static_cast<SceneNode *>(node->getParent()); 
     283                } 
     284        } 
     285        //----------------------------------------------------------------------- 
     286        void OcclusionCullingSceneManager::deleteQueries() 
     287        { 
     288                for(int i=0; i < mNumSceneNodes; i++) 
     289                        delete mOcclusionQueries[i]; 
     290 
     291                mOcclusionQueries.clear(); 
     292        } 
    171293}        

  • trunk/VUT/chcdemo/RenderTraverser.h

    r10 r22  
    4747        // several statistics for a rendering pass 
    4848        long GetRenderTime(); 
    49         int  GetNumTraversedNodes(); 
     49        int GetNumTraversedNodes(); 
    5050        int GetNumQueryCulledNodes(); 
    5151        int GetNumFrustumCulledNodes(); 
Note: See TracChangeset for help on using the changeset viewer.