Ignore:
Timestamp:
03/22/07 18:24:13 (18 years ago)
Author:
mattausch
Message:

removed dependency on ogre in gtpvisibility

Location:
GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE
Files:
28 edited
1 moved

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreBvHierarchy.h

    r1344 r2280  
    228228 
    229229                        // add contained geometry (Entities) to list 
    230                         virtual void getGeometryList(GtpVisibility::GeometryVector *geometryList) = 0; 
     230                        virtual void getGeometryList(GeometryVector *geometryList) = 0; 
    231231                         
    232232                        // create (when necessary), setup and return wire bounding box representing the node 
    … …  
    355355 
    356356                        // a branch has no geometry, do nothing 
    357                         virtual void getGeometryList(GtpVisibility::GeometryVector *geometryList) { } 
     357                        virtual void getGeometryList(GeometryVector *geometryList) { } 
    358358 
    359359                        // branches do not posses geometry => just merge child aabbs 
    … …  
    416416                                Camera* cam, RenderQueue* queue, bool onlyShadowCasters, bool showBoxes, bool fullVis = false); 
    417417 
    418                         virtual void getGeometryList(GtpVisibility::GeometryVector *geometryList); 
     418                        virtual void getGeometryList(GeometryVector *geometryList); 
    419419 
    420420                        // update the world aabb based on the contained geometry 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreBvHierarchyInterface.h

    r2259 r2280  
    9191        */ 
    9292        virtual void GetNodeGeometryList(GtpVisibility::HierarchyNode *node,     
    93                                                                          GtpVisibility::GeometryVector *geometryList,  
     93                                                                         GeometryVector *geometryList,  
    9494                                                                         bool includeChildren); 
    9595 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreBvHierarchySceneNode.h

    r1320 r2280  
    3535 
    3636                // place all entities in geometry queue (for CHC) 
    37                 virtual void getGeometryList(GtpVisibility::GeometryVector *geometryList); 
     37                virtual void getGeometryList(GeometryVector *geometryList); 
    3838 
    3939                // return a bounding box enclosing all objects 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreBvhRenderable.h

    r1320 r2280  
    3535 
    3636                // place all entities in geometry queue (for CHC) 
    37                 virtual void getGeometryList(GtpVisibility::GeometryVector *geometryList) = 0; 
     37                virtual void getGeometryList(GeometryVector *geometryList) = 0; 
    3838 
    3939                // return a bounding box enclosing all objects 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreKdRenderable.h

    r1195 r2280  
    3535 
    3636                // place all entities in geometry queue (for CHC) 
    37                 virtual void getGeometryList(GtpVisibility::GeometryVector *geometryList) = 0; 
     37                virtual void getGeometryList(GeometryVector *geometryList) = 0; 
    3838 
    3939                // return a bounding box enclosing all objects 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreKdTree.h

    r1312 r2280  
    3131#include "OgreKdTreeCamera.h" 
    3232#include "HierarchyInterface.h" 
     33#include "VisibilityMesh.h" 
    3334 
    3435 
    … …  
    228229 
    229230                        // add contained geometry (Entities) to list 
    230                         virtual void getGeometryList(GtpVisibility::GeometryVector *geometryList) = 0; 
     231                        virtual void getGeometryList(GeometryVector *geometryList) = 0; 
    231232                         
    232233                        // create (when necessary), setup and return wire bounding box representing the node 
    … …  
    351352 
    352353                        // a branch has no geometry, do nothing 
    353                         virtual void getGeometryList(GtpVisibility::GeometryVector *geometryList) { } 
     354                        virtual void getGeometryList(GeometryVector *geometryList) { } 
    354355 
    355356                        // branches do not posses geometry => just merge child aabbs 
    … …  
    412413                                Camera* cam, RenderQueue* queue, bool onlyShadowCasters, bool showBoxes, bool fullVis = false); 
    413414 
    414                         virtual void getGeometryList(GtpVisibility::GeometryVector *geometryList); 
     415                        virtual void getGeometryList(GeometryVector *geometryList); 
    415416 
    416417                        // update the world aabb based on the contained geometry 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreKdTreeHierarchyInterface.h

    r2259 r2280  
    9191        */ 
    9292        virtual void GetNodeGeometryList(GtpVisibility::HierarchyNode *node,     
    93                                                                          GtpVisibility::GeometryVector *geometryList,  
     93                                                                         GeometryVector *geometryList,  
    9494                                                                         bool includeChildren); 
    9595 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreKdTreeSceneNode.h

    r1203 r2280  
    3535 
    3636                // place all entities in geometry queue (for CHC) 
    37                 virtual void getGeometryList(GtpVisibility::GeometryVector *geometryList); 
     37                virtual void getGeometryList(GeometryVector *geometryList); 
    3838 
    3939                // return a bounding box enclosing all objects 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreOcclusionCullingSceneManager.h

    r2255 r2280  
    1414#include "ViewCellsManager.h" 
    1515#include "VisibilityInfo.h" 
     16#include "VisibilityMesh.h" 
    1617 
    1718 
    … …  
    2627 
    2728 
    28 /** 
    29         This class extends the terrain scene manager, 
    30         using occlusion queries for visibility culling. 
     29/** This class extends the terrain scene manager, using occlusion queries for  
     30        visibility culling. 
    3131*/ 
    3232class __declspec(dllexport) OcclusionCullingSceneManager: public TerrainSceneManager 
    … …  
    196196                                                                 const bool nodeVisibility);     
    197197 
    198         void AddVisibleMeshGeometryToQueue(const GtpVisibility::MeshInfoContainer &visibleGeometry,  
     198        void AddVisibleMeshGeometryToQueue(const MeshInfoContainer &visibleGeometry,  
    199199                                                                           Camera *cam); 
    200         void AddVisibleNodeGeometryToQueue(const GtpVisibility::NodeInfoContainer &visibleNodes,  
     200 
     201        void AddVisibleNodeGeometryToQueue(const NodeInfoContainer &visibleNodes,  
    201202                                                                           Camera *cam); 
    202203 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreOcclusionQueriesQueryManager.h

    r2255 r2280  
    22#define _OcclusionQueriesQueryManager_H__ 
    33 
     4 
    45#include "OgrePlatformQueryManager.h" 
     6 
    57 
    68namespace Ogre { 
    79   
    8 /** 
    9         Class which implements a query manager for Ogre scene queries using occlusion queries. 
     10class OgrePlatformHierarchyInterface; 
     11class Viewport; 
     12 
     13/** Class which implements a query manager for Ogre scene queries using occlusion queries. 
    1014*/ 
    1115class __declspec(dllexport) OcclusionQueriesQueryManager: public PlatformQueryManager 
    … …  
    1519                on different hierarchy types, while reusing the implementation of the query methods. 
    1620    */ 
    17         OcclusionQueriesQueryManager(GtpVisibility::HierarchyInterface *hierarchyInterface,  
     21        OcclusionQueriesQueryManager(PlatformHierarchyInterface *hierarchyInterface,  
    1822                                                                 Viewport *vp, 
    1923                                                                 int queryModes,  
    20                                                                  int itemBufferMode); 
    21      
     24                                                                 int itemBufferMode):   
     25        PlatformQueryManager(hierarchyInterface, vp, queryModes),  
     26        mItemBufferMode(itemBufferMode) 
     27        {} 
     28 
    2229    void ComputeCameraVisibility(const Camera &camera, 
    23                                                                  GtpVisibility::NodeInfoContainer *visibleNodes, 
    24                                                                  GtpVisibility::MeshInfoContainer *visibleGeometry, 
    25                                                                  GtpVisibility::PatchInfoContainer *visiblePatches, 
     30                                                                 NodeInfoContainer *visibleNodes, 
     31                                                                 MeshInfoContainer *visibleGeometry, 
     32                                                                 PatchInfoContainer *visiblePatches, 
    2633                                                                 const bool relativeVisibility, 
    2734                                                                 const bool approximateVisibility); 
    2835     
    29     /**  
    30         Uses the specified point to execute the visibility query in all directions.  
    31         @sa ComputeCameraVisibility() 
     36    /** Uses the specified point to execute the visibility query in all directions.  
     37                @sa ComputeCameraVisibility() 
    3238    */ 
    3339    void ComputeFromPointVisibility(const Vector3 &point, 
    34                                                                         GtpVisibility::NodeInfoContainer *visibleNodes, 
    35                                                                         GtpVisibility::MeshInfoContainer *visibleGeometry, 
    36                                                                         GtpVisibility::PatchInfoContainer *visiblePatches, 
     40                                                                        NodeInfoContainer *visibleNodes, 
     41                                                                        MeshInfoContainer *visibleGeometry, 
     42                                                                        PatchInfoContainer *visiblePatches, 
    3743                                                                        const bool relativeVisibility, 
    3844                                                                        const bool approximateVisibility); 
    … …  
    4349        void CollectGeometryVisibility(GtpVisibility::QueryList::iterator &visQueryIt,  
    4450                                                                   GtpVisibility::QueryList::iterator &projQueryIt, 
    45                                                                    GtpVisibility::GeometryVector *geometryList,  
    46                                                                    GtpVisibility::MeshInfoContainer *visibleGeometry, 
     51                                                                   GeometryVector *geometryList,  
     52                                                                   MeshInfoContainer *visibleGeometry, 
    4753                                                                   bool relativeVisibility); 
    4854 
    … …  
    5056                                                           GtpVisibility::QueryList::iterator &projQueryIt, 
    5157                                                           GtpVisibility::NodeVector *nodeList,  
    52                                                            GtpVisibility::NodeInfoContainer *visibleNodes, 
     58                                                           NodeInfoContainer *visibleNodes, 
    5359                                                           bool relativeVisibility); 
    5460 
    5561        void CollectRelativeGeometryVisibilityForItemBuffer(GtpVisibility::QueryList::iterator &projQueryIt, 
    56                                                                                                 GtpVisibility::GeometryVector *geometryList,  
    57                                                                                                 GtpVisibility::MeshInfoContainer *visibleGeometry); 
     62                                                                                                                GeometryVector *geometryList,  
     63                                                                                                                MeshInfoContainer *visibleGeometry); 
    5864 
    59         void CollectRelativePatchVisibilityForItemBuffer( 
    60                                                                         GtpVisibility::QueryList::iterator &projQueryIt, 
    61                                                                         GtpVisibility::PatchVector *patchList,  
    62                                                                         GtpVisibility::PatchInfoContainer *visiblePatches); 
     65        void CollectRelativePatchVisibilityForItemBuffer(GtpVisibility::QueryList::iterator &projQueryIt, 
     66                                                                                                         PatchVector *patchList,  
     67                                                                                                         PatchInfoContainer *visiblePatches); 
    6368 
    6469        void CollectPatchVisibility(GtpVisibility::QueryList::iterator &visQueryIt,  
    6570                                                                GtpVisibility::QueryList::iterator &projQueryIt, 
    66                                                                 GtpVisibility::PatchVector *patchList,  
    67                                                                 GtpVisibility::PatchInfoContainer *visiblePatches, 
     71                                                                PatchVector *patchList,  
     72                                                                PatchInfoContainer *visiblePatches, 
    6873                                                                bool relativeVisibility); 
    6974 
    70         void RemoveDuplicateNodes(GtpVisibility::NodeInfoContainer *visibleNodes); 
    71         void RemoveDuplicateGeometry(GtpVisibility::MeshInfoContainer *visibleMesh); 
    72         void RemoveDuplicatePatches(GtpVisibility::PatchInfoContainer *visiblePatches); 
     75        void RemoveDuplicateNodes(NodeInfoContainer *visibleNodes); 
     76        void RemoveDuplicateGeometry(MeshInfoContainer *visibleMesh); 
     77        void RemoveDuplicatePatches(PatchInfoContainer *visiblePatches); 
    7378 
    7479        /** Returns the patches of the geometry of a given node.  
    … …  
    7782        */ 
    7883        virtual void GetNodePatchList(GtpVisibility::HierarchyNode *node,        
    79                                                                   GtpVisibility::PatchVector *patchList); 
     84                                                                  PatchVector *patchList); 
    8085 
    8186        int mItemBufferMode; 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreOctreeHierarchyInterface.h

    r2278 r2280  
    4949 
    5050        void GetNodeGeometryList(GtpVisibility::HierarchyNode *node, 
    51                                                          GtpVisibility::GeometryVector *geometryList,  
     51                                                         GeometryVector *geometryList,  
    5252                                                         bool includeChildren); 
    5353         

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgrePlatformHierarchyInterface.h

    r938 r2280  
    66#include <OgreCamera.h> 
    77#include <OgreRenderSystem.h> 
    8  
    9 //#include "OgreSolidHalfBoundingBox.h" 
    108#include "OgreSolidBoundingBox.h" 
    119#include "HierarchyInterface.h" 
    1210#include "VisibilityInfo.h" 
    1311#include "OgrePlatformOcclusionQuery.h" 
     12#include "VisibilityMesh.h" 
     13 
     14 
    1415 
    1516/** This namespace contains the Ogre dependent classes. 
    … …  
    114115        void ResetQueries(); 
    115116 
     117        /** Returns the geometry of a given hierarchy node.  
     118                @param node the hierarchy node containing the geometry 
     119                @param geometryList geometry is returned in this list 
     120                @param includeChildren if the geometry of the children should be taken into account 
     121        */ 
     122        virtual void GetNodeGeometryList(GtpVisibility::HierarchyNode *node,     
     123                                                                         GeometryVector *geometryList,  
     124                                                                         bool includeChildren) = 0; 
     125 
    116126protected: 
    117127        /** Renders the given geometry  

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgrePlatformQueryManager.h

    r2255 r2280  
    44#include "VisibilityInfo.h" 
    55#include "QueryManager.h" 
    6 #include "HierarchyInterface.h" 
     6#include "OgrePlatformHierarchyInterface.h" 
     7#include "VisibilityMesh.h" 
     8 
    79 
    810namespace Ogre { 
    911   
    10 /** 
    11         Class which implements the QueryManager for Ogre scene queries. 
     12/** Class which implements the QueryManager for Ogre scene queries. 
    1213*/ 
    1314class __declspec(dllexport) PlatformQueryManager: public GtpVisibility::QueryManager 
    … …  
    1718            on different hierarchy types, while reusing the implementation of the query methods. 
    1819    */ 
    19         PlatformQueryManager(GtpVisibility::HierarchyInterface *hierarchyInterface,  
     20        PlatformQueryManager(PlatformHierarchyInterface *hierarchyInterface,  
    2021                                 Viewport *vp,  
    21                                                  int queryModes); 
     22                                                 int queryModes) 
     23        : QueryManager(queryModes), 
     24          mViewport(vp),  
     25          mWasInitialised(false), 
     26          mHierarchyInterface(hierarchyInterface) 
     27        {} 
    2228     
    23     /**  
    24         Uses the specified point to execute the visibility query in all directions.  
    25         @sa ComputeCameraVisibility() 
     29    /** Uses the specified point to execute the visibility query in all directions.  
     30                @sa ComputeCameraVisibility() 
    2631    */ 
    27     void ComputeFromPointVisibility(const Vector3 &point, 
    28                                                                         GtpVisibility::NodeInfoContainer *visibleNodes, 
    29                                                                         GtpVisibility::MeshInfoContainer *visibleGeometry, 
    30                                                                         GtpVisibility::PatchInfoContainer *visiblePatches, 
    31                                                                         const bool relativeVisibility, 
    32                                                                         const bool approximateVisibility); 
     32    virtual void ComputeFromPointVisibility(const Vector3 &point, 
     33                                                                                        NodeInfoContainer *visibleNodes, 
     34                                                                                        MeshInfoContainer *visibleGeometry, 
     35                                                                                        PatchInfoContainer *visiblePatches, 
     36                                                                                        const bool relativeVisibility, 
     37                                                                                        const bool approximateVisibility); 
    3338   
    34         void ComputeCameraVisibility(const Camera &camera, 
    35                                                                  GtpVisibility::NodeInfoContainer *visibleNodes, 
    36                                                                  GtpVisibility::MeshInfoContainer *visibleGeometry, 
    37                                                                  GtpVisibility::PatchInfoContainer *visiblePatches, 
    38                                                                 const bool relativeVisibility, 
    39                                                                 const bool approximateVisibility); 
     39        virtual void ComputeCameraVisibility(const Camera &camera, 
     40                                                                                 NodeInfoContainer *visibleNodes, 
     41                                                                                 MeshInfoContainer *visibleGeometry, 
     42                                                                                 PatchInfoContainer *visiblePatches, 
     43                                                                                const bool relativeVisibility, 
     44                                                                                const bool approximateVisibility); 
    4045   
    41         bool ShootRay(const Ray &ray, std::vector<Mesh *> *visibleMeshes, bool isGlobalLine = false);   
     46        //virtual bool ShootRay(const Ray &ray, std::vector<Mesh *> *visibleMeshes, bool isGlobalLine = false);   
    4247 
    4348        /** Sets a viewport for rendering. 
    … …  
    4651 
    4752protected: 
     53 
    4854#ifdef ITEM_BUFFER 
    49         void CollectItemBufferResults( 
    50                                 GtpVisibility::MeshInfoContainer *visibleGeometry, 
    51                                 GtpVisibility::PatchInfoContainer *visiblePatches); 
     55        void CollectItemBufferResults(MeshInfoContainer *visibleGeometry, 
     56                                                                  PatchInfoContainer *visiblePatches); 
    5257 
    53         void InitItemBuffer(GtpVisibility::MeshInfoContainer *visibleGeometry, 
    54                                                 GtpVisibility::PatchInfoContainer *visiblePatches); 
     58        void InitItemBuffer(MeshInfoContainer *visibleGeometry, 
     59                                                PatchInfoContainer *visiblePatches); 
    5560#endif // ITEM_BUFFER 
    5661 
    5762        Viewport *mViewport; 
    58          
    5963        bool mWasInitialised; 
     64 
     65        PlatformHierarchyInterface *mHierarchyInterface; 
    6066}; 
    6167 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreSceneNodeHierarchyInterface.h

    r2259 r2280  
    4343         
    4444        void GetNodeGeometryList(GtpVisibility::HierarchyNode *node,     
    45                                          GtpVisibility::GeometryVector *geometryList,  
    46                                         bool includeChildren); 
     45                                                         GeometryVector *geometryList,  
     46                                                        bool includeChildren); 
    4747 
    4848        void DetermineFullVisibility(GtpVisibility::HierarchyNode *node) const {} 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/VisibilityMesh.h

    r159 r2280  
    22#define _VisibilityMesh_H__ 
    33 
    4 //#include <OgreMesh.h> 
     4 
    55#include <OgreEntity.h> 
     6#include "VisibilityInfo.h" 
    67 
    78namespace GtpVisibility { 
    … …  
    1112 
    1213 
     14typedef std::vector<GtpVisibility::Mesh *> GeometryVector; 
     15typedef std::vector<GtpVisibility::Patch *> PatchVector; 
     16 
     17 
     18typedef GtpVisibility::VisibilityInfo<GtpVisibility::Patch *> PatchInfo; 
     19typedef GtpVisibility::VisibilityInfo<GtpVisibility::Mesh *> MeshInfo; 
     20typedef GtpVisibility::VisibilityInfo<GtpVisibility::HierarchyNode *> NodeInfo; 
     21 
     22 
     23typedef std::vector<PatchInfo> PatchInfoContainer; 
     24typedef std::vector<MeshInfo> MeshInfoContainer; 
     25typedef std::vector<NodeInfo> NodeInfoContainer; 
     26 
     27 
    1328#endif // VisibilityMesh.h 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreBvHierarchy.cpp

    r2069 r2280  
    17131713 
    17141714//------------------------------------------------------------------------- 
    1715 void BvHierarchy::Leaf::getGeometryList(GtpVisibility::GeometryVector *geometryList) 
     1715void BvHierarchy::Leaf::getGeometryList(GeometryVector *geometryList) 
    17161716{ 
    17171717        BvhRenderableList::iterator it = mBvhRenderables.begin(); 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreBvHierarchyInterface.cpp

    r2258 r2280  
    138138 
    139139void BvHierarchyInterface::GetNodeGeometryList(GtpVisibility::HierarchyNode *node,  
    140                                                                                                    GtpVisibility::GeometryVector *geometryList,  
     140                                                                                                   GeometryVector *geometryList,  
    141141                                                                                                   bool includeChildren)  
    142142{ 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreBvHierarchySceneNode.cpp

    r1320 r2280  
    136136        } 
    137137 
    138         void BvHierarchySceneNode::getGeometryList(GtpVisibility::GeometryVector *geometryList) 
     138        void BvHierarchySceneNode::getGeometryList(GeometryVector *geometryList) 
    139139        { 
    140140                SceneNode::ObjectIterator objIt = getAttachedObjectIterator(); 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreKdTree.cpp

    r2069 r2280  
    17071707 
    17081708//------------------------------------------------------------------------- 
    1709 void KdTree::Leaf::getGeometryList(GtpVisibility::GeometryVector *geometryList) 
     1709void KdTree::Leaf::getGeometryList(GeometryVector *geometryList) 
    17101710{ 
    17111711        KdRenderableList::iterator it = mKdRenderables.begin(); 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreKdTreeHierarchyInterface.cpp

    r2066 r2280  
    136136 
    137137void KdTreeHierarchyInterface::GetNodeGeometryList(GtpVisibility::HierarchyNode *node,  
    138                                                                                                    GtpVisibility::GeometryVector *geometryList,  
     138                                                                                                   GeometryVector *geometryList,  
    139139                                                                                                   bool includeChildren)  
    140140{ 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreKdTreeSceneNode.cpp

    r1203 r2280  
    136136        } 
    137137 
    138         void KdTreeSceneNode::getGeometryList(GtpVisibility::GeometryVector *geometryList) 
     138        void KdTreeSceneNode::getGeometryList(GeometryVector *geometryList) 
    139139        { 
    140140                SceneNode::ObjectIterator objIt = getAttachedObjectIterator(); 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionCullingSceneManager.cpp

    r2278 r2280  
    1212#include <OgreIteratorWrappers.h> 
    1313#include <OgreHeightmapTerrainPageSource.h> 
    14 //#include "Containers.h" 
    1514#include "ViewCellsManager.h" 
    1615#include <OgreConfigFile.h> 
    1716#include "OgreTypeConverter.h" 
    1817#include "OgreMeshInstance.h" 
    19 //#include "common.h" 
    2018#include "OgreBoundingBoxConverter.h" 
    2119#include <OgreManualObject.h> 
    … …  
    11601158        if (key == "HierarchyInterface") 
    11611159        { 
    1162                 * static_cast<GtpVisibility::HierarchyInterface **>(val) = mHierarchyInterface; 
     1160                * static_cast<PlatformHierarchyInterface **>(val) = mHierarchyInterface; 
    11631161                return true; 
    11641162        } 
    … …  
    16431641                        LoadViewCells(filename, mObjects, false, &bconverter); 
    16441642         
    1645         Ogre::LogManager::getSingleton().logMessage("******** view cells loaded *********"); 
     1643        LogManager::getSingleton().logMessage("******** view cells loaded *********"); 
    16461644 
    16471645        // objects are set to invisible initially 
    … …  
    20272025                return; 
    20282026        } 
    2029  
     2027Ogre::LogManager::getSingleton().logMessage("here99"); 
    20302028    Root::getSingleton()._setCurrentSceneManager(this); 
    20312029        mActiveQueuedRenderableVisitor->targetSceneMgr = this; 
    … …  
    22272225        mVisibilityManager->SetQueryManager(queryManager); 
    22282226 
    2229         GtpVisibility::NodeInfoContainer visibleNodes; 
    2230         GtpVisibility::MeshInfoContainer visibleGeometry; 
    2231         GtpVisibility::PatchInfoContainer visiblePatches; 
     2227        NodeInfoContainer visibleNodes; 
     2228        MeshInfoContainer visibleGeometry; 
     2229        PatchInfoContainer visiblePatches; 
    22322230 
    22332231        if (fromPoint) 
    … …  
    22712269        if (!nodeVisibility) 
    22722270        { 
    2273                 GtpVisibility::MeshInfoContainer::iterator geomIt, geomIt_end = visibleGeometry.end(); 
     2271                MeshInfoContainer::iterator geomIt, geomIt_end = visibleGeometry.end(); 
    22742272 
    22752273                for (geomIt = visibleGeometry.begin(); geomIt != geomIt_end; ++geomIt) 
    … …  
    22942292                //-- apply queries on node level 
    22952293 
    2296                 GtpVisibility::NodeInfoContainer::iterator nodesIt, nodesIt_end = visibleNodes.end(); 
     2294                NodeInfoContainer::iterator nodesIt, nodesIt_end = visibleNodes.end(); 
    22972295 
    22982296                for (nodesIt = visibleNodes.begin(); nodesIt != nodesIt_end; ++ nodesIt) 
    … …  
    24332431//----------------------------------------------------------------------- 
    24342432void OcclusionCullingSceneManager::AddVisibleMeshGeometryToQueue( 
    2435                                                 const GtpVisibility::MeshInfoContainer &visibleGeometry, 
     2433                                                const MeshInfoContainer &visibleGeometry, 
    24362434                                                Camera *cam) 
    24372435{ 
    2438         GtpVisibility::MeshInfoContainer::const_iterator geomIt, geomIt_end = visibleGeometry.end(); 
     2436        MeshInfoContainer::const_iterator geomIt, geomIt_end = visibleGeometry.end(); 
    24392437 
    24402438        for (geomIt = visibleGeometry.begin(); geomIt != geomIt_end; ++geomIt) 
    … …  
    24562454//----------------------------------------------------------------------- 
    24572455void OcclusionCullingSceneManager::AddVisibleNodeGeometryToQueue( 
    2458                                                 const GtpVisibility::NodeInfoContainer &visibleNodes, 
     2456                                                const NodeInfoContainer &visibleNodes, 
    24592457                                                Camera *cam) 
    24602458{ 
    … …  
    24622460        //-- apply queries on node level 
    24632461 
    2464         GtpVisibility::NodeInfoContainer::const_iterator nodesIt, nodesIt_end = visibleNodes.end(); 
     2462        NodeInfoContainer::const_iterator nodesIt, nodesIt_end = visibleNodes.end(); 
    24652463 
    24662464        for (nodesIt = visibleNodes.begin(); nodesIt != nodesIt_end; ++ nodesIt) 
    … …  
    25292527        mVisibilityManager->SetQueryManager(queryManager); 
    25302528 
    2531         GtpVisibility::NodeInfoContainer visibleNodes; 
    2532         GtpVisibility::MeshInfoContainer visibleGeometry; 
    2533         GtpVisibility::PatchInfoContainer visiblePatches; 
     2529        NodeInfoContainer visibleNodes; 
     2530        MeshInfoContainer visibleGeometry; 
     2531        PatchInfoContainer visiblePatches; 
    25342532 
    25352533        if (mUseFromPointQueries) 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOcclusionQueriesQueryManager.cpp

    r2255 r2280  
    1 #include "OgreOcclusionQueriesQueryManager.h" 
    21#include <OgreLogManager.h> 
    32#include <OgreStringConverter.h> 
    43#include <vector> 
    54#include <OgreSubEntity.h> 
    6 #include "OgrePlatformHierarchyInterface.h" 
     5 
     6#include "OgreOcclusionQueriesQueryManager.h" 
     7//#include "OgrePlatformHierarchyInterface.h" 
    78#include "OgreOcclusionCullingSceneManager.h" 
    89#include "VisibilityEnvironment.h" 
    … …  
    1314 
    1415//-----------------------------------------------------------------------  
    15 OcclusionQueriesQueryManager::OcclusionQueriesQueryManager( 
    16                                                         GtpVisibility::HierarchyInterface *hierarchyInterface,  
     16/*OcclusionQueriesQueryManager::OcclusionQueriesQueryManager( 
     17                                                        PlatformHierarchyInterface *hierarchyInterface,  
    1718                                                        Viewport *vp, 
    1819                                                        int queryModes, 
    19                                                         int itemBufferMode): 
    20 PlatformQueryManager(hierarchyInterface, vp, queryModes),  
     20                                                        int itemBufferMode) 
     21:PlatformQueryManager(hierarchyInterface, vp, queryModes),  
    2122mItemBufferMode(itemBufferMode) 
    2223{ 
    23 } 
     24}*/ 
    2425//----------------------------------------------------------------------- 
    2526void OcclusionQueriesQueryManager::ComputeCameraVisibility( 
    2627                                                                                        const Camera &camera, 
    27                                                                                         GtpVisibility::NodeInfoContainer *visibleNodes, 
    28                                                                                         GtpVisibility::MeshInfoContainer *visibleGeometry, 
    29                                                                                         GtpVisibility::PatchInfoContainer *visiblePatches, 
     28                                                                                        NodeInfoContainer *visibleNodes, 
     29                                                                                        MeshInfoContainer *visibleGeometry, 
     30                                                                                        PatchInfoContainer *visiblePatches, 
    3031                                                                                        const bool relativeVisibility, 
    3132                                                                                        const bool approximateVisibility) 
    … …  
    119120 
    120121        // vector for storing entities of meshes 
    121         GtpVisibility::GeometryVector geometryList; 
     122        GeometryVector geometryList; 
    122123         
    123124        // store geometry of the hierarchy nodes in a geometry list 
    … …  
    131132         
    132133        // geometry list iterator 
    133         GtpVisibility::GeometryVector::iterator geometryIt, geometryIt_end = geometryList.end(); 
     134        GeometryVector::iterator geometryIt, geometryIt_end = geometryList.end(); 
    134135 
    135136        // vector for storing subentities of meshes 
    136         GtpVisibility::PatchVector patchList; 
     137        PatchVector patchList; 
    137138 
    138139        // store patchges of the geometries in a patch list 
    … …  
    145146        } 
    146147 
    147         GtpVisibility::PatchVector::iterator patchIt, patchIt_end = patchList.end(); 
     148        PatchVector::iterator patchIt, patchIt_end = patchList.end(); 
    148149 
    149150        // to obtain the correct number of projected pixels, depth write must be disabled 
    … …  
    183184                                const int projPixels = 1; 
    184185 
    185                                 visibleNodes->push_back(GtpVisibility::NodeInfo(*nodeIt, visPixels, projPixels)); 
     186                                visibleNodes->push_back(NodeInfo(*nodeIt, visPixels, projPixels)); 
    186187                                queryList[i].push_back(NULL); 
    187188                        } 
    … …  
    207208                                        const int projPixels = 1; 
    208209 
    209                                         visibleGeometry->push_back(GtpVisibility::MeshInfo(*geometryIt, visPixels, projPixels)); 
     210                                        visibleGeometry->push_back(MeshInfo(*geometryIt, visPixels, projPixels)); 
    210211                                } 
    211212                                else 
    … …  
    229230                                        const int projPixels = 1; 
    230231 
    231                                         visiblePatches->push_back(GtpVisibility::PatchInfo(*patchIt, visPixels, projPixels)); 
     232                                        visiblePatches->push_back(PatchInfo(*patchIt, visPixels, projPixels)); 
    232233                                } 
    233234                                else 
    … …  
    304305void OcclusionQueriesQueryManager::ComputeFromPointVisibility( 
    305306                                                                const Vector3 &point, 
    306                                                                 GtpVisibility::NodeInfoContainer *visibleNodes, 
    307                                                                 GtpVisibility::MeshInfoContainer *visibleGeometry, 
    308                                                                 GtpVisibility::PatchInfoContainer *visiblePatches, 
     307                                                                NodeInfoContainer *visibleNodes, 
     308                                                                MeshInfoContainer *visibleGeometry, 
     309                                                                PatchInfoContainer *visiblePatches, 
    309310                                                                const bool relativeVisibility, 
    310311                                                                const bool approximateVisibility) 
    … …  
    336337                                                GtpVisibility::QueryList::iterator &projQueryIt, 
    337338                                                GtpVisibility::NodeVector *nodeList,   
    338                                                 GtpVisibility::NodeInfoContainer *visibleNodes, 
     339                                                NodeInfoContainer *visibleNodes, 
    339340                                                bool relativeVisibility) 
    340341{ 
    … …  
    368369                if (visiblePixels > 0) 
    369370                { 
    370                         visibleNodes->push_back( 
    371                                 GtpVisibility::NodeInfo(*nodeIt, visiblePixels, projectedPixels)); 
     371                        visibleNodes->push_back(NodeInfo(*nodeIt, visiblePixels, projectedPixels)); 
    372372                } 
    373373        } 
    … …  
    376376void OcclusionQueriesQueryManager::CollectRelativeGeometryVisibilityForItemBuffer( 
    377377                                                                        GtpVisibility::QueryList::iterator &projQueryIt, 
    378                                                                         GtpVisibility::GeometryVector *geometryList,  
    379                                                                         GtpVisibility::MeshInfoContainer *visibleGeometry) 
    380 { 
    381         GtpVisibility::GeometryVector::iterator geometryIt; 
     378                                                                        GeometryVector *geometryList,  
     379                                                                        MeshInfoContainer *visibleGeometry) 
     380{ 
     381        GeometryVector::iterator geometryIt; 
    382382 
    383383        //-- queries for geometry 
    … …  
    400400void OcclusionQueriesQueryManager::CollectRelativePatchVisibilityForItemBuffer( 
    401401                                                                        GtpVisibility::QueryList::iterator &projQueryIt, 
    402                                                                         GtpVisibility::PatchVector *patchList,  
    403                                                                         GtpVisibility::PatchInfoContainer *visiblePatches) 
    404 { 
    405         GtpVisibility::PatchVector::iterator patchIt; 
     402                                                                        PatchVector *patchList,  
     403                                                                        PatchInfoContainer *visiblePatches) 
     404{ 
     405        PatchVector::iterator patchIt; 
    406406 
    407407        //-- queries for geometry 
    … …  
    425425                                                        GtpVisibility::QueryList::iterator &visQueryIt,  
    426426                                                        GtpVisibility::QueryList::iterator &projQueryIt, 
    427                                                         GtpVisibility::GeometryVector *geometryList,  
    428                                                         GtpVisibility::MeshInfoContainer *visibleGeometry, 
     427                                                        GeometryVector *geometryList,  
     428                                                        MeshInfoContainer *visibleGeometry, 
    429429                                                        bool relativeVisibility) 
    430430{ 
    431         GtpVisibility::GeometryVector::iterator geometryIt; 
     431        GeometryVector::iterator geometryIt; 
    432432 
    433433        //-- queries for geometry 
    … …  
    451451                if (visiblePixels > 0) 
    452452                {                         
    453                         visibleGeometry->push_back(GtpVisibility::MeshInfo(*geometryIt, visiblePixels,  
    454                                 projectedPixels)); 
     453                        visibleGeometry->push_back(MeshInfo(*geometryIt, visiblePixels, projectedPixels)); 
    455454                } 
    456455        } 
    … …  
    460459                                                        GtpVisibility::QueryList::iterator &visQueryIt,  
    461460                                                        GtpVisibility::QueryList::iterator &projQueryIt, 
    462                                                         GtpVisibility::PatchVector *patchList,  
    463                                                         GtpVisibility::PatchInfoContainer *visiblePatches, 
     461                                                        PatchVector *patchList,  
     462                                                        PatchInfoContainer *visiblePatches, 
    464463                                                        bool relativeVisibility) 
    465464{ 
    466         GtpVisibility::PatchVector::iterator patchIt; 
     465        PatchVector::iterator patchIt; 
    467466 
    468467        //-- queries for patch 
    … …  
    486485                if (visiblePixels > 0) 
    487486                {                         
    488                         visiblePatches->push_back(GtpVisibility::PatchInfo(*patchIt, visiblePixels,  
    489                                 projectedPixels)); 
     487                        visiblePatches->push_back( 
     488                                PatchInfo(*patchIt, visiblePixels, projectedPixels)); 
    490489                } 
    491490        } 
    … …  
    493492//----------------------------------------------------------------------- 
    494493void  OcclusionQueriesQueryManager::RemoveDuplicateNodes( 
    495                                         GtpVisibility::NodeInfoContainer *visibleNodes) 
     494                                        NodeInfoContainer *visibleNodes) 
    496495{ 
    497496        sort(visibleNodes->begin(), visibleNodes->end()); 
    498497 
    499         GtpVisibility::NodeInfoContainer::iterator visibleNodesIt, 
     498        NodeInfoContainer::iterator visibleNodesIt, 
    500499                visibleNodesIt_end = visibleNodes->end(); 
    501500         
    502         GtpVisibility::NodeInfo *nodeInfo = NULL; 
     501        NodeInfo *nodeInfo = NULL; 
    503502 
    504503        for (visibleNodesIt = visibleNodes->begin(); visibleNodesIt != visibleNodesIt_end;  
    … …  
    521520//----------------------------------------------------------------------- 
    522521void  OcclusionQueriesQueryManager::RemoveDuplicateGeometry( 
    523                                 GtpVisibility::MeshInfoContainer *visibleGeometry) 
     522                                MeshInfoContainer *visibleGeometry) 
    524523{ 
    525524        sort(visibleGeometry->begin(), visibleGeometry->end()); 
    526525         
    527         GtpVisibility::MeshInfoContainer::iterator visibleGeomIt, 
     526        MeshInfoContainer::iterator visibleGeomIt, 
    528527                        visibleGeomIt_end = visibleGeometry->end(); 
    529528 
    530         GtpVisibility::MeshInfo *geomInfo = NULL; 
     529        MeshInfo *geomInfo = NULL; 
    531530 
    532531        for (visibleGeomIt = visibleGeometry->begin(); visibleGeomIt != visibleGeomIt_end;  
    … …  
    549548//----------------------------------------------------------------------- 
    550549void  OcclusionQueriesQueryManager::RemoveDuplicatePatches( 
    551                                 GtpVisibility::PatchInfoContainer *visiblePatches) 
     550                                PatchInfoContainer *visiblePatches) 
    552551{ 
    553552        sort(visiblePatches->begin(), visiblePatches->end()); 
    554553         
    555         GtpVisibility::PatchInfoContainer::iterator visiblePatchIt, 
     554        PatchInfoContainer::iterator visiblePatchIt, 
    556555                        visiblePatchIt_end = visiblePatches->end(); 
    557556 
    558         GtpVisibility::PatchInfo *patchInfo = NULL; 
     557        PatchInfo *patchInfo = NULL; 
    559558 
    560559        for (visiblePatchIt = visiblePatches->begin(); visiblePatchIt != visiblePatchIt_end;  
    … …  
    577576//----------------------------------------------------------------------- 
    578577void OcclusionQueriesQueryManager::GetNodePatchList(GtpVisibility::HierarchyNode *node,  
    579                                                                                                         GtpVisibility::PatchVector *patchList) 
    580 { 
    581         GtpVisibility::GeometryVector geomList; 
     578                                                                                                        PatchVector *patchList) 
     579{ 
     580        GeometryVector geomList; 
    582581        mHierarchyInterface->GetNodeGeometryList(node, &geomList, false); 
    583582 
    584583        // geometry list iterator 
    585         GtpVisibility::GeometryVector::iterator geomIt, geomIt_end = geomList.end(); 
     584        GeometryVector::iterator geomIt, geomIt_end = geomList.end(); 
    586585 
    587586        for (geomIt = geomList.begin(); geomIt != geomIt_end; ++geomIt) 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreOctreeHierarchyInterface.cpp

    r2278 r2280  
    189189                int y = (i & 2) / 2; 
    190190                int z = i & 1; 
    191  
     191                Ogre::LogManager::getSingleton().logMessage("y"); 
    192192                //std::stringstream d; d << "x " << x << " y " << y << " z " << z; 
    193193                //LogManager::getSingleton().logMessage(d.str()); 
    … …  
    304304//----------------------------------------------------------------------- 
    305305void OctreeHierarchyInterface::GetNodeGeometryList(GtpVisibility::HierarchyNode *node, 
    306                                                                                                    GtpVisibility::GeometryVector *geometryList,  
     306                                                                                                   GeometryVector *geometryList,  
    307307                                                                                                   bool includeChildren) 
    308308{ 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgrePlatformQueryManager.cpp

    r2255 r2280  
    88#include "OgrePlatformHierarchyInterface.h" 
    99 
     10 
     11 
    1012namespace Ogre { 
    1113 
    1214//-----------------------------------------------------------------------  
    13 PlatformQueryManager::PlatformQueryManager(GtpVisibility::HierarchyInterface *hierarchyInterface,  
     15/* 
     16PlatformQueryManager::PlatformQueryManager(PlatformHierarchyInterface *hierarchyInterface,  
    1417                                                                                   Viewport *vp,  
    1518                                                                                   int queryModes): 
    16 QueryManager(hierarchyInterface, queryModes),  
     19//QueryManager(hierarchyInterface, queryModes),  
     20QueryManager(queryModes), 
    1721mViewport(vp),  
    18 mWasInitialised(false) 
    19 { 
    20 } 
    21 //----------------------------------------------------------------------- 
    22 bool PlatformQueryManager::ShootRay(const Ray &ray,  
     22mWasInitialised(false), 
     23mHierarchyInterface(hierarchyInterface) 
     24{ 
     25}*/ 
     26//----------------------------------------------------------------------- 
     27/*bool PlatformQueryManager::ShootRay(const Ray &ray,  
    2328                                                                        std::vector<Mesh *> *visibleMeshes,  
    2429                                                                        bool isGlobalLine) 
    … …  
    2631    // run OGRE ray shooting query 
    2732    return false; 
    28 } 
     33}*/ 
    2934//----------------------------------------------------------------------- 
    3035void PlatformQueryManager::ComputeFromPointVisibility( 
    31                                         const Vector3 &point, 
    32                                         GtpVisibility::NodeInfoContainer *visibleNodes, 
    33                                         GtpVisibility::MeshInfoContainer *visibleGeometry, 
    34                                         GtpVisibility::PatchInfoContainer *visiblePatches, 
    35                                         const bool relativeVisibility, 
    36                                         const bool approximateVisibility) 
     36                                                                                        const Vector3 &point, 
     37                                                                                        NodeInfoContainer *visibleNodes, 
     38                                                                                        MeshInfoContainer *visibleGeometry, 
     39                                                                                        PatchInfoContainer *visiblePatches, 
     40                                                                                        const bool relativeVisibility, 
     41                                                                                        const bool approximateVisibility) 
    3742{ 
    3843        SceneManager *sm = 
    … …  
    105110void PlatformQueryManager::ComputeCameraVisibility( 
    106111                                                                        const Camera &camera, 
    107                                                                         GtpVisibility::NodeInfoContainer *visibleNodes, 
    108                                                                         GtpVisibility::MeshInfoContainer *visibleGeometry, 
    109                                                                         GtpVisibility::PatchInfoContainer *visiblePatches, 
     112                                                                        NodeInfoContainer *visibleNodes, 
     113                                                                        MeshInfoContainer *visibleGeometry, 
     114                                                                        PatchInfoContainer *visiblePatches, 
    110115                                                                        const bool relativeVisibility, 
    111116                                                                        const bool approximateVisibility) 
    … …  
    162167//----------------------------------------------------------------------- 
    163168void PlatformQueryManager::CollectItemBufferResults( 
    164                                 GtpVisibility::MeshInfoContainer *visibleGeometry, 
    165                                 GtpVisibility::PatchInfoContainer *visiblePatches) 
     169                                MeshInfoContainer *visibleGeometry, 
     170                                PatchInfoContainer *visiblePatches) 
    166171{ 
    167172        int dimx = 0; 
    … …  
    205210//----------------------------------------------------------------------- 
    206211void PlatformQueryManager::InitItemBuffer( 
    207                                 GtpVisibility::MeshInfoContainer *visibleGeometry, 
    208                                 GtpVisibility::PatchInfoContainer *visiblePatches) 
     212                                MeshInfoContainer *visibleGeometry, 
     213                                PatchInfoContainer *visiblePatches) 
    209214{ 
    210215        if (mWasInitialised) 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreSceneContentGenerator.cpp

    r2278 r2280  
    5454                                         const Quaternion &orientation, const String& objName) 
    5555{ 
    56         char name[25]; 
     56        char name[300]; 
    5757 
    5858        sprintf(name, "%s Entity%d", objName.c_str(), GetObjectCount()); 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreSceneNodeHierarchyInterface.cpp

    r370 r2280  
    137137//----------------------------------------------------------------------- 
    138138void SceneNodeHierarchyInterface::GetNodeGeometryList(GtpVisibility::HierarchyNode *node,        
    139                                                                                           GtpVisibility::GeometryVector *geometryList,  
    140                                                                                           bool includeChildren) 
     139                                                                                                          GeometryVector *geometryList,  
     140                                                                                                          bool includeChildren) 
    141141{ 
    142142        SceneNode::ObjectIterator objIt =  

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreVisibilitySceneManagerDll.cpp

    r1320 r2280  
    2929#include <OgreRoot.h> 
    3030#include <OgreLogManager.h> 
     31#include <fstream> 
    3132 
    3233#include "OgreBvHierarchySceneManager.h" 
    3334#include "VisibilityManager.h" 
    3435#include "VisibilityEnvironment.h" 
    35                  
     36#include "CullingManager.h" 
     37 
     38 
    3639GtpVisibility::VisibilityEnvironment *visEnv; 
    3740GtpVisibility::VisibilityManager *visManager; 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/Plugin_VisibilitySceneManager.vcproj

    r2278 r2280  
    282282                <Configuration 
    283283                        Name="Release Internal|Win32" 
    284                         OutputDirectory="Release" 
    285                         IntermediateDirectory="Release" 
     284                        OutputDirectory="..\lib\Release" 
     285                        IntermediateDirectory="..\obj\Release" 
    286286                        ConfigurationType="2" 
    287287                        CharacterSet="2" 
    … …  
    293293                                InlineFunctionExpansion="2" 
    294294                                EnableIntrinsicFunctions="TRUE" 
    295                                 ImproveFloatingPointConsistency="TRUE" 
     295                                ImproveFloatingPointConsistency="FALSE" 
    296296                                FavorSizeOrSpeed="1" 
    297297                                OmitFramePointers="TRUE" 
    … …  
    300300                                OptimizeForWindowsApplication="TRUE" 
    301301                                AdditionalIncludeDirectories="&quot;$(OGRE_PATH)\PlugIns\OctreeSceneManager\include&quot;;&quot;$(OGRE_PATH)\Samples\Common\include&quot;;&quot;$(OGRE_PATH)\Dependencies\include\CEGUI&quot;;&quot;$(OGRE_PATH)\Samples\Common\CEGUIRenderer\include&quot;;&quot;$(OGRE_PATH)\OgreMain\include&quot;;&quot;$(OGRE_PATH)\Dependencies\include&quot;;..\include;..\..\..\OnlineCullingCHC\include;..\..\..\Preprocessing\src;..\..\..\..\..\Lib\Vis\OnlineCullingCHC\IVReader\include;..\..\..\..\..\Lib\Vis\OnlineCullingCHC\ObjReader\include" 
    302                                 PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;GTP_VISIBILITY_MODIFIED_OGRE;PLUGIN_KD_TERRAIN_EXPORTS" 
     302                                PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;GTP_VISIBILITY_MODIFIED_OGRE;GAMETOOLS_ILLUMINATION_MODULE;PLUGIN_KD_TERRAIN_EXPORTS" 
    303303                                StringPooling="TRUE" 
    304304                                RuntimeLibrary="2" 
    … …  
    322322                                AdditionalLibraryDirectories="&quot;$(OGRE_PATH)\PlugIns\OctreeSceneManager\bin\Release&quot;;&quot;$(OGRE_PATH)\OgreMain\lib\Release&quot;;&quot;$(OGRE_PATH)\Samples\Common\CEGUIRenderer\lib&quot;;..\..\GtpVisibility\lib\Release;..\..\lib\Release;..\lib\Release;&quot;$(OGRE_PATH)\Dependencies\lib\Release&quot;;..\..\..\Preprocessing\lib\Release;..\..\..\..\..\..\..\NonGTP\Xerces\xercesc\lib;..\..\..\Preprocessing\src\GL;&quot;$(CG_LIB_PATH)&quot;;..\..\..\..\..\..\..\NonGTP\Zlib\lib;..\..\..\..\..\Lib\Vis\Preprocessing\MultiLevelRayTracing\RTWorld\Release;..\..\..\..\..\Lib\Vis\Preprocessing\MultiLevelRayTracing\RTScene\Release;..\..\..\..\..\Lib\Vis\OnlineCullingCHC\IVReader\lib\Release;..\..\..\..\..\Lib\Vis\OnlineCullingCHC\ObjReader\lib\Release" 
    323323                                ModuleDefinitionFile="..\misc\OgreVisibilitySceneManager.def" 
    324                                 GenerateDebugInformation="TRUE" 
     324                                GenerateDebugInformation="FALSE" 
    325325                                SubSystem="2" 
    326326                                OptimizeReferences="2" 
    … …  
    635635                                RelativePath="..\include\OgreVisibilityOptionsManager.h"> 
    636636                        </File> 
     637                        <File 
     638                                RelativePath="..\include\VisibilityMesh.h"> 
     639                        </File> 
    637640                </Filter> 
    638641                <Filter 
Note: See TracChangeset for help on using the changeset viewer.