Changeset 52


Ignore:
Timestamp:
04/19/05 18:32:46 (19 years ago)
Author:
mattausch
Message:
 
Location:
trunk/VUT/OcclusionCullingSceneManager
Files:
13 edited

Legend:

Unmodified
Added
Removed

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

    r51 r52  
    5757        mMaxAngle = Vector3(360, 360, 360); 
    5858 
    59         /* 
    60         mWindow->getViewport(0)->setBackgroundColour(fadeColour); 
    61  
    62         Entity *ogreHeadEnt = mSceneMgr->createEntity("head", "ogrehead.mesh"); 
    63         mOgreHead = mSceneMgr->getRootSceneNode()->createChildSceneNode( "OgreHeadNode" ); 
    64         mOgreHead->attachObject(ogreHeadEnt); 
    65         */ 
    66         generateScene(4); 
     59        generateScene(330); 
     60 
    6761        // Create a skybox 
    6862    //mSceneMgr->setSkyBox(true, "Examples/CloudyNoonSkyBox", 1000, false); 
    69     ColourValue fadeColour(0.3, 0.9, 0.5); 
     63    ColourValue fadeColour(0.1, 0.1, 0.6); 
    7064        mWindow->getViewport(0)->setBackgroundColour(fadeColour); 
    7165 
    … …  
    176170        mSceneNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Occlusion/SceneNodesInfo"); 
    177171        mHierarchyNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Occlusion/HierarchyNodesInfo"); 
     172        mRenderedNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Occlusion/RenderedNodesInfo"); 
    178173 
    179174        mAlgorithmInfo->setCaption(": " + mCurrentAlgorithmCaptions[mCurrentAlgorithm]); 
    … …  
    184179        mSceneNodesInfo->setCaption(": 0"); 
    185180        mHierarchyNodesInfo->setCaption(": 0"); 
     181        mRenderedNodesInfo->setCaption(": 0"); 
    186182 
    187183    pOver->show(); 
    … …  
    306302        mSceneMgr->getOption("NumOctreeNodes", &opt); sprintf(str,": %d", opt);  
    307303        mHierarchyNodesInfo->setCaption(str); 
     304 
     305        mSceneMgr->getOption("NumRenderedNodes", &opt); sprintf(str,": %d", opt);  
     306        mRenderedNodesInfo->setCaption(str); 
    308307} 
    309308//----------------------------------------------------------------------- 

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

    r51 r52  
    7979        OverlayElement *mHierarchyNodesInfo; 
    8080        OverlayElement *mSceneNodesInfo; 
     81        OverlayElement *mRenderedNodesInfo; 
    8182}; 
    8283 

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

    r51 r52  
    183183        mSceneNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Occlusion/SceneNodesInfo"); 
    184184        mHierarchyNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Occlusion/HierarchyNodesInfo"); 
     185        mRenderedNodesInfo = OverlayManager::getSingleton().getOverlayElement("Example/Occlusion/RenderedNodesInfo"); 
    185186 
    186187        mAlgorithmInfo->setCaption(": " + mCurrentAlgorithmCaptions[mCurrentAlgorithm]); 
    … …  
    191192        mSceneNodesInfo->setCaption(": 0"); 
    192193        mHierarchyNodesInfo->setCaption(": 0"); 
    193  
     194        mRenderedNodesInfo->setCaption(": 0"); 
     195                 
    194196    pOver->show(); 
    195197}  
    … …  
    362364        mSceneMgr->getOption("NumOctreeNodes", &opt); sprintf(str,": %d", opt);  
    363365        mHierarchyNodesInfo->setCaption(str); 
     366 
     367        mSceneMgr->getOption("NumRenderedNodes", &opt); sprintf(str,": %d", opt);  
     368        mRenderedNodesInfo->setCaption(str); 
    364369} 
    365370//----------------------------------------------------------------------- 

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

    r48 r52  
    7979        OverlayElement *mHierarchyNodesInfo; 
    8080        OverlayElement *mSceneNodesInfo; 
     81        OverlayElement *mRenderedNodesInfo; 
    8182 
    8283        SceneNode *mCurrentObject;         // The newly created object 

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

    r45 r52  
    7474                 
    7575                void initDistanceQueue(Camera *cam); 
    76                 void pullUpVisibility( Camera *cam, Octree *octree ); 
    77                 void traverseOctant(Camera *cam, Octree *octant ); 
    78                 void renderOctant( Camera *cam, Octree *octant ); 
     76                void pullUpVisibility(Octree *octree); 
     77                void traverseOctant(Camera *cam, Octree *octant); 
     78                void renderOctant(Camera *cam, Octree *octant); 
    7979                bool isLeaf(Octree *octant); 
    8080 

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

    r51 r52  
    132132                */ 
    133133                HardwareOcclusionQuery *getNextOcclusionQuery(void); 
    134                 /** Pulls up the visibility from the child nodes. */ 
    135                 void pullUpVisibility( Camera *cam, SceneNode *node ); 
     134                /** Pulls up the visibility from the child node.  
     135                @param the child node  
     136                */ 
     137                void pullUpVisibility(SceneNode *node); 
    136138                /** delete all previously defined occlusion queries */ 
    137139                void deleteQueries(); 
    … …  
    171173                unsigned int mNumRenderedGeometry; 
    172174                unsigned int mNumRenderedNodes; 
    173  
     175                 
    174176        private: 
    175177                // the scene root 

  • trunk/VUT/OcclusionCullingSceneManager/scripts/OcclusionCullingDemo.overlay

    r42 r52  
    8787                top 5 
    8888                width 450 
    89                 height 90 
     89                height 105 
    9090                material Core/StatsBlockCenter 
    9191                border_size 1 1 1 1 
    … …  
    230230                        colour_bottom 0.3 0.5 0.3 
    231231                } 
     232                element TextArea(Example/Occlusion/RenderedNodes) 
     233                { 
     234                        metrics_mode pixels 
     235                        left 5 
     236                        top 80 
     237                        width 180 
     238                        height 30 
     239                        font_name TrebuchetMSBold 
     240                        char_height 16 
     241                        caption Rendered Nodes 
     242                        colour_top 0.5 0.7 0.5 
     243                        colour_bottom 0.3 0.5 0.3 
     244                }        
     245                element TextArea(Example/Occlusion/RenderedNodesInfo) 
     246                { 
     247                        metrics_mode pixels 
     248                        left 180 
     249                        top 80 
     250                        width 90 
     251                        height 30 
     252                        font_name TrebuchetMSBold 
     253                        char_height 16 
     254                        caption : 
     255                        colour_top 0.5 0.7 0.5 
     256                        colour_bottom 0.3 0.5 0.3 
     257                } 
     258 
    232259 
    233260        } 

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

    r45 r52  
    66Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TestCulling", "..\TestCulling\TestCulling.vcproj", "{248F19A6-2FE0-4F5D-8928-E0EA10609887}" 
    77        ProjectSection(ProjectDependencies) = postProject 
     8                {80DECC17-BDDD-4412-8CF8-F7C1C17A7436} = {80DECC17-BDDD-4412-8CF8-F7C1C17A7436} 
    89        EndProjectSection 
    910EndProject 

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

    r51 r52  
    1616                //mDisplayNodes = true; 
    1717                //mShowBoundingBoxes = true; 
    18                 mShowBoxes = true; 
    19                 mMaxDepth = 20; 
     18                //mShowBoxes = true; 
     19                //mMaxDepth = 20; 
    2020        } 
    2121        //----------------------------------------------------------------------- 
    … …  
    4343                mOcclusionCullingOctreeSceneTraverser->setSceneRoot(mOctree); 
    4444                mOcclusionCullingOctreeSceneTraverser->renderScene(mCameraInProgress); 
    45                  
     45 
    4646                _deleteRenderedQueueGroups(); 
    4747 
    48                 //-- render overlay 
     48                //-- render rest, e.g., overlay 
    4949                clearSpecialCaseRenderQueues(); 
    50                 SceneManager::_renderVisibleObjects( ); 
    51          
    52                 clearSpecialCaseRenderQueues(); 
     50                SceneManager::_renderVisibleObjects(); 
     51                //_deleteRenderedQueueGroups(); 
    5352        } 
    5453        //----------------------------------------------------------------------- 
    … …  
    6160        void OcclusionCullingOctreeSceneManager::_updateSceneGraph(Camera* cam) 
    6261        { 
    63                 //char *msg = "now updating scenegraph\n"; OutputDebugString(msg); 
    64                 //mOcclusionCullingOctreeSceneTraverser->preprocess(); 
    65  
    66         mOcclusionCullingOctreeSceneTraverser->setNumSceneNodes((int)mSceneNodes.size()); 
     62                mOcclusionCullingOctreeSceneTraverser->setNumSceneNodes((int)mSceneNodes.size()); 
    6763                mOcclusionCullingOctreeSceneTraverser->setRenderSystem(mDestRenderSystem); 
    6864         

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

    r51 r52  
    1818        } 
    1919        //----------------------------------------------------------------------- 
    20         void OcclusionCullingOctreeSceneTraverser::traverseOctant(Camera *cam, Octree *octant ) 
     20        void OcclusionCullingOctreeSceneTraverser::traverseOctant(Camera *cam, Octree *octant) 
    2121        { 
    2222                mNumTraversedNodes ++; 
    … …  
    3434 
    3535                        if(nextChild) 
     36                        { 
    3637                                mOctreeDistanceQueue->push(nextChild); 
     38                        } 
    3739                } 
    3840        } 
    … …  
    5153                        octant->_getCullBounds(&box); 
    5254                         
    53                         //if(static_cast<OctreeCamera *>(cam)->getVisibility(box) == OctreeCamera::NONE) 
    5455                        if(!cam->isVisible(box)) 
    5556                        { 
    … …  
    8586                        bool intersects = false; 
    8687 
     88                        /*char msg2[100]; 
     89                        Vector3 min = box.getMinimum(); 
     90                        Vector3 max = box.getMaximum(); 
     91 
     92                        sprintf(msg2, "culling box: %3.3f %3.3f %3.3f %3.3f %3.3f %3.3f\n", min.x, min.y, min.z, max.x, max.y, max.z); 
     93                        OutputDebugString(msg2);*/ 
     94 
    8795                        if(!cam->isVisible(box, intersects)) 
    8896                        { 
    … …  
    94102                        { 
    95103                                octant->setOctreeVisible(true); 
     104                        //      char msg[100]; sprintf(msg, "intersecting\n"); 
     105                        //      OutputDebugString(msg); 
    96106                                traverseOctant(cam, octant); 
    97107                                continue; 
    … …  
    103113                        // wait if result not available 
    104114                        query->pullOcclusionQuery(&visiblePixels); 
    105 //visiblePixels = 1; 
     115 
     116                        char msg[100]; sprintf(msg, "visible pixels: %d\n", visiblePixels, intersects); 
     117                        OutputDebugString(msg); 
     118 
    106119                        // node visible 
    107120                        if(visiblePixels > mVisibilityThreshold) 
    … …  
    111124                        else 
    112125                        { 
    113                                 char msg[100]; 
    114                                 Vector3 min = box.getMinimum(); 
    115                                 Vector3 max = box.getMaximum(); 
    116  
    117                                 sprintf(msg, "culling box: %3.3f %3.3f %3.3f %3.3f %3.3f %3.3f\n", min.x, min.y, min.z, max.x, max.y, max.z); 
    118                                 OutputDebugString(msg); 
    119  
    120126                                mNumQueryCulledNodes ++; 
    121127                        } 
    … …  
    143149                                unsigned int visiblePixels; 
    144150                                query->pullOcclusionQuery(&visiblePixels); 
    145 //visiblePixels = 1; 
     151 
    146152                                if(visiblePixels > mVisibilityThreshold) 
    147153                                { 
    148                                         pullUpVisibility(cam, octant); 
     154                                        pullUpVisibility(octant); 
    149155                                        traverseOctant(cam, octant); 
    150156                                } 
    … …  
    176182                                        // update octant's visited flag 
    177183                                        octant->setLastVisited(mFrameId); 
    178                                         pullUpVisibility(cam, octant);                   
     184 
     185                                        pullUpVisibility(octant);                        
    179186                                        traverseOctant(cam, octant); 
    180187 
    … …  
    185192                                bool wasVisible = octant->isOctreeVisible() && (octant->lastVisited() == mFrameId - 1); 
    186193                                 
    187                                 /* char msg[100]; 
     194                                /*  
     195                                char msg[100]; 
    188196                                if(wasVisible) sprintf(msg, "yes, was visible, %d\n", mFrameId); 
    189197                                else sprintf(msg, "no was invisible, %d\n", mFrameId); 
    190                                 OutputDebugString(msg);*/ 
     198                                OutputDebugString(msg); 
     199                                */ 
    191200 
    192201                                // identify nodes that we cannot skip queries for 
    193                                 bool leafOrWasInvisible = !wasVisible || isLeaf(octant); 
     202                                bool mustQuery = !wasVisible || (octant->numNodes() > 0) || isLeaf(octant); 
    194203 
    195204                                // reset node's visibility classification  
    … …  
    200209                         
    201210                                // skip testing previously visible interior nodes 
    202                                 if(leafOrWasInvisible) 
     211                                if(mustQuery) 
    203212                                { 
    204213                                        HardwareOcclusionQuery *query = issueOcclusionQuery(&box, wasVisible); 
    … …  
    215224        } 
    216225        //----------------------------------------------------------------------- 
    217         void OcclusionCullingOctreeSceneTraverser::pullUpVisibility( Camera *cam, Octree *octant ) 
     226        void OcclusionCullingOctreeSceneTraverser::pullUpVisibility( Octree *octant ) 
    218227        { 
    219228                while(octant && !octant->isOctreeVisible()) 
    220229                { 
    221                         // if we come across some renderable geometry => render it 
    222                         renderOctant(cam, octant); 
    223                          
    224230                        octant->setOctreeVisible(true); 
    225231                        octant = octant->getParent(); 
    … …  
    229235        void OcclusionCullingOctreeSceneTraverser::renderOctant( Camera *cam, Octree *octant ) 
    230236        { 
    231                 if(octant->numNodes() == 0) return; 
    232                 if(octant->lastVisited() != octant->lastRendered()) 
    233                 { 
     237                if(octant->lastRendered() != mFrameId) 
     238                { 
     239                        octant->setLastRendered(mFrameId); 
     240 
     241                        if(octant->numNodes() == 0) return; 
     242 
    234243                        //TODO: does nothing useful 
    235244                        setRenderingMode(MODE_RENDER); 
     245 
     246                        ((OctreeSceneManager *)mSceneManager)->_renderOctant(cam, octant); 
     247 
    236248                        mNumRenderedNodes ++; 
    237  
    238                         octant->setLastRendered(octant->lastVisited()); 
    239                         ((OctreeSceneManager *)mSceneManager)->_renderOctant(cam, octant); 
    240                 } 
    241                 //else OutputDebugString("already rendered"); 
    242         } 
    243         //----------------------------------------------------------------------- 
    244         void OcclusionCullingOctreeSceneTraverser::setSceneRoot(Octree *root) 
     249                } 
     250        } 
     251        //----------------------------------------------------------------------- 
     252        void OcclusionCullingOctreeSceneTraverser::setSceneRoot( Octree *root ) 
    245253        { 
    246254                mOctreeSceneRoot = root; 
    247255        } 
    248256        //----------------------------------------------------------------------- 
    249         void OcclusionCullingOctreeSceneTraverser::initDistanceQueue(Camera *cam) 
     257        void OcclusionCullingOctreeSceneTraverser::initDistanceQueue( Camera *cam ) 
    250258        { 
    251259                if(mOctreeDistanceQueue) 
    … …  
    274282        bool OcclusionCullingOctreeSceneTraverser::getOption( const String & key, void *val ) 
    275283        { 
    276                 if ( key == "NumOctreeNodes" ) 
     284                if (key == "NumOctreeNodes") 
    277285                { 
    278286                        * static_cast < unsigned int * > ( val ) = mNumOctreeNodes; 
    … …  
    285293        bool OcclusionCullingOctreeSceneTraverser::getOptionKeys( StringVector & refKeys ) 
    286294        { 
    287                 refKeys.push_back( "NumOctreeNodes" ); 
     295                refKeys.push_back("NumOctreeNodes"); 
    288296                 
    289297                return OcclusionCullingSceneTraverser::getOptionKeys(refKeys);           

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

    r51 r52  
    4949        //for(unsigned int i=0; i < 1000; i++) 
    5050                //mOcclusionQueries.push_back(mRenderSystem->createHardwareOcclusionQuery()); 
     51 
    5152            //mCurrentAlgorithm = RENDER_CULL_FRUSTUM; 
    5253 
    … …  
    6667                                break; 
    6768                }        
    68                  
     69 
    6970                mFrameId ++; 
    7071        } 
    … …  
    9192                                if(visiblePixels > mVisibilityThreshold) 
    9293                                { 
    93                                         pullUpVisibility(cam, node); 
     94                                        pullUpVisibility(node); 
    9495                                        traverseNode(cam, node); 
    9596                                } 
    … …  
    119120                                        // update node's visited flag 
    120121                                        node->setLastVisited(mFrameId); 
    121                                         pullUpVisibility(cam, node);                     
     122                                        pullUpVisibility(node);                  
    122123                                        traverseNode(cam, node); 
    123124 
    … …  
    129130                                         
    130131                                // identify nodes that we cannot skip queries for 
    131                                 bool leafOrWasInvisible = !wasVisible || isLeaf(node); 
     132                                bool mustQuery= !wasVisible || (node->numAttachedObjects() > 0) || isLeaf(node); 
    132133 
    133134                                // reset node's visibility classification  
    … …  
    137138                                node->setLastVisited(mFrameId); 
    138139                                 
    139                                 // skip testing previously visible interior nodes 
    140                                 if(leafOrWasInvisible) 
     140                                // skip testing previously visible interior nodes without geometry 
     141                                if(mustQuery) 
    141142                                { 
    142143                                        HardwareOcclusionQuery *query = issueOcclusionQuery(&node->_getWorldAABB(), wasVisible); 
    … …  
    235236                 
    236237                setRenderingMode(MODE_QUERY); 
    237                 //setRenderingMode(MODE_RENDER); 
     238                //mRenderSystem->_setRasterisationMode(SDL_SOLID);setRenderingMode(MODE_RENDER); 
    238239 
    239240                // get next available test id 
    … …  
    247248                query->endOcclusionQuery(); 
    248249 
     250                 
     251                //mRenderSystem->_setRasterisationMode(SDL_WIREFRAME); 
     252                setRenderingMode(MODE_RENDER); 
     253                renderBoundingBox(box); 
     254                //mRenderSystem->_setRasterisationMode(SDL_SOLID); 
     255                 
    249256                return query; 
    250257        } 
    … …  
    253260        {        
    254261                // avoid unnecessary state changes 
    255                 //if(mode != mQueryMode) 
    256                 //{ 
     262                if(mode != mQueryMode) 
     263                { 
     264                        mQueryMode = mode; 
    257265                        bool enabled = (mode == MODE_RENDER); 
    258 //if(mode == MODE_QUERY){ 
    259                         mRenderSystem->_setColourBufferWriteEnabled(enabled,  
    260                                 enabled, enabled, enabled); 
     266                         
     267                        //if(mode == MODE_RENDER) return; 
     268 
     269                        /* 
     270                        mRenderSystem->_setRasterisationMode(SDL_SOLID); 
     271                        mRenderSystem->_setSurfaceParams(ColourValue(0.9, 0.2, 0.2), 
     272                        ColourValue(0.2, 0.2, 0.2), ColourValue(0.2, 0.2, 0.2), 
     273                        ColourValue(0, 0, 0), Real(100)); 
     274                        mRenderSystem->_setDepthBufferCheckEnabled(false); 
     275                        mRenderSystem->_setAlphaRejectSettings(CMPF_ALWAYS_PASS, 255); 
     276                        */ 
     277 
     278                mRenderSystem->_setColourBufferWriteEnabled(enabled, enabled, enabled, enabled); 
    261279                        mRenderSystem->_setDepthBufferWriteEnabled(enabled); 
    262280                        mRenderSystem->setLightingEnabled(enabled); 
    263 //} 
    264                         mQueryMode = mode; 
    265                 //} 
     281                } 
    266282        } 
    267283        //----------------------------------------------------------------------- 
    … …  
    290306                setRenderingMode(MODE_RENDER); 
    291307                 
    292                 mSceneManager->_renderSceneNode(cam, node); 
     308                if(node->lastRendered() != node->lastVisited()) 
     309                { 
     310                        node->setLastRendered(node->lastVisited()); 
     311                        mNumRenderedNodes ++; 
     312 
     313                        mSceneManager->_renderSceneNode(cam, node); 
     314                } 
    293315        } 
    294316        //----------------------------------------------------------------------- 
    … …  
    334356        } 
    335357        //----------------------------------------------------------------------- 
    336         void OcclusionCullingSceneTraverser::pullUpVisibility( Camera *cam, SceneNode *node ) 
     358        void OcclusionCullingSceneTraverser::pullUpVisibility(SceneNode *node ) 
    337359        { 
    338360                while(node && !node->isNodeVisible()) 
    339361                { 
    340                         // if we come across some renderable geometry => render it 
    341                         if(node->numAttachedObjects() > 0) 
    342                         { 
    343                                 renderSceneNode(cam, node); 
    344                         } 
    345  
    346362                        node->setNodeVisible(true); 
    347363                        node = node->getParentSceneNode(); 
    … …  
    367383                        halfbox->setupBoundingBox(*box); 
    368384                         
    369                         //mRenderSystem->_setWorldMatrix(Matrix4::IDENTITY); 
     385                        mRenderSystem->_setWorldMatrix(Matrix4::IDENTITY); 
     386 
    370387                        // Set world transformation 
    371388                        /*halfbox->getWorldTransforms(xform); 
    … …  
    380397                                mRenderSystem->_setWorldMatrix(*xform); 
    381398                        } 
    382                         mRenderSystem->setClipPlanes(halfbox->getClipPlanes()); 
     399                        mRenderSystem->setClipPlanes(halfbox->getClipPlanes());*/ 
    383400 
    384401                        static RenderOperation ro; 
    … …  
    387404                        halfbox->getRenderOperation(ro); 
    388405                        ro.srcRenderable = halfbox;  
    389                         mRenderSystem->_render(ro);*/ 
    390  
    391                         mSceneManager->myrenderSingleObject(getSolidHalfBoundingBox(half),  
    392                                 getSolidHalfBoundingBox(half)->getTechnique()->getPass(0), false); 
     406                        mRenderSystem->_render(ro); 
     407 
     408                        //mSceneManager->myrenderSingleObject(getSolidHalfBoundingBox(half), getSolidHalfBoundingBox(half)->getTechnique()->getPass(0), true); 
    393409                } 
    394410        } 
    … …  
    480496                { 
    481497                        * static_cast < unsigned int * > ( val ) = mNumFrustumCulledNodes; 
     498                        return true; 
     499                } 
     500                if ( key == "NumRenderedNodes" ) 
     501                { 
     502                        * static_cast < unsigned int * > ( val ) = mNumRenderedNodes; 
    482503                        return true; 
    483504                } 
    … …  
    493514                refKeys.push_back( "NumQueryCulledNodes" ); 
    494515                refKeys.push_back( "NumFrustumCulledNodes" ); 
    495                 //refKeys.push_back( "mNumRenderedGeometry" ); 
     516                refKeys.push_back( "mNumRenderedGeometry" ); 
    496517 
    497518                return true; 

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

    r51 r52  
    1616                        new OcclusionCullingOctreeSceneTraverser(this, mDestRenderSystem); 
    1717 
     18                mShowBoxes = true; 
    1819                //mDisplayNodes = true; 
    1920                //mShowBoundingBoxes = true; 
    20                 mShowBoxes = true; 
    21                 mMaxDepth = 20; 
     21                //mMaxDepth = 20; 
    2222        } 
    2323        //----------------------------------------------------------------------- 
    … …  
    3535         
    3636                setSpecialCaseRenderQueueMode(SceneManager::SCRQM_INCLUDE); 
    37                 SceneManager::_renderVisibleObjects( ); 
     37                SceneManager::_renderVisibleObjects(); 
    3838                _deleteRenderedQueueGroups(); 
    3939 
    … …  
    5151                clearSpecialCaseRenderQueues(); 
    5252                SceneManager::_renderVisibleObjects( ); 
    53          
    54                 clearSpecialCaseRenderQueues(); 
    5553        } 
    5654        //----------------------------------------------------------------------- 
    … …  
    5957                // must be empty because objects are found and rendered in an interleaved fashion 
    6058                // in _renderVisibibleObjects  
    61                 //char *msg = "now finding visible objects\n"; OutputDebugString(msg); 
    6259        } 
    6360        //----------------------------------------------------------------------- 
    6461        void OcclusionCullingTerrainSceneManager::_updateSceneGraph(Camera* cam) 
    6562        { 
    66                 //char *msg = "now updating scenegraph\n"; OutputDebugString(msg); 
    67                 //mOcclusionCullingTerrainSceneTraverser->preprocess(); 
    68  
    69         mOcclusionCullingOctreeSceneTraverser->setNumSceneNodes((int)mSceneNodes.size()); 
     63                mOcclusionCullingOctreeSceneTraverser->setNumSceneNodes((int)mSceneNodes.size()); 
    7064                mOcclusionCullingOctreeSceneTraverser->setRenderSystem(mDestRenderSystem); 
    7165         
Note: See TracChangeset for help on using the changeset viewer.