Changeset 112 for trunk/VUT


Ignore:
Timestamp:
05/25/05 18:28:46 (20 years ago)
Author:
mattausch
Message:
 
Location:
trunk/VUT
Files:
27 edited

Legend:

Unmodified
Added
Removed

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

    r87 r112  
    4343        /** basic initializations on beginning of each frame, e.g.,  
    4444                resets statistics. 
     45                @param visualizeCulledNodes  
    4546        */ 
    46         void InitFrame(); 
     47        void InitFrame(bool visualizeCulledNodes); 
     48 
     49        /** Some visualization of culled nodes are shown, depending  
     50        on the type of hierarchy. 
     51        @param showVisualization if true, culled nodes are visualized 
     52        */ 
     53        void SetVisualizeCulledNodes(bool visualizeCulledNodes); 
    4754 
    4855protected: 
    … …  
    5461 
    5562        HierarchyInterface *mHierarchyInterface; 
     63        bool mVisualizeCulledNodes; 
    5664}; 
    5765} // namespace GtpVisibility 

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

    r111 r112  
    55 
    66namespace GtpVisibility { 
     7 
     8enum  CullingType {QUERY_CULLED, FRUSTUM_CULLED}; 
    79 
    810/**     Class which implements a hierarchy interface for a scene hierarchy. 
    … …  
    109111        */ 
    110112        void SetUseOptimization(bool useOptimization); 
     113        //bool mIsShadowPass; 
    111114 
    112         bool mDummy; 
     115        /** Visualization of a culled node, dependent on the culling type.  
     116                @param type can be one of FRUSTUM_CULLED, QUERY_CULLED 
     117        */ 
     118        virtual void VisualizeCulledNode(HierarchyNode *node,  
     119                CullingType type) = NULL; 
    113120 
    114121protected: 

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

    r111 r112  
    88{ 
    99        //InitFrame(); 
    10          
    1110        QueryQueue queryQueue; 
    1211        unsigned int visiblePixels = 0; 
    … …  
    3029                        } 
    3130                        else 
    32                         { 
    33                                 if (mHierarchyInterface->mDummy) 
     31                        {       //if (mHierarchyInterface->mIsShadowPass) 
    3432                                mNumQueryCulledNodes ++; 
     33                                 
     34                                if(mVisualizeCulledNodes) 
     35                                { 
     36                                        mHierarchyInterface->VisualizeCulledNode(node, QUERY_CULLED); 
     37                                } 
    3538                        } 
    3639                } 
    … …  
    4548 
    4649                        if (!mHierarchyInterface->CheckFrustumVisible(node, intersects)) 
    47                         {       if (mHierarchyInterface->mDummy) 
     50                        {//if (mHierarchyInterface->mIsShadowPass) 
    4851                                mNumFrustumCulledNodes ++; 
     52                                 
     53                                if(mVisualizeCulledNodes) 
     54                                { 
     55                                        mHierarchyInterface->VisualizeCulledNode(node, QUERY_CULLED); 
     56                                } 
    4957                        } 
    5058                        else 

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

    r87 r112  
    66CullingManager::CullingManager(): 
    77mHierarchyInterface(NULL), mVisibilityThreshold(0), mNumQueryCulledNodes(0),  
    8 mNumFrustumCulledNodes(0), mNumQueriesIssued(0) 
     8mNumFrustumCulledNodes(0), mNumQueriesIssued(0), 
     9mVisualizeCulledNodes(false) 
    910{ 
    1011} 
    … …  
    3536} 
    3637//----------------------------------------------------------------------- 
    37 void CullingManager::InitFrame() 
     38void CullingManager::SetVisualizeCulledNodes(bool visualizeCulledNodes) 
     39{ 
     40        mVisualizeCulledNodes = visualizeCulledNodes; 
     41} 
     42//----------------------------------------------------------------------- 
     43void CullingManager::InitFrame(bool visualizeCulledNodes) 
    3844{ 
    3945        mNumFrustumCulledNodes = mNumQueryCulledNodes = mNumQueriesIssued = 0; 
     46        mVisualizeCulledNodes = visualizeCulledNodes; 
    4047} 
    4148} // namespace GtpVisibility 

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

    r111 r112  
    1111        while (!mHierarchyInterface->GetQueue()->empty()) 
    1212        { 
    13                 if (mHierarchyInterface->mDummy) 
    14                         Ogre::LogManager::getSingleton().logMessage("shadow pass"); 
    15         //      elseOgre::LogManager::getSingleton().logMessage("no shadow pass"); 
    1613                HierarchyNode *node = mHierarchyInterface->GetQueue()->top(); 
    1714                mHierarchyInterface->GetQueue()->pop(); 
    … …  
    2219 
    2320                if (!mHierarchyInterface->CheckFrustumVisible(node)) 
    24                 {if (mHierarchyInterface->mDummy) 
     21                {//if (mHierarchyInterface->mIsShadowPass) 
    2522                        mNumFrustumCulledNodes ++; 
    2623                } 

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

    r111 r112  
    88HierarchyInterface::HierarchyInterface():  
    99mFrameId(0), mNumTraversedNodes(0), mNumRenderedNodes(0),  
    10 mSceneRoot(0), mPreviousNode(0), mCurrentTestIdx(0), mUseOptimization(true), 
    11 mDummy(false) 
     10mSceneRoot(0), mPreviousNode(0), mCurrentTestIdx(0), mUseOptimization(true) 
     11//, mIsShadowPass(false) 
    1212{        
    1313        mDistanceQueue = new DistanceQueue(GreaterDistance<HierarchyNode *>(this)); 

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

    r111 r112  
    2121 
    2222                if (!mHierarchyInterface->CheckFrustumVisible(node, intersects)) 
    23                 {if (mHierarchyInterface->mDummy) 
     23                {//if (mHierarchyInterface->mIsShadowPass) 
    2424                        mNumFrustumCulledNodes ++; 
    2525                } 
    … …  
    4646                        } 
    4747                        else 
    48                         { 
    49                                 if (mHierarchyInterface->mDummy) 
     48                        {       //if (mHierarchyInterface->mIsShadowPass) 
    5049                                mNumQueryCulledNodes ++; 
    5150                        } 

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

    r87 r112  
    4343        unsigned int LastVisited(GtpVisibility::HierarchyNode *node) const; 
    4444 
     45        void VisualizeCulledNode(GtpVisibility::HierarchyNode *node,  
     46                                                         GtpVisibility::CullingType type); 
     47 
    4548protected: 
    4649        /** Returns pointer to the bounding box of the node. 

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

    r111 r112  
    8686 
    8787protected: 
     88        /** materials for visualizing frustum and query culled nodes */ 
     89        void CreateCulledNodeMaterials(); 
     90 
    8891        /** A pass that prepares an occlusion query. 
    8992                @remark disables depth write, colour write, lighting, 

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

    r87 r112  
    3535 
    3636        AxisAlignedBox *GetBoundingBox(GtpVisibility::HierarchyNode *node); 
     37 
     38        void VisualizeCulledNode(GtpVisibility::HierarchyNode *node,  
     39                                                        GtpVisibility::CullingType type); 
    3740}; 
    3841 

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

    r100 r112  
    6060        bool mUseVisibilityCulling; 
    6161        bool mShowVisualization; 
     62        bool mRenderNodesForViz; 
     63        bool mVisualizeCulledNodes; 
    6264}; 
    6365 

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

    r103 r112  
    5959        bool mUseVisibilityCulling; 
    6060        bool mShowVisualization; 
     61 
     62        bool mVisualizeCulledNodes; 
    6163}; 
    6264} // namespace Ogre 

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

    r103 r112  
    6363        bool mShowVisualization; 
    6464        bool mRenderNodesForViz; 
     65        bool mVisualizeCulledNodes; 
    6566}; 
    6667 

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

    r103 r112  
    142142        return &mBox; 
    143143} 
     144//----------------------------------------------------------------------- 
     145void OctreeHierarchyInterface::VisualizeCulledNode(GtpVisibility::HierarchyNode *node,  
     146                                                                                                   GtpVisibility::CullingType type) 
     147{ 
     148        WireBoundingBox *box = static_cast<Octree *>(node)->getWireBoundingBox(); 
    144149 
     150        if (type == GtpVisibility::FRUSTUM_CULLED) 
     151        { 
     152                box->setMaterial("FrustumCulledNodesMaterial"); 
     153        } 
     154        else // type == GtpVisibility::QUERY_CULLED 
     155        { 
     156                box->setMaterial("QueryCulledNodesMaterial"); 
     157        } 
     158        static_cast<OctreeSceneManager *>(mSceneManager)->getBoxes()->push_back(box); 
     159        //LogManager::getSingleton().logMessage("pushing box"); 
     160} 
    145161} // namespace Ogre 

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

    r111 r112  
    1212mCamera(NULL), mCullCamera(NULL), mOnlyShadowCasters(false) 
    1313{ 
     14        CreateCulledNodeMaterials(); 
     15         
     16} 
     17//----------------------------------------------------------------------- 
     18void PlatformHierarchyInterface::CreateCulledNodeMaterials() 
     19{ 
     20        // material for frustum culled nodes 
     21        MaterialPtr mat = MaterialManager::getSingleton().getByName("FrustumCulledNodesMaterial"); 
     22        MaterialPtr baseWhite = MaterialManager::getSingleton().getByName("BaseWhiteNoLighting"); 
     23        if (mat.isNull()) 
     24        { 
     25                mat = MaterialManager::getSingleton().create("FrustumCulledNodesMaterial",  
     26                        ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 
     27 
     28                //baseWhite.get()->copyDetailsTo(mat); 
     29                //mat->setColourWriteEnabled(true); 
     30                mat->setLightingEnabled(false); 
     31                //mat->setAmbient(ColourValue(1,0,0)); 
     32        } 
     33 
     34        // material for query culled nodes 
     35        MaterialPtr mat2 = MaterialManager::getSingleton().getByName("QueryCulledNodesMaterial"); 
     36 
     37        if (mat2.isNull()) 
     38        { 
     39                mat2 = MaterialManager::getSingleton().create("QueryCulledNodesMaterial",  
     40                        ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME); 
     41                //baseWhite.get()->copyDetailsTo(mat2); 
     42        //      mat2->setColourWriteEnabled(true); 
     43                mat2->setLightingEnabled(false); 
     44                //mat2->setAmbient(ColourValue(0,0,1));          
     45        } 
    1446} 
    1547//----------------------------------------------------------------------- 
    … …  
    162194        // Set colour write mode off 
    163195        mRenderSystem->_setColourBufferWriteEnabled(false, false, false, false); 
    164         // Set colour write mode pff 
    165     mRenderSystem->_setColourBufferWriteEnabled(false, false, false, false); 
    166196} 
    167197//----------------------------------------------------------------------- 
    … …  
    177207{ 
    178208        mOnlyShadowCasters = onlyShadowCasters; 
    179         mDummy = mOnlyShadowCasters ; 
     209        //mIsShadowPass = mOnlyShadowCasters ; 
    180210} 
    181211//----------------------------------------------------------------------- 

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

    r111 r112  
    8787{ 
    8888        Matrix3 mat; 
    89         mat.FromEulerAnglesYXZ(Degree(rotation.x),//.valueRadians(),  
    90                                                    Degree(rotation.y),//.valueRadians(),  
    91                                                    Degree(rotation.z));//.valueRadians()); 
     89        mat.FromEulerAnglesYXZ(Degree(rotation.x), Degree(rotation.y), 
     90                                                   Degree(rotation.z)); 
    9291 
    9392        return GenerateSceneObject(position, Quaternion(mat), objName); 

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

    r103 r112  
    124124        return &mBox; 
    125125} 
     126//----------------------------------------------------------------------- 
     127void SceneNodeHierarchyInterface::VisualizeCulledNode(GtpVisibility::HierarchyNode *node,  
     128                                                                                                          GtpVisibility::CullingType type) 
     129{ 
     130        // TODO 
     131} 
    126132} // namespace Ogre      

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

    r103 r112  
    1212VisibilityOctreeSceneManager::VisibilityOctreeSceneManager( 
    1313        GtpVisibility::VisibilityManager *visManager) 
    14 : mVisibilityManager(visManager), mUseVisibilityCulling(true), 
    15 mShowVisualization(false) 
     14:  
     15mVisibilityManager(visManager),  
     16mUseVisibilityCulling(true), 
     17mShowVisualization(false), 
     18mRenderNodesForViz(false), 
     19mVisualizeCulledNodes(false) 
    1620{ 
    1721        mHierarchyInterface =  
    … …  
    3741                                                        mCullCamera ? getCamera("CullCamera") : NULL); 
    3842 
    39         // call initframe to reset culling manager stats 
    40         mVisibilityManager->GetCullingManager()->InitFrame(); 
    41  
    42         // standard terrain scenemanager rendering without hierarchical culling 
    43         if (!mUseVisibilityCulling || mShowVisualization) 
    44         {        
    45                 OctreeSceneManager::_renderVisibleObjects(); 
    46                 return; 
    47         }  
     43        if (!mShowVisualization) 
     44        { 
     45                // two cameras (one for culling, one for rendering) 
     46                mHierarchyInterface->InitFrame(mOctree, mCameraInProgress,  
     47                                                                mCullCamera ? getCamera("CullCamera") : NULL); 
     48 
     49                // call initframe to reset culling manager stats 
     50                mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes); 
     51        } 
    4852         
    4953        //-- hierarchical culling 
    … …  
    136140                return true; 
    137141        } 
     142        if (key == "RenderNodesForViz") 
     143        { 
     144                mRenderNodesForViz = (*static_cast<const bool *>(val)); 
     145                return true; 
     146        } 
     147        if (key == "SkyBoxEnabled") 
     148        { 
     149                mSkyBoxEnabled = (*static_cast<const bool *>(val)); 
     150                return true; 
     151        } 
     152        if (key == "SkyPlaneEnabled") 
     153        { 
     154                mSkyPlaneEnabled = (*static_cast<const bool *>(val)); 
     155                return true; 
     156        } 
     157        if (key == "SkyDomeEnabled") 
     158        { 
     159                mSkyDomeEnabled = (*static_cast<const bool *>(val)); 
     160                return true; 
     161        } 
     162        if (key == "VisualizeCulledNodes") 
     163        { 
     164                mVisualizeCulledNodes = (*static_cast<const bool *>(val)); 
     165                return true; 
     166        } 
    138167        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface). 
    139168                setOption(key, val) || OctreeSceneManager::setOption(key, val); 

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

    r111 r112  
    3838void VisibilitySceneManager::_renderVisibleObjects() 
    3939{ 
    40         // two cameras (one for culling, one for rendering) 
    41         mHierarchyInterface->InitFrame(mSceneRoot, mCameraInProgress); 
     40        if (!mShowVisualization) 
     41        { 
     42                // two cameras (one for culling, one for rendering) 
     43                mHierarchyInterface->InitFrame(mSceneRoot, mCameraInProgress); 
    4244 
    43         // call initframe to reset culling manager stats 
    44         mVisibilityManager->GetCullingManager()->InitFrame(); 
     45                // call initframe to reset culling manager stats 
     46                mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes); 
     47        } 
    4548 
    4649        // standard terrain scenemanager rendering without hierarchical culling 
    … …  
    4851        {        
    4952                SceneManager::_renderVisibleObjects(); 
     53         
    5054                return; 
    5155        }  
    52          
     56 
    5357        //-- hierarchical culling 
    5458        // the objects of different layers (e.g., background, scene,  

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

    r111 r112  
    1919mUseVisibilityCulling(true), 
    2020mShowVisualization(false), 
    21 mRenderNodesForViz(false) 
     21mRenderNodesForViz(false), 
     22mVisualizeCulledNodes(false) 
    2223{ 
    2324        mHierarchyInterface =  
    … …  
    6667                for (NodeList::iterator it = mVisible.begin(); it != mVisible.end(); ++it) 
    6768                { 
     69                        MaterialPtr mp = (*it)->getMaterial(); 
     70                         
     71                        mp.get()->setLightingEnabled(false); 
     72                        mp.get()->setAmbient(ColourValue(1,0,0)); 
     73                        mp.get()->setDiffuse(ColourValue(1,1,1)); 
     74                        mp.get()->setSpecular(ColourValue(1,1,1)); 
     75                         
     76                        mp.get()->getTechnique(0)->getPass(0)->removeAllTextureUnitStates(); 
     77                        //*mp = MaterialManager::getSingleton().getByName("BaseWhiteNoLighting"); 
     78                        //(*it)->setMaterialName("BaseWhiteNoLighting"); 
    6879                        getRenderQueue()->addRenderable(*it); 
    6980 
    … …  
    8596void VisibilityTerrainSceneManager::_renderVisibleObjects() 
    8697{ 
    87  
    8898        if (!mShowVisualization) 
    8999        { 
    … …  
    93103 
    94104                // call initframe to reset culling manager stats 
    95                 mVisibilityManager->GetCullingManager()->InitFrame(); 
    96         } 
    97  
     105                mVisibilityManager->GetCullingManager()->InitFrame(mVisualizeCulledNodes); 
     106        } 
     107         
    98108        // standard terrain scenemanager rendering without hierarchical culling 
    99109        if (!mUseVisibilityCulling || mShowVisualization) 
    … …  
    184194        { 
    185195                mSkyDomeEnabled = (*static_cast<const bool *>(val)); 
     196                return true; 
     197        } 
     198        if (key == "VisualizeCulledNodes") 
     199        { 
     200                mVisualizeCulledNodes = (*static_cast<const bool *>(val)); 
    186201                return true; 
    187202        } 

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

    r111 r112  
    113113mUseVisibilityCulling(true), 
    114114mUseOptimization(true), 
    115 mShowVisualization(false) 
     115mShowVisualization(false), 
     116mVisualizeCulledNodes(false) 
    116117{ 
    117118    // Reduce move speed 
    … …  
    293294 
    294295        mSceneMgr->setOption("ShowVisualization", &mShowVisualization); 
     296        mSceneMgr->setOption("VisualizeCulledNodes", &mVisualizeCulledNodes); 
    295297} 
    296298//----------------------------------------------------------------------- 

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

    r107 r112  
    9797        bool mShowVisualization; 
    9898 
     99        bool mVisualizeCulledNodes; 
     100 
    99101        Camera *mVizCamera; 
    100102}; 

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

    r111 r112  
    9393        // Set ambient light 
    9494        //mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5)); 
    95         mSceneMgr->setAmbientLight(ColourValue(0.0, 0.0, 0.0)); 
     95        mSceneMgr->setAmbientLight(ColourValue(0.5, 0.5, 0.5)); 
    9696 
    9797        //-- create light 
    … …  
    9999        mSunLight->setType(Light::LT_DIRECTIONAL); 
    100100        //mSunLight->setType(Light::LT_SPOTLIGHT); 
     101        //mSunLight->setSpotlightRange(Degree(30), Degree(50)); 
     102 
    101103    mSunLight->setPosition(707, 2000, 500); 
    102104        mSunLight->setCastShadows(true); 
    103105 
    104         //mSunLight->setSpotlightRange(Degree(30), Degree(50)); 
    105  
    106     Vector3 dir(0.5, 0.1, 0.5); 
     106        Vector3 dir(0.5, 0.5, 0.5); 
    107107        dir.normalise(); 
    108         mSunLight->setDirection(Vector3::NEGATIVE_UNIT_Y); 
     108        mSunLight->setDirection(dir); 
     109        //mSunLight->setDirection(Vector3::NEGATIVE_UNIT_Y); 
    109110 
    110111        mSunLight->setDiffuseColour(1, 1, 1); 
    … …  
    130131        setupGui(); 
    131132 
    132         //mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE); 
    133  
    134133        // Floor plane 
    135         Plane plane; 
     134        /*Plane plane; 
    136135        plane.normal = Vector3::UNIT_Y; 
    137136        plane.d = -60; 
    … …  
    142141        pPlaneEnt->setMaterialName("Examples/Rockwall"); 
    143142        pPlaneEnt->setCastShadows(true); 
    144         mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(pPlaneEnt); 
     143        mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(pPlaneEnt);*/ 
    145144 
    146145        if (mRoot->getRenderSystem()->getCapabilities()->hasCapability(RSC_HWRENDER_TO_TEXTURE)) 
    … …  
    154153                mSceneMgr->setShadowTextureSettings(512, 2); 
    155154        } 
    156         mSceneMgr->setShadowColour(ColourValue(0, 0, 0)); 
    157  // mSceneMgr->setShowDebugShadows(true); 
     155        //mSceneMgr->setShadowColour(ColourValue(0, 0, 0)); 
     156        mSceneMgr->setShadowColour(ColourValue(0.5, 0.5, 0.5)); 
     157    // mSceneMgr->setShowDebugShadows(true); 
    158158 
    159159 
    … …  
    175175 
    176176                // the objects are generated on the whole terrain 
    177                 mTerrainContentGenerator->GenerateScene(1500, "athene"); 
    178                 //mTerrainContentGenerator->GenerateScene(1500, "robot"); 
     177                //mTerrainContentGenerator->GenerateScene(1500, "athene"); 
     178                mTerrainContentGenerator->GenerateScene(1500, "robot"); 
    179179                //      mTerrainContentGenerator->GenerateScene(500, "ninja"); 
    180180        } 
    … …  
    245245mRecord(false), 
    246246mTimeElapsed(0), 
    247 mUseShadows(false) 
     247mUseShadows(false), 
     248mVisualizeCulledNodes(false) 
    248249{ 
    249250        // Reduce move speed 
    … …  
    704705{ 
    705706        mShowVisualization = !mShowVisualization; 
     707        mVisualizeCulledNodes = !mVisualizeCulledNodes; 
    706708 
    707709        // create viewport with priority VIZ_VIEWPORT_Z_ORDER:  
    … …  
    718720        mVizCamera->setAspectRatio(Real(vizvp->getActualWidth()) /  
    719721                        Real(vizvp->getActualHeight())); 
     722                 
     723                mSceneMgr->setOption("VisualizeCulledNodes", &mVisualizeCulledNodes); 
    720724                //vizvp->setClearEveryFrame(false); 
    721725 
    … …  
    732736        { 
    733737                mWindow->removeViewport(VIZ_VIEWPORT_Z_ORDER); 
    734                 // if octree was enabled for visualization purpose 
     738                // if octree was enabled for visualization purpose, reset now 
    735739                mSceneMgr->setOption("ShowOctree", &mShowOctree); 
    736740        } 

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

    r111 r112  
    165165        Real mTimeElapsed; 
    166166        bool mUseShadows; 
     167 
     168        bool mVisualizeCulledNodes; 
    167169}; 
    168170 

  • trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/include/OgreOctreeSceneManager.h

    r103 r112  
    111111        */ 
    112112        void _renderOctant(Camera* cam, Octree *octree, bool onlyShadowCasters); 
     113 
     114        /** Returns stored list of boxes */ 
     115        BoxList *getBoxes(); 
    113116#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    114117 

  • trunk/VUT/work/ogre_changes/Plugins/OctreeSceneManager/src/OgreOctreeSceneManager.cpp

    r103 r112  
    11671167} 
    11681168#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
     1169//-----------------------------------------------------------------------        
     1170BoxList *OctreeSceneManager::getBoxes() 
     1171{ 
     1172        return &mBoxes; 
     1173} 
    11691174//----------------------------------------------------------------------- 
    11701175void OctreeSceneManager::_renderOctant(Camera *cam, Octree *octant, bool onlyShadowCasters) 
Note: See TracChangeset for help on using the changeset viewer.