Changeset 130


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

added visibility queries

Location:
trunk/VUT
Files:
32 edited

Legend:

Unmodified
Added
Removed

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

    r74 r130  
    88namespace GtpVisibility 
    99{ 
    10  
    11 typedef std::pair<HierarchyNode *, OcclusionQuery *> QueryPair; 
    12 typedef std::queue<QueryPair> QueryQueue; 
    1310 
    1411/** Renders the scene with the coherent hierarchical culling algorithm.  

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

    r112 r130  
    33 
    44#include "DistanceQueue.h" 
     5#include "VisibilityMesh.h" 
    56 
    67namespace GtpVisibility { 
    78 
    89enum  CullingType {QUERY_CULLED, FRUSTUM_CULLED}; 
     10 
     11typedef std::vector<HierarchyNode *> HierarchyNodeList; 
     12typedef std::vector<GtpVisibility::Mesh *> GeometryList; 
     13typedef std::pair<HierarchyNode *, OcclusionQuery *> QueryPair; 
     14typedef std::queue<QueryPair> QueryQueue; 
    915 
    1016/**     Class which implements a hierarchy interface for a scene hierarchy. 
    … …  
    2632        */ 
    2733        virtual void TraverseNode(HierarchyNode *node) = 0; 
    28         /** Renders current scene node . 
    29                 @param node current scene node to be rendered 
     34        /** Renders current hierarchy node. 
     35                @param node current hierarchy node to be rendered 
    3036        */ 
    3137        virtual void RenderNode(HierarchyNode *node) = 0; 
    … …  
    119125                CullingType type) = NULL; 
    120126 
     127        /** Returns vector of previously rendered hierarchy nodes. 
     128        */ 
     129        std::vector<HierarchyNode *> *GetRenderedNodes(); 
     130        /** Returns vector of previoulsy rendered geometry. 
     131        */ 
     132         
     133        /** Issue a occlusion query for this mesh. 
     134                @param node the current mesh 
     135                @returns occlusion query for this node 
     136        */ 
     137        virtual GtpVisibility::OcclusionQuery *IssueOcclusionQuery(GtpVisibility::Mesh *mesh) = 0; 
     138 
     139        /** Returns geometry of hierarchy node.  
     140        */ 
     141        virtual void GetGeometry(GtpVisibility::HierarchyNode *node,     
     142                                                         GeometryList *geometryList,  
     143                                                         bool includeChildren) = 0; 
     144 
     145 
     146        /** Renders geometry. 
     147        */ 
     148        virtual void RenderGeometry(GtpVisibility::Mesh *geom) = 0; 
     149 
    121150protected: 
    122151         
    … …  
    128157        //--- statistics 
    129158        unsigned int mNumTraversedNodes; 
    130         unsigned int mNumRenderedNodes; 
    131159 
    132160        DistanceQueue *mDistanceQueue; 
    … …  
    134162        HierarchyNode *mPreviousNode; 
    135163 
    136          
     164        std::vector<HierarchyNode *> mRenderedNodes; 
    137165}; 
    138166} // namespace GtpVisibility 

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

    r113 r130  
    1111namespace GtpVisibility { 
    1212   
     13typedef std::vector<OcclusionQuery *> QueryList; 
     14 
    1315/** This abstract class defines interface for a specific visibility query 
    1416    algorithm. The interface supports two from point visibility queries and 
    … …  
    2325public: 
    2426    /** Constructor taking a hierarchy interface as an argument. This allows to operate 
    25         onm different hierarchy types, while reusing the implementation of the query methods. 
     27        on different hierarchy types, while reusing the implementation of the query methods. 
    2628     */ 
    2729    QueryManager(HierarchyInterface *hierarchyInterface); 
    … …  
    8183             ); 
    8284   
    83         /** Sets the scene traverser. 
    84       @remark the scene traverser depends on the type of hierarchyInterface the scene consists of. 
     85        /** Sets the hierarchy interface. 
     86      @remark the traversal depends on the type of hierarchyInterface the scene consists of. 
    8587        */ 
    86         void SetSceneTraverser(HierarchyInterface *hierarchyInterface); 
     88        void SetHierarchyInterface(HierarchyInterface *hierarchyInterface); 
    8789 
    8890protected: 

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

    r71 r130  
    1616    NodeInfo(HierarchyNode *node,const float v): mNode(node), mVisibility(v) {} 
    1717 
     18        float GetVisibiliy() const {return mVisibility;} 
     19 
    1820protected: 
    1921    /** pointer to the scene node */ 
    … …  
    3133public: 
    3234        MeshInfo(Mesh *mesh, const float v): mMesh(mesh), mVisibility(v) {} 
     35 
     36        float GetVisibiliy() const {return mVisibility;} 
    3337 
    3438protected: 

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

    r114 r130  
    5555        */ 
    5656        void SetUseChcOptimization(bool useOptimization); 
     57        /** Sets pointer to a query manager.  
     58        */ 
     59        void SetQueryManager(QueryManager *queryManager); 
     60        /** see set  
     61        */ 
     62        QueryManager *GetQueryManager(); 
    5763 
    5864protected: 

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

    r71 r130  
    22#define _VisibilityMesh_H__ 
    33 
    4 #include "OgreMesh.h" 
     4//#include <OgreMesh.h> 
     5#include <OgreEntity.h> 
    56 
    67namespace GtpVisibility { 
    7   typedef Ogre::Mesh Mesh; 
     8  typedef Ogre::Entity Mesh; 
    89} 
    910 

  • trunk/VUT/GtpVisibility/scripts/GtpVisibility.vcproj

    r120 r130  
    6464                                PreprocessorDefinitions="WIN32;NDEBUG;_LIB" 
    6565                                RuntimeLibrary="2" 
     66                                RuntimeTypeInfo="TRUE" 
    6667                                UsePrecompiledHeader="0" 
    6768                                WarningLevel="3" 
    … …  
    107108                        </File> 
    108109                        <File 
    109                                 RelativePath="..\include\DistanceQueue.h"> 
    110                         </File> 
    111                         <File 
    112110                                RelativePath="..\src\DummyPreprocessingManager.cpp"> 
    113111                        </File> 
    … …  
    148146                        </File> 
    149147                        <File 
     148                                RelativePath="..\include\DistanceQueue.h"> 
     149                        </File> 
     150                        <File 
     151                                RelativePath="..\include\DummyQueryManager.h"> 
     152                        </File> 
     153                        <File 
    150154                                RelativePath="..\include\FrustumCullingManager.h"> 
    151155                        </File> 

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

    r119 r130  
    4848 
    4949                        if (!mHierarchyInterface->CheckFrustumVisible(node, intersects)) 
    50                         {//if (mHierarchyInterface->mIsShadowPass) 
     50                        { 
    5151                                mNumFrustumCulledNodes ++; 
    5252                                 

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

    r120 r130  
    77//----------------------------------------------------------------------- 
    88HierarchyInterface::HierarchyInterface():  
    9 mFrameId(0), mNumTraversedNodes(0), mNumRenderedNodes(0),  
    10 mSceneRoot(0), mPreviousNode(0), mCurrentTestIdx(0), mUseOptimization(false) 
     9mFrameId(0), mNumTraversedNodes(0), mSceneRoot(0),  
     10mPreviousNode(0), mCurrentTestIdx(0), mUseOptimization(false) 
    1111//, mIsShadowPass(false) 
    1212{        
    … …  
    2626void HierarchyInterface::InitFrame(HierarchyNode *root) 
    2727{ 
    28         mFrameId ++; 
     28        ++ mFrameId; 
    2929        mCurrentTestIdx = 0; 
    3030        mNumTraversedNodes = 0; 
    31         mNumRenderedNodes = 0; 
     31        mRenderedNodes.clear(); 
    3232 
    3333        SetSceneRoot(root); 
    … …  
    6363unsigned int HierarchyInterface::GetNumRenderedNodes() 
    6464{ 
    65         return mNumRenderedNodes; 
     65        return (unsigned int)mRenderedNodes.size(); 
    6666} 
    67  
     67//----------------------------------------------------------------------- 
    6868void HierarchyInterface::SetUseOptimization(bool useOptimization) 
    6969{ 
    7070        mUseOptimization = useOptimization; 
    7171} 
     72//----------------------------------------------------------------------- 
     73std::vector<HierarchyNode *> *HierarchyInterface::GetRenderedNodes() 
     74{ 
     75        return &mRenderedNodes; 
     76} 
    7277 
    7378} // namespace GtpVisibility 

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

    r71 r130  
    55  
    66QueryManager::QueryManager(HierarchyInterface *hierarchyInterface) 
     7:mHierarchyInterface(hierarchyInterface) 
    78{ 
    89} 

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

    r114 r130  
    8383        return mCullingManagerType; 
    8484} 
    85  
     85//----------------------------------------------------------------------- 
     86void VisibilityManager::SetQueryManager(QueryManager *queryManager) 
     87{ 
     88        mQueryManager = queryManager; 
     89} 
     90//----------------------------------------------------------------------- 
     91QueryManager *VisibilityManager::GetQueryManager() 
     92{ 
     93        return mQueryManager; 
     94} 
    8695} // namespace GtpVisibility 

  • 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 ++); 

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

    r115 r130  
    161161}  
    162162//----------------------------------------------------------------------- 
    163 TerrainMouseQueryListener::~TerrainMouseQueryListener( ) 
    164 { 
    165 } 
    166 //----------------------------------------------------------------------- 
    167 void TerrainMouseQueryListener::mouseMoved (MouseEvent *e) 
     163TerrainMouseQueryListener::~TerrainMouseQueryListener() 
     164{ 
     165} 
     166//----------------------------------------------------------------------- 
     167void TerrainMouseQueryListener::mouseMoved(MouseEvent *e) 
    168168{ 
    169169        // Update CEGUI with the mouse motion 
    170     CEGUI::System::getSingleton().injectMouseMove(e->getRelX() * mGUIRenderer->getWidth(), e->getRelY() * mGUIRenderer->getHeight()); 
     170    CEGUI::System::getSingleton().injectMouseMove(e->getRelX() *  
     171                mGUIRenderer->getWidth(), e->getRelY() * mGUIRenderer->getHeight()); 
    171172} 
    172173//----------------------------------------------------------------------- 

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

    r122 r130  
    66#include <OgreMemoryMacros.h> 
    77#include "TerrainMouseQueryListener.h" 
     8#include "OgrePlatformQueryManager.h" 
     9#include "OgreVisibilityTerrainSceneManager.h" 
     10#include "VisibilityInfo.h" 
    811 
    912// output file for frame info 
    … …  
    5457mTerrainContentGenerator(sceneGenerator), 
    5558mVisibilityThreshold(0), 
    56 //mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING), 
    57 mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::FRUSTUM_CULLING), 
     59mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::COHERENT_HIERARCHICAL_CULLING), 
     60//mCurrentAlgorithm(GtpVisibility::VisibilityEnvironment::FRUSTUM_CULLING), 
    5861mNodeVizMode(NODEVIZ_NONE), 
    5962mVizCameraHeight(Real(2500.0)), 
    … …  
    8184mSunLight(sunLight) 
    8285{ 
    83         mInputDevice = PlatformManager::getSingleton().createInputReader(); 
    84         mInputDevice->initialise(win, true, true); 
    85  
    86         /* 
     86        //mInputDevice = PlatformManager::getSingleton().createInputReader(); 
     87         
     88        //mInputDevice->initialise(win, true, true); 
     89        mEventProcessor = new EventProcessor(); 
     90         
     91        mEventProcessor->initialise(win); 
     92        mEventProcessor->startProcessingEvents(); 
    8793        mEventProcessor->addMouseListener(this); 
    8894        mEventProcessor->addMouseMotionListener(this); 
    89         mEventProcessor->addKeyListener(this); 
    90         */ 
     95 
     96        //mEventProcessor->addKeyListener(this); 
     97        mInputDevice = mEventProcessor->getInputReader(); 
     98         
    9199 
    92100        // create ray query executor, used to place objects in terrain 
    … …  
    145153        mSceneMgr->setOption("CullCamera", &mCullCamera); 
    146154        mSceneMgr->setOption("ShowVisualization", &mShowVisualization); 
     155 
     156        mVisibilityManager =  
     157                dynamic_cast<VisibilityTerrainSceneManager *>(mSceneMgr)->GetVisibilityManager(); 
     158 
     159        dynamic_cast<PlatformQueryManager *>(mVisibilityManager->GetQueryManager())-> 
     160                SetViewport(mWindow->getViewport(0)); 
    147161}  
    148162//----------------------------------------------------------------------- 
    149163TerrainMouseQueryListener::~TerrainMouseQueryListener() 
    150164{ 
    151         PlatformManager::getSingleton().destroyInputReader(mInputDevice); 
     165        //PlatformManager::getSingleton().destroyInputReader(mInputDevice); 
    152166     
    153167        delete mRayQueryExecutor; 
     168        delete mEventProcessor; 
    154169} 
    155170//----------------------------------------------------------------------- 
    … …  
    170185                 // Setup the ray scene query 
    171186         Ray mouseRay = mCamera->getCameraToViewportRay(e->getX(), e->getY()); 
    172    
    173                  Vector3 queryResult; 
     187                 
     188                 //Vector3 queryResult; mRayQueryExecutor->executeRayQuery(&queryResult, mouseRay); 
    174189                  
    175190                 // Get results, create a node/entity on the position 
    176191                 mCurrentObject = mTerrainContentGenerator->GenerateSceneObject( 
    177                          mouseRay.getOrigin(), Vector3(0,0,0), "robot"); 
     192                         mouseRay.getOrigin(), Vector3::ZERO, "robot", false); 
    178193                 
    179194         mLMouseDown = true;  
    … …  
    231246bool TerrainMouseQueryListener::frameStarted(const FrameEvent &evt) 
    232247{ 
    233         LogManager::getSingleton().logMessage("frame started"); 
    234248        if (mWindow->isClosed()) 
     249        { 
    235250        return false; 
    236  
    237          mInputDevice->capture(); 
    238                   
    239          //-- IMPORTANT: must be set, otherwise terrain is not rendered correctly 
    240          int terrainLevelIdx = 0; 
    241          mSceneMgr->setOption("TerrainLevelIdx", &terrainLevelIdx); 
    242  
    243          //-- setup what is needed for immediate mouse/key movement 
    244          if (mTimeDelay >= 0)  
    245                  mTimeDelay -= evt.timeSinceLastFrame; 
    246  
    247          // If this is the first frame, pick a speed 
    248          if (evt.timeSinceLastFrame == 0) 
    249          { 
    250                  mMoveScale = 1; 
    251                  mRotScale = 0.1; 
    252          } 
    253          // Otherwise scale movement units by time passed since last frame 
    254          else 
    255          { 
    256                  // Move about 100 units per second, 
    257                  mMoveScale = mMoveSpeed * evt.timeSinceLastFrame; 
    258                  // Take about 10 seconds for full rotation 
    259                  mRotScale = mRotateSpeed * evt.timeSinceLastFrame; 
    260          } 
    261  
    262          mRotX = 0; 
    263          mRotY = 0; 
    264          mTranslateVector = Vector3::ZERO; 
    265  
    266          if (!processUnbufferedKeyInput(evt)) 
    267          { 
    268                  return false; 
    269          } 
    270          if (!processUnbufferedMouseInput(evt)) 
    271          { 
    272                  return false; 
    273          } 
    274  
    275          if (mShowVisualization) 
    276          { 
     251        } 
     252 
     253//      mInputDevice->capture(); 
     254 
     255        //-- IMPORTANT: must be set, otherwise terrain is not rendered correctly 
     256        int terrainLevelIdx = 0; 
     257        mSceneMgr->setOption("TerrainLevelIdx", &terrainLevelIdx); 
     258 
     259        //-- setup what is needed for immediate mouse/key movement 
     260        if (mTimeDelay >= 0)  
     261        { 
     262                mTimeDelay -= evt.timeSinceLastFrame; 
     263        } 
     264 
     265        // If this is the first frame, pick a speed 
     266        if (evt.timeSinceLastFrame == 0) 
     267        { 
     268                mMoveScale = 1; 
     269                mRotScale = 0.1; 
     270        } 
     271        // Otherwise scale movement units by time passed since last frame 
     272        else 
     273        { 
     274                // Move about 100 units per second, 
     275                mMoveScale = mMoveSpeed * evt.timeSinceLastFrame; 
     276                // Take about 10 seconds for full rotation 
     277                mRotScale = mRotateSpeed * evt.timeSinceLastFrame; 
     278        } 
     279 
     280        mRotX = 0; 
     281        mRotY = 0; 
     282        mTranslateVector = Vector3::ZERO; 
     283 
     284        if (!processUnbufferedKeyInput(evt)) 
     285        { 
     286                return false; 
     287        } 
     288/*      if (!processUnbufferedMouseInput(evt)) 
     289        { 
     290                return false; 
     291        }*/ 
     292        // --- set parameters for visualization 
     293        if (mShowVisualization) 
     294        { 
    277295                // important for visualization => draw octree bounding boxes 
    278296                mSceneMgr->setOption("ShowOctree", &mShowVisualization); 
    279                 // also render nodew content? 
    280                 //mSceneMgr->setOption("RenderNodesForViz", &mRenderNodesForViz); 
    281  
    282                 // -- setup visualization camera 
     297                 
     298                // ---- setup visualization camera 
     299 
    283300                mVizCamera->setPosition(0, 0, 0); 
    284301                mVizCamera->setOrientation(Quaternion::IDENTITY); 
    … …  
    289306                // point down -Z axis 
    290307                mVizCamera->pitch(Radian(Degree(270.0))); 
    291          
     308 
    292309                // rotation arounnd X axis 
    293310                mVizCamera->yaw(Math::ATan2(-mCamera->getDerivedDirection().x,  
    … …  
    298315        } 
    299316 
     317        //-- set application state 
    300318        switch (mAppState) 
    301319        { 
    … …  
    312330                                StringConverter::toString(mFrameInfo.size() - 1)); 
    313331                }        
    314          
    315                  moveCamera(); 
    316                  Clamp2Terrain(); 
    317  
    318                  break; 
     332 
     333                moveCamera(); 
     334                Clamp2Terrain(); 
     335 
     336                break; 
    319337        default: 
    320338                break; 
    321339        };       
    322          
     340 
    323341        return true; 
     342} 
     343//----------------------------------------------------------------------- 
     344void TerrainMouseQueryListener::ApplyVisibilityQuery() 
     345{ 
     346        InfoContainer<GtpVisibility::NodeInfo> visibleNodes; 
     347        InfoContainer<GtpVisibility::MeshInfo> visibleGeometry; 
     348 
     349    mVisibilityManager->GetQueryManager()->ComputeCameraVisibility(*mCamera, 
     350                            &visibleNodes, &visibleGeometry, false); 
     351 
     352        for (int i=0; i < visibleGeometry.size(); ++i) 
     353        { 
     354                std::stringstream d; d << "Geometry visibility: " << visibleGeometry[i].GetVisibiliy(); 
     355                LogManager::getSingleton().logMessage(d.str()); 
     356        } 
     357        for (int i=0; i < visibleNodes.size(); ++i) 
     358        { 
     359                std::stringstream d; d << "Node visibility: " << visibleNodes[i].GetVisibiliy(); 
     360                LogManager::getSingleton().logMessage(d.str()); 
     361        } 
     362 
    324363} 
    325364//----------------------------------------------------------------------- 
    … …  
    365404        { 
    366405                ofstr << StringConverter::toString((*it).position) << " "  
    367                         << StringConverter::toString((*it).orientation) << " " 
    368                         << StringConverter::toString((*it).timeElapsed) << "\n"; 
     406                          << StringConverter::toString((*it).orientation) << " " 
     407                          << StringConverter::toString((*it).timeElapsed) << "\n"; 
    369408        } 
    370409        ofstr.close(); 
    … …  
    390429                mFrameInfo.push_back(info); 
    391430                 
    392                 /* 
    393                 std::stringstream d; 
     431                /*      std::stringstream d; 
    394432                d << StringConverter::toString(info.position) << " " << StringConverter::toString(info.orientation); 
    395                 LogManager::getSingleton().logMessage(d.str()); 
    396                 */ 
     433                LogManager::getSingleton().logMessage(d.str());         */ 
    397434        } 
    398435        ifstr.close(); 
    … …  
    791828        KEY_PRESSED(KC_F3, 0.3, nextAppState()); 
    792829        KEY_PRESSED(KC_F4, 0.3, toggleRecord()); 
     830        KEY_PRESSED(KC_F5, 0.3, ApplyVisibilityQuery()); 
    793831 
    794832        KEY_PRESSED(KC_F11, 0.3, takeScreenShot()); 

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

    r121 r130  
    99#include <OgreException.h> 
    1010#include "VisibilityEnvironment.h" 
     11#include "VisibilityManager.h" 
    1112#include "OgreTerrainContentGenerator.h" 
    1213 
    … …  
    113114        void toggleRecord(); 
    114115 
     116        void ApplyVisibilityQuery(); 
     117 
     118        void switchMouseMode()  
     119        { 
     120        mUseBufferedInputMouse = !mUseBufferedInputMouse; 
     121                mInputDevice->setBufferedInput(mUseBufferedInputKeys, mUseBufferedInputMouse); 
     122        } 
    115123protected: 
    116124 
    … …  
    201209 
    202210        Light *mSunLight; 
     211        GtpVisibility::VisibilityManager *mVisibilityManager; 
     212        EventProcessor* mEventProcessor; 
     213         
     214        bool mUseBufferedInputKeys, mUseBufferedInputMouse, mInputTypeSwitchingOn; 
     215         
    203216}; 
    204217 

  • trunk/VUT/work/TestCullingTerrain/TestCullingTerrain.vcproj

    r115 r130  
    7575                                PreprocessorDefinitions="_WINDOWS;_STLP_USE_DYNAMIC_LIB;OGRE_LIBRARY_IMPORTS;_RELEASE;WIN32;_STLP_RELEASE;GTP_VISIBILITY_MODIFIED_OGRE" 
    7676                                RuntimeLibrary="2" 
     77                                RuntimeTypeInfo="TRUE" 
    7778                                UsePrecompiledHeader="0" 
    7879                                WarningLevel="3" 

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

    r115 r130  
    5757 
    5858        TerrainMouseQueryListener *mTerrainFrameListener; 
    59  
     59         
    6060private: 
    6161        void chooseSceneManager(void); 
Note: See TracChangeset for help on using the changeset viewer.