Changeset 130 for trunk/VUT/Ogre


Ignore:
Timestamp:
06/14/05 02:50:05 (20 years ago)
Author:
mattausch
Message:

added visibility queries

Location:
trunk/VUT/Ogre
Files:
15 edited

Legend:

Unmodified
Added
Removed

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

    r112 r130  
    33 
    44#include <OgreOctree.h> 
    5 #include "OgrePlatformHierarchyInterface.h" 
     5#include <OgreOctreeSceneManager.h> 
     6#include "OgreSceneNodeHierarchyInterface.h" 
    67 
    78namespace Ogre { 
    … …  
    910        This class implements the hierarchy interface for the Ogre octree hierarchy. 
    1011*/ 
    11 class OctreeHierarchyInterface : public PlatformHierarchyInterface 
     12class OctreeHierarchyInterface : public SceneNodeHierarchyInterface 
    1213{ 
    1314public: 
    14         OctreeHierarchyInterface(SceneManager *sm, RenderSystem *rsys); 
     15        OctreeHierarchyInterface(OctreeSceneManager *sm, RenderSystem *rsys); 
    1516         
    1617        /** Sets the number of nodes in this octree  
    … …  
    4647                                                         GtpVisibility::CullingType type); 
    4748 
     49        /*bool FindVisibleObjects(GtpVisibility::HierarchyNode *node,    
     50                                                        InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,  
     51                                                        bool includeChildren = false);*/ 
     52        void GetGeometry(GtpVisibility::HierarchyNode *node, 
     53                                         GtpVisibility::GeometryList *geometryList,  
     54                                         bool includeChildren); 
     55 
    4856protected: 
    4957        /** Returns pointer to the bounding box of the node. 
    … …  
    5765        */ 
    5866        Real GetSquaredViewDepth(const Camera* cam, const AxisAlignedBox* box) const; 
     67        /** number of octree hierarchy nodes */ 
    5968        unsigned int mNumOctreeNodes; 
    6069}; 

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

    r121 r130  
    1010#include "OgreSolidBoundingBox.h" 
    1111#include "HierarchyInterface.h" 
     12#include "VisibilityInfo.h" 
    1213#include "OgrePlatformOcclusionQuery.h" 
    1314 
    … …  
    5152                @remark If null, the actual camera is used for both viewing and culling          
    5253        */ 
    53         void InitFrame(GtpVisibility::HierarchyNode *root, Camera *cam, Camera *cullCam = NULL, bool leaveTransparentsInQueue = false); 
     54        void InitFrame(GtpVisibility::HierarchyNode *root, Camera *cam, Camera *cullCam = NULL,  
     55                bool leaveTransparentsInQueue = false); 
    5456        /** Checks if the node is visible from the current view frustum. 
    5557                @param node the current node 
    … …  
    7880                GtpVisibility::HierarchyNode *node, const bool wasVisible); 
    7981 
     82        /** Issue a occlusion query for this mesh. 
     83                @param node the current mesh 
     84                @returns occlusion query for this node 
     85        */ 
     86        GtpVisibility::OcclusionQuery *IssueOcclusionQuery(GtpVisibility::Mesh *mesh); 
     87 
    8088        /** If true, the interface finds and renders only objects which are marked as shadow casters. 
    8189                @remark This is important for the shadow texture pass 
    8290        */ 
    8391        void SetOnlyShadowCasters(bool onlyShadowCasters); 
    84         /** see set */ 
     92        /** see set  
     93        */ 
    8594        bool GetOnlyShadowCasters(); 
    86         /** see set */ 
     95        /** see set  
     96        */ 
    8797        bool GetUseOptimization(); 
     98        /** see set 
     99        */ 
     100        SceneManager *GetSceneManager(); 
    88101 
    89         /** true if bounding box query is currently active. */ 
     102        /** see set  
     103        */ 
     104        RenderSystem *GetRenderSystem(); 
     105         
     106        /** true if bounding box query is currently active.  
     107        */ 
    90108    bool IsBoundingBoxQuery(); 
    91109 
     110        /** Finds visible objects of hierarchy node using occlusion queries 
     111        @param node the current scene node 
     112        @param objs the visible objects 
     113        @param includeChildren if the children of current scene nodes should also be traversed 
     114        */ 
     115        /*virtual bool FindVisibleObjects(GtpVisibility::HierarchyNode *node,    
     116                                                                        InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,  
     117                                                                        bool includeChildren = false) = 0;*/ 
    92118protected: 
    93         /** materials for visualizing frustum and query culled nodes */ 
     119        /** Renders geometry  
     120        */ 
     121        void RenderGeometry(GtpVisibility::Mesh *geom); 
     122 
     123        /** Materials for visualizing frustum and query culled nodes. 
     124        */ 
    94125        void CreateNodeVizMaterials(); 
     126 
     127        /** Deletes all occlusion queries. 
     128        */ 
     129        void DeleteQueries(); 
     130         
     131        /** Renders bounding box of specified node. 
     132                @param box the bounding box of the scene node to be rendered  
     133        */ 
     134        void RenderBoundingBox(AxisAlignedBox *box); 
     135 
     136        /** Returns pointer to current renderable bounding box geometry. 
     137        */ 
     138        SolidBoundingBox *GetSolidBoundingBox(); 
    95139 
    96140        /** A pass that prepares an occlusion query. 
    … …  
    98142                vertex and fragment program. 
    99143        */ 
    100         void SetOcclusionPass(); 
     144        //void SetOcclusionPass(); 
    101145 
    102         /** Deletes all occlusion queries. 
    103         */ 
    104         void DeleteQueries(); 
    105         /** Renders bounding box of specified node. 
    106                 @param box the bounding box of the scene node to be rendered  
    107         */ 
    108         void RenderBoundingBox(AxisAlignedBox *box); 
    109  
    110         /** Returns pointer to current renderable bounding box geometry 
    111         */ 
    112         SolidBoundingBox *GetSolidBoundingBox(); 
    113  
    114         /** Returns pointer to current renderable half bounding box geometry 
    115         */ 
     146        /** Returns pointer to current renderable half bounding box geometry.*/ 
    116147        //SolidHalfBoundingBox *GetSolidHalfBoundingBox(); 
    117148 
    118         /** Renderable of an aabb 
     149        /** Renderable of an aabb. 
    119150        */ 
    120151        SolidBoundingBox *mSolidBoundingBox; 

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

    r107 r130  
    3737        void SetScale(Vector3 scale); 
    3838         
    39         /** the number of created objects */ 
     39        /** The number of created objects */ 
    4040        int GetObjectCount(); 
    4141 
    42         /** writes scene nodes to file */ 
     42        /** Writes scene nodes to file */ 
    4343        bool WriteObjects(const std::string &filename); 
    4444 
    45         /** loads scene nodes from file */ 
     45        /** Loads scene nodes from file */ 
    4646        bool LoadObjects(const std::string &filename); 
    47  
     47        /** Generates a scene object with the specified parameters 
     48                @param position the position of the scene object 
     49                @param orientation the orientation of the scene object 
     50                @param objName the mesh name of the scene object 
     51                @returns the created scene object 
     52        */ 
    4853        SceneNode *GenerateSceneObject(const Vector3 &position,  
    4954                const Quaternion &orientation, const String &objName); 

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

    r112 r130  
    33 
    44#include "OgrePlatformHierarchyInterface.h" 
     5#include "VisibilityInfo.h" 
     6#include "QueryManager.h" 
     7 
    58 
    69namespace Ogre { 
    … …  
    3841        void VisualizeCulledNode(GtpVisibility::HierarchyNode *node,  
    3942                                                        GtpVisibility::CullingType type); 
     43 
     44        /*bool FindVisibleObjects(GtpVisibility::HierarchyNode *node,    
     45                                                        InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,  
     46                                                        bool includeChildren = false);*/ 
     47         
     48        void GetGeometry(GtpVisibility::HierarchyNode *node,     
     49                                         GtpVisibility::GeometryList *geometryList,  
     50                                         bool includeChildren); 
    4051}; 
    4152 

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

    r110 r130  
    3535        */ 
    3636        SceneNode *GenerateSceneObject(const Vector3 &position,  
    37                 const Vector3 &rotation, const String &objName); 
     37                const Vector3 &rotation, const String &objName, const bool clampToTerrain = true); 
    3838         
    3939        /** offset which is added to objects when put into the terrain */ 

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

    r122 r130  
    6565        /** Creates material for depth pass, e.g., a pass that only fills the depth buffer */ 
    6666        void InitDepthPass(); 
     67         
     68        /** Prepares visualization of hierarchical culling. */ 
    6769        void ShowVisualization(Camera *cam); 
    6870        OctreeHierarchyInterface *mHierarchyInterface; 

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

    r114 r130  
    22#define _VisibilityOptionsManager_H__ 
    33 
     4 
     5#include <OgreString.h> 
     6#include <OgreStringVector.h> 
    47#include "VisibilityManager.h" 
    58#include "HierarchyInterface.h" 
    6 #include <OgreString.h> 
    7 #include <OgreStringVector.h> 
     9 
    810 
    911namespace Ogre { 
    … …  
    3032                "Algorithm", "Threshold";                        
    3133        */ 
    32         bool setOption( const String &, const void * ); 
     34        bool setOption(const String &, const void *); 
    3335        /** Gets the given option for the scene traverser. 
    3436            @remarks 
    3537            See setOption 
    3638        */ 
    37         bool getOption( const String &, void * ); 
     39        bool getOption(const String &, void *); 
    3840        bool getOptionKeys( StringVector &refKeys ); 
    3941         

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

    r129 r130  
    99 
    1010#include "OgreOctreeHierarchyInterface.h" 
     11#include "OgrePlatformQueryManager.h" 
    1112#include "VisibilityManager.h" 
    1213 
    … …  
    1718        using occlusion queries for visibility culling. 
    1819*/ 
    19 class VisibilityTerrainSceneManager: public TerrainSceneManager 
     20class __declspec(dllexport) VisibilityTerrainSceneManager: public TerrainSceneManager 
    2021{ 
    2122public: 
    … …  
    7475        Entity* createEntity(const String& entityName, const String& meshName); 
    7576 
     77        /** Returns pointer to visibility manager */ 
     78        GtpVisibility::VisibilityManager *GetVisibilityManager(); 
     79 
    7680protected: 
    7781         
    … …  
    101105 
    102106        int mCurrentEntityId; 
     107 
     108        PlatformQueryManager *mQueryManager; 
    103109}; 
    104110 

  • trunk/VUT/Ogre/scripts/Plugin_VisibilitySceneManager.vcproj

    r115 r130  
    9393                                BufferSecurityCheck="FALSE" 
    9494                                EnableFunctionLevelLinking="TRUE" 
     95                                RuntimeTypeInfo="TRUE" 
    9596                                UsePrecompiledHeader="0" 
    9697                                WarningLevel="3" 
    … …  
    196197                                </File> 
    197198                                <File 
     199                                        RelativePath="..\include\OgrePlatformQueryManager.h"> 
     200                                </File> 
     201                                <File 
    198202                                        RelativePath="..\include\OgreSceneContentGenerator.h"> 
    199203                                </File> 
    … …  
    222226                                <File 
    223227                                        RelativePath="..\src\OgrePlatformOcclusionQuery.cpp"> 
     228                                </File> 
     229                                <File 
     230                                        RelativePath="..\src\OgrePlatformQueryManager.cpp"> 
    224231                                </File> 
    225232                                <File 

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

    r115 r130  
    99 
    1010//----------------------------------------------------------------------- 
    11 OctreeHierarchyInterface::OctreeHierarchyInterface(SceneManager *sm, RenderSystem *rsys):  
    12 PlatformHierarchyInterface(sm, rsys) 
     11OctreeHierarchyInterface::OctreeHierarchyInterface(OctreeSceneManager *sm, RenderSystem *rsys):  
     12SceneNodeHierarchyInterface(sm, rsys) 
    1313{ 
    1414} 
    … …  
    106106                octant->setLastRendered(mFrameId); 
    107107 
    108                 static_cast<OctreeSceneManager *>(mSceneManager)->_renderOctant(mCamera,  
     108                dynamic_cast<OctreeSceneManager *>(mSceneManager)->_renderOctant(mCamera,  
    109109                        octant, mOnlyShadowCasters, mLeaveTransparentsInQueue); 
    110110 
    111                 mNumRenderedNodes ++; 
     111                mRenderedNodes.push_back(node); 
    112112        } 
    113113#endif 
    … …  
    157157        } 
    158158 
    159         static_cast<OctreeSceneManager *>(mSceneManager)->getBoxes()->push_back(box); 
    160 } 
     159        dynamic_cast<OctreeSceneManager *>(mSceneManager)->getBoxes()->push_back(box); 
     160} 
     161//----------------------------------------------------------------------- 
     162void OctreeHierarchyInterface::GetGeometry(GtpVisibility::HierarchyNode *node,   
     163                                                                                   GtpVisibility::GeometryList *geometryList,  
     164                                                                                   bool includeChildren) 
     165{ 
     166        NodeList::const_iterator nodeIt, nodeIt_end; 
     167        nodeIt_end = static_cast<Octree *>(node)->mNodes.end(); 
     168 
     169        for (nodeIt = static_cast<Octree *>(node)->mNodes.begin(); nodeIt != nodeIt_end; ++nodeIt) 
     170        { 
     171                SceneNodeHierarchyInterface::GetGeometry(*nodeIt, geometryList, includeChildren); 
     172        } 
     173} 
     174//----------------------------------------------------------------------- 
     175/*bool OctreeHierarchyInterface::FindVisibleObjects(GtpVisibility::HierarchyNode *node,  
     176                                                                        InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,  
     177                                                                        bool includeChildren) 
     178{ 
     179        bool foundVisible = false; 
     180 
     181        PlatformOcclusionQuery query(mRenderSystem); 
     182 
     183        NodeList *nodes = &static_cast<Octree *>(node)->mNodes; 
     184         
     185        NodeList::const_iterator nodeIt = nodes->begin(), nodeIt_end; 
     186         
     187        nodeIt_end = nodes->end(); 
     188 
     189        while (nodeIt != nodeIt_end) 
     190        { 
     191                OctreeNode *octreeNode = (*nodeIt); 
     192                if (SceneNodeHierarchyInterface::FindVisibleObjects(octreeNode, visibleGeometry, includeChildren)) 
     193                { 
     194                        foundVisible = true; 
     195                } 
     196                ++nodeIt; 
     197        } 
     198 
     199        return foundVisible; 
     200}*/ 
     201 
    161202} // namespace Ogre 

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

    r122 r130  
    11#include <OgreCamera.h> 
    22#include <OgreLogManager.h> 
     3#include <OgreSubEntity.h> 
     4#include <OgreEntity.h> 
     5#include <OgreMovableObject.h> 
    36#include "OgreSolidBoundingBox.h" 
    47#include "OgrePlatformHierarchyInterface.h" 
    … …  
    138141        mCullCamera = cullCam ? cullCam : cam; 
    139142 
    140         if (mCullCamera != mCamera) 
    141                 LogManager::getSingleton().logMessage("cullcamera is not camera!"); 
     143        //if (mCullCamera != mCamera) 
     144        //      LogManager::getSingleton().logMessage("cullcamera is not camera"); 
    142145 
    143146        // create materials for node visualization 
    … …  
    186189        { 
    187190                mIsBoundingBoxQuery = true; 
     191 
    188192                //LogManager::getSingleton().logMessage("render box\n"); 
    189193                RenderBoundingBox(GetBoundingBox(node)); 
    … …  
    197201} 
    198202//----------------------------------------------------------------------- 
    199 void PlatformHierarchyInterface::SetOcclusionPass() 
     203GtpVisibility::OcclusionQuery *PlatformHierarchyInterface::IssueOcclusionQuery(GtpVisibility::Mesh *mesh) 
     204{ 
     205        // get next available test id 
     206        GtpVisibility::OcclusionQuery *query = GetNextOcclusionQuery(); 
     207 
     208        //-- the actual query test 
     209        query->BeginQuery(); 
     210         
     211        RenderGeometry(mesh); 
     212 
     213        query->EndQuery(); 
     214 
     215        return query; 
     216} 
     217//----------------------------------------------------------------------- 
     218/*void PlatformHierarchyInterface::SetOcclusionPass() 
    200219{ 
    201220    // disable vertex and fragment program 
    … …  
    215234        // Set colour write mode off 
    216235        mRenderSystem->_setColourBufferWriteEnabled(false, false, false, false); 
    217 } 
     236}*/ 
    218237//----------------------------------------------------------------------- 
    219238SolidBoundingBox *PlatformHierarchyInterface::GetSolidBoundingBox() 
    … …  
    228247{ 
    229248        mOnlyShadowCasters = onlyShadowCasters; 
    230         //mIsShadowPass = mOnlyShadowCasters ; 
    231249} 
    232250//----------------------------------------------------------------------- 
    … …  
    245263        return mIsBoundingBoxQuery; 
    246264} 
     265//----------------------------------------------------------------------- 
     266void PlatformHierarchyInterface::RenderGeometry(GtpVisibility::Mesh *geom) 
     267{ 
     268        mSceneManager->_renderMovableObject(geom, mLeaveTransparentsInQueue); 
     269} 
     270//----------------------------------------------------------------------- 
     271SceneManager *PlatformHierarchyInterface::GetSceneManager() 
     272{ 
     273        return mSceneManager; 
     274} 
     275//----------------------------------------------------------------------- 
     276RenderSystem *PlatformHierarchyInterface::GetRenderSystem() 
     277{ 
     278        return mRenderSystem; 
     279} 
    247280} // namespace Ogre 

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

    r121 r130  
    186186        return true; 
    187187} 
     188 
    188189} // namespace Ogre 

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

    r115 r130  
    1 #include "OgreSceneNodeHierarchyInterface.h" 
    21#include <OgreIteratorWrappers.h> 
    32#include <OgreCamera.h> 
    43#include <OgreSceneNode.h> 
     4#include <OgreEntity.h> 
     5#include <OgreSubEntity.h> 
     6#include <OgreLogManager.h> 
     7#include "OgreSceneNodeHierarchyInterface.h" 
     8#include "OgrePlatformOcclusionQuery.h" 
     9 
    510 
    611namespace Ogre { 
    … …  
    4045        { 
    4146                sceneNode->setLastRendered(sceneNode->lastVisited()); 
    42                 mNumRenderedNodes ++; 
     47                mRenderedNodes.push_back(node); 
    4348 
    4449                mSceneManager->_renderSceneNode(mCamera, sceneNode, mLeaveTransparentsInQueue); 
    … …  
    130135        // TODO 
    131136} 
     137//----------------------------------------------------------------------- 
     138void SceneNodeHierarchyInterface::GetGeometry(GtpVisibility::HierarchyNode *node,        
     139                                                                                          GtpVisibility::GeometryList *geometryList,  
     140                                                                                          bool includeChildren) 
     141{ 
     142        SceneNode::ObjectIterator objIt =  
     143                static_cast<SceneNode *>(node)->getAttachedObjectIterator(); 
     144 
     145        while (objIt.hasMoreElements()) 
     146    { 
     147                MovableObject *movable = objIt.getNext(); 
     148                 
     149                // we are interested only in the entities, i.e., intances of geometry 
     150                if (movable->getMovableType() == "Entity") 
     151                { 
     152                        Entity *ent = static_cast<Entity *>(movable); 
     153                        //std::stringstream d; d << "ent " << ent->getName();  
     154                        //LogManager::getSingleton().logMessage(d.str()); 
     155                        geometryList->push_back(ent); 
     156                } 
     157    } 
     158} 
    132159} // namespace Ogre      

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

    r111 r130  
    6868//----------------------------------------------------------------------- 
    6969SceneNode *TerrainContentGenerator::GenerateSceneObject(const Vector3 &position,  
    70                                          const Vector3 &rotation, const String& objName) 
     70                                         const Vector3 &rotation, const String& objName, const bool clampToTerrain) 
    7171{ 
    7272        Vector3 queryResult; 
    7373        // set y to max height so we are sure to be over terrain 
    7474        Vector3 pos(position.x, MAX_HEIGHT, position.z); 
     75 
     76        if (!clampToTerrain) 
     77        { 
     78                return SceneContentGenerator::GenerateSceneObject(queryResult, rotation, objName); 
     79        } 
    7580 
    7681        if (mRayQueryExecutor->executeRayQuery(&queryResult, position, Vector3::NEGATIVE_UNIT_Y)) 

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

    r129 r130  
    2424mDelayRenderTransparents(true), 
    2525mUseDepthPass(false), 
    26 mRenderItemBuffer(true), 
     26mRenderItemBuffer(false), 
    2727mCurrentEntityId(0) 
    2828{ 
    2929        mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem); 
    30  
     30        mQueryManager = new PlatformQueryManager(mHierarchyInterface, mCurrentViewport); 
     31 
     32        mVisibilityManager->SetQueryManager(mQueryManager); 
    3133        //mDisplayNodes = true; 
    3234        //mShowBoundingBoxes = true; 
    … …  
    8789                mHierarchyInterface = NULL; 
    8890        } 
     91        if (mQueryManager) 
     92        { 
     93                delete mQueryManager; 
     94                mQueryManager = NULL; 
     95        } 
    8996} 
    9097//----------------------------------------------------------------------- 
    9198void VisibilityTerrainSceneManager::ShowVisualization(Camera *cam) 
    9299{ 
    93         LogManager::getSingleton().logMessage("***********VISUALIZATION************"); 
    94100        // add player camera for visualization purpose 
    95101        try  
    … …  
    189195                setAmbientLight(ColourValue(1,1,1,1)); 
    190196        } 
    191  
    192         LogManager::getSingleton().logMessage("***********FIND OBJECTS************"); 
    193         getRenderQueue()->clear(); 
     197        //getRenderQueue()->clear(); 
    194198 
    195199        //-- show visible scene nodes and octree bounding boxes from last frame 
    … …  
    221225void VisibilityTerrainSceneManager::_renderVisibleObjects() 
    222226{ 
    223         /* 
    224         std::stringstream d; 
    225         d << "Terrain render level: " << TerrainRenderable::getCurrentRenderLevelIndex(); 
    226         LogManager::getSingleton().logMessage(d.str()); 
    227  
    228227        // increase terrain renderlevel 
    229228        int renderLevel = TerrainRenderable::getCurrentRenderLevelIndex() + 1; 
    … …  
    233232                renderLevel = 0; 
    234233        } 
    235 */ 
     234 
    236235        // visualization: apply standard rendering 
    237236        if (mShowVisualization) 
    238237        {        
    239238                TerrainSceneManager::_renderVisibleObjects(); 
    240         //      TerrainRenderable::setCurrentRenderLevelIndex(renderLevel); 
     239                TerrainRenderable::setCurrentRenderLevelIndex(renderLevel); 
    241240                return; 
    242241        } 
    243  
    244         LogManager::getSingleton().logMessage("***********RENDER OBJECTS************"); 
    245242 
    246243        InitDepthPass();        // create material for depth pass 
    … …  
    309306        TerrainSceneManager::_renderVisibleObjects(); 
    310307 
    311         //TerrainRenderable::setCurrentRenderLevelIndex(renderLevel); 
     308        TerrainRenderable::setCurrentRenderLevelIndex(renderLevel); 
    312309        //WriteLog(); // write out stats 
    313310} 
    … …  
    374371        // notifiy that frame has ended so terrain render level can be reset for correct 
    375372        // terrain rendering 
    376 /*      if (key == "TerrainLevelIdx") 
     373        if (key == "TerrainLevelIdx") 
    377374        { 
    378375                TerrainRenderable::setCurrentRenderLevelIndex((*static_cast<const int *>(val))); 
    379376                return true; 
    380         }*/ 
     377        } 
    381378        return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface). 
    382379                setOption(key, val) || TerrainSceneManager::setOption(key, val); 
    … …  
    507504                                //<< ", renderable name: " << irend-> 
    508505                                RenderSingleObjectForItemBuffer(*irend, ipass->first); 
    509                                 RenderSingleObjectForOcclusionQuery( 
     506                                //RenderSingleObjectForOcclusionQuery( 
    510507                } 
    511508        } 
    … …  
    562559        //LogManager::getSingleton().logMessage("has vertex program"); 
    563560        Pass *usedPass = setPass(mItemBufferPass);  
    564 //Pass *usedPass = setPass(pass); 
     561        //Pass *usedPass = setPass(pass); 
    565562        std::stringstream d; 
    566563        d << "item buffer id: " << rend->getId() << ", col: " << col; 
    … …  
    571568} 
    572569//----------------------------------------------------------------------- 
    573 Entity* VisibilityTerrainSceneManager::createEntity(const String& entityName, const String& meshName) 
     570GtpVisibility::VisibilityManager *VisibilityTerrainSceneManager::GetVisibilityManager() 
     571{ 
     572        return mVisibilityManager; 
     573} 
     574//----------------------------------------------------------------------- 
     575Entity* VisibilityTerrainSceneManager::createEntity(const String& entityName,  
     576                                                                                                        const String& meshName) 
    574577{ 
    575578        Entity *ent = SceneManager::createEntity(entityName, meshName); 
    576579 
    577         for (int i = 0; i < ent->getNumSubEntities(); ++i) 
     580        for (int i = 0; i < (int)ent->getNumSubEntities(); ++i) 
    578581        { 
    579582                ent->getSubEntity(i)->setId(mCurrentEntityId ++); 
Note: See TracChangeset for help on using the changeset viewer.