Changeset 2280


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

removed dependency on ogre in gtpvisibility

Location:
GTP/trunk/Lib/Vis
Files:
2 added
55 edited
1 moved

Legend:

Unmodified
Added
Removed

  • GTP/trunk/Lib/Vis/GtpVisibility.sln

    r2278 r2280  
    1414Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Plugin_VisibilitySceneManager", "OnlineCullingCHC\OGRE\src\Plugin_VisibilitySceneManager.vcproj", "{80DECC17-BDDD-4412-8CF8-F7C1C17A7436}" 
    1515        ProjectSection(ProjectDependencies) = postProject 
     16                {5776B40B-5FCE-46D5-8F7C-3912E24E0638} = {5776B40B-5FCE-46D5-8F7C-3912E24E0638} 
    1617                {5776B40B-5FCE-46D5-8F7C-3912E24E0638} = {5776B40B-5FCE-46D5-8F7C-3912E24E0638} 
    1718                {5776B40B-5FCE-46D5-8F7C-3912E24E0638} = {5776B40B-5FCE-46D5-8F7C-3912E24E0638} 
    … …  
    1920                {101A7691-74F3-48B4-96A3-CF35578F5900} = {101A7691-74F3-48B4-96A3-CF35578F5900} 
    2021                {EABCE292-D598-4600-A1C9-2591E7D62FDA} = {EABCE292-D598-4600-A1C9-2591E7D62FDA} 
     22                {7319E499-473D-4CE5-9983-725D6E68A55D} = {7319E499-473D-4CE5-9983-725D6E68A55D} 
     23                {7319E499-473D-4CE5-9983-725D6E68A55D} = {7319E499-473D-4CE5-9983-725D6E68A55D} 
     24                {7319E499-473D-4CE5-9983-725D6E68A55D} = {7319E499-473D-4CE5-9983-725D6E68A55D} 
     25                {7319E499-473D-4CE5-9983-725D6E68A55D} = {7319E499-473D-4CE5-9983-725D6E68A55D} 
     26                {7319E499-473D-4CE5-9983-725D6E68A55D} = {7319E499-473D-4CE5-9983-725D6E68A55D} 
     27                {7319E499-473D-4CE5-9983-725D6E68A55D} = {7319E499-473D-4CE5-9983-725D6E68A55D} 
     28                {7319E499-473D-4CE5-9983-725D6E68A55D} = {7319E499-473D-4CE5-9983-725D6E68A55D} 
     29                {7319E499-473D-4CE5-9983-725D6E68A55D} = {7319E499-473D-4CE5-9983-725D6E68A55D} 
    2130        EndProjectSection 
    2231EndProject 
    … …  
    3241Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TestCullingTerrain", "..\..\App\Demos\Vis\HillyTerrain\OGRE\TestCullingTerrain.vcproj", "{248F19A6-2FE0-4F5D-8928-E0EA10609887}" 
    3342        ProjectSection(ProjectDependencies) = postProject 
     43                {5776B40B-5FCE-46D5-8F7C-3912E24E0638} = {5776B40B-5FCE-46D5-8F7C-3912E24E0638} 
    3444                {80DECC17-BDDD-4412-8CF8-F7C1C17A7436} = {80DECC17-BDDD-4412-8CF8-F7C1C17A7436} 
    3545                {101A7691-74F3-48B4-96A3-CF35578F5900} = {101A7691-74F3-48B4-96A3-CF35578F5900} 
    … …  
    3848Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "TestKdTree", "..\..\App\Demos\Vis\KdTreeDemo\OGRE\scripts\TestKdTree.vcproj", "{17F2C6F9-6101-430E-ABF4-71383868EF24}" 
    3949        ProjectSection(ProjectDependencies) = postProject 
    40                 {5776B40B-5FCE-46D5-8F7C-3912E24E0638} = {5776B40B-5FCE-46D5-8F7C-3912E24E0638} 
    4150                {5776B40B-5FCE-46D5-8F7C-3912E24E0638} = {5776B40B-5FCE-46D5-8F7C-3912E24E0638} 
    4251                {80DECC17-BDDD-4412-8CF8-F7C1C17A7436} = {80DECC17-BDDD-4412-8CF8-F7C1C17A7436} 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/IVReader/src/IVReader.vcproj

    r2278 r2280  
    228228                <Configuration 
    229229                        Name="Release Internal|Win32" 
    230                         OutputDirectory="Release" 
    231                         IntermediateDirectory="Release" 
     230                        OutputDirectory="..\lib\Release" 
     231                        IntermediateDirectory="..\obj\Release" 
    232232                        ConfigurationType="2" 
    233233                        CharacterSet="2"> 
    … …  
    244244                                OptimizeForWindowsApplication="TRUE" 
    245245                                AdditionalIncludeDirectories="&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;;&quot;$(OGRE_PATH)\Samples\Common\include&quot;;..\include" 
    246                                 PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;IVREADER_EXPORTS;GTP_VISIBILITY_MODIFIED_OGRE" 
     246                                PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;IVREADER_EXPORTS;GTP_VISIBILITY_MODIFIED_OGRE;GAMETOOLS_ILLUMINATION_MODULE" 
    247247                                StringPooling="TRUE" 
    248248                                RuntimeLibrary="2" 

  • 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 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/ObjReader/src/ObjReader.cpp

    r2124 r2280  
    3131{ 
    3232        GtpVisibilityPreprocessor::Debug.open("debug.log"); 
     33 
    3334        // HACK: get any preprocessor to load file 
    3435        // note should be preserved to allow manual mesh reloading, 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/ObjReader/src/ObjReader.vcproj

    r2278 r2280  
    227227                <Configuration 
    228228                        Name="Release Internal|Win32" 
    229                         OutputDirectory="Release" 
    230                         IntermediateDirectory="Release" 
     229                        OutputDirectory="..\lib\Release" 
     230                        IntermediateDirectory="..\obj\Release" 
    231231                        ConfigurationType="2" 
    232232                        CharacterSet="2"> 
    … …  
    243243                                OptimizeForWindowsApplication="TRUE" 
    244244                                AdditionalIncludeDirectories="&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;;&quot;$(OGRE_PATH)\Samples\Common\include&quot;;..\include;..\..\..\Preprocessing\src" 
    245                                 PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;OBJREADER_EXPORTS;GTP_VISIBILITY_MODIFIED_OGRE" 
     245                                PreprocessorDefinitions="WIN32;NDEBUG;_WINDOWS;_USRDLL;OBJREADER_EXPORTS;GTP_VISIBILITY_MODIFIED_OGRE;GAMETOOLS_ILLUMINATION_MODULE" 
    246246                                StringPooling="TRUE" 
    247247                                RuntimeLibrary="2" 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/include/CullingManager.h

    r2278 r2280  
    22#define _CullingManager_H__ 
    33 
     4#include <iostream> 
     5#include <fstream> 
    46#include "HierarchyInterface.h" 
     7 
    58 
    69 
    … …  
    811 
    912/** This abstract class implements an interface for a specific culling  
    10         algorithm. The algorithm is either used to render a scene  
    11         or to make a visibility query. 
     13        algorithm. The algorithm is either used to render a scene or to make a visibility query. 
    1214*/ 
    1315class CullingManager 
    … …  
    5456        void SetVisualizeCulledNodes(bool visualizeCulledNodes); 
    5557 
     58 
    5659protected: 
    5760         
    … …  
    6366        HierarchyInterface *mHierarchyInterface; 
    6467        bool mVisualizeCulledNodes; 
     68 
    6569}; 
     70 
    6671} // namespace GtpVisibility 
    6772#endif // CullingManager 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/include/DummyPreprocessingManager.h

    r2278 r2280  
    4242      Returns false if no viewcell was found. 
    4343    */ 
    44   virtual bool LocateViewCellIds(const Vector3 &center, 
    45                                 const float radius, 
    46                                 vector<int> *viewCellIds 
    47                                  ); 
    48  
     44  /*virtual bool LocateViewCellIds(const Vector3 &center, 
     45                                                                const float radius, 
     46                                                                vector<int> *viewCellIds 
     47                                                                ); 
     48*/ 
    4949 
    5050  /** 
    … …  
    5252     a union with visibleNodes and visibleMeshes. Returns the number of added entries. 
    5353  */ 
    54   virtual int AddViewCellPVS(const int cellID, 
    55                             NodeInfoContainer *visibleNodes, 
    56                             MeshInfoContainer *visibleMeshes); 
     54  //virtual int AddViewCellPVS(const int cellID, 
     55//                                              NodeInfoContainer *visibleNodes, 
     56//                                              MeshInfoContainer *visibleMeshes); 
    5757 
    5858}; 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/include/DummyQueryManager.h

    r2255 r2280  
    1919      QueryManager(hierarchyInterface, 0) {} 
    2020     
    21     /** 
    22        @sa QueryManager::ComputeCameraVisibility() 
    23      */ 
     21    /** @sa QueryManager::ComputeCameraVisibility() 
     22    */ 
    2423    virtual void ComputeCameraVisibility(const Camera &camera, 
    2524                                                                                 NodeInfoContainer *visibleNodes, 
    … …  
    2928                                                                                 const bool approximateVisibility); 
    3029     
    31     /** 
    32        @sa QueryManager::ComputeFromPointVisibility() 
     30    /** @sa QueryManager::ComputeFromPointVisibility() 
    3331    */ 
    3432    virtual void ComputeFromPointVisibility(const Vector3 &point, 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/include/HierarchyInterface.h

    r2259 r2280  
    33 
    44#include "DistanceQueue.h" 
    5 #include "VisibilityMesh.h" 
     5//#include "VisibilityMesh.h" 
    66#include <stack> 
    77 
    … …  
    1111 
    1212typedef std::vector<HierarchyNode *> NodeVector; 
    13 typedef std::vector<GtpVisibility::Mesh *> GeometryVector; 
    14 typedef std::vector<GtpVisibility::Patch *> PatchVector; 
     13//typedef std::vector<GtpVisibility::Mesh *> GeometryVector; 
     14//typedef std::vector<GtpVisibility::Patch *> PatchVector; 
     15 
    1516typedef std::pair<HierarchyNode *, OcclusionQuery *> QueryPair; 
    1617typedef std::pair<HierarchyNode *, bool> PendingQuery; 
    … …  
    139140        */ 
    140141         
    141         /** Returns the geometry of a given hierarchy node.  
    142                 @param node the hierarchy node containing the geometry 
    143                 @param geometryList geometry is returned in this list 
    144                 @param includeChildren if the geometry of the children should be taken into account 
    145         */ 
    146         virtual void GetNodeGeometryList(GtpVisibility::HierarchyNode *node,     
    147                                                                          GeometryVector *geometryList,  
    148                                                                          bool includeChildren) = 0; 
    149  
    150142         
    151143        /** This is an optimization when issuing the occlusion test.  

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/include/PreprocessingManager.h

    r316 r2280  
    77#include "HierarchyInterface.h" 
    88#include "VisibilityInfo.h" 
    9 #include "VisibilityVector3.h" 
     9//#include "VisibilityVector3.h" 
    1010 
    1111namespace GtpVisibility { 
    … …  
    8080        added to the container. Returns true if the corresponding PVS exists. 
    8181    */ 
    82     virtual bool GetPVS(const Vector3 &point, 
     82 /*   virtual bool GetPVS(const Vector3 &point, 
    8383                        const float radius, 
    8484                        NodeInfoContainer *visibleNodes, 
    8585                        MeshInfoContainer *visibleMeshes); 
    86      
     86   */  
    8787     
    8888   
    … …  
    115115        Returns false if no viewcell was found. 
    116116    */ 
    117     virtual bool LocateViewCellIds(const Vector3 &center, 
     117/*    virtual bool LocateViewCellIds(const Vector3 &center, 
    118118                                   const float radius, 
    119119                                   vector<int> *viewCellIds 
    120120                                   ) = 0; 
    121      
     121  */   
    122122    /** 
    123123       Add a PVS of the given viewcell to the already evaluated PVS by computing 
    124124       a union with visibleNodes and visibleMeshes. Returns the number of added entries. 
    125125    */ 
    126     virtual int AddViewCellPVS(const int cellID, 
     126   /* virtual int AddViewCellPVS(const int cellID, 
    127127                                                           NodeInfoContainer *visibleNodes, 
    128128                                                           MeshInfoContainer *visibleMeshes ) = 0; 
    129      
     129    */ 
    130130    HierarchyInterface *mSceneTraverser; 
    131131  }; 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/include/QueryManager.h

    r2255 r2280  
    55 
    66#include "VisibilityInfo.h" 
    7 #include "VisibilityVector3.h" 
    8 #include "VisibilityCamera.h" 
    9 #include "VisibilityRay.h" 
     7//#include "VisibilityCamera.h" 
     8//#include "VisibilityRay.h" 
     9 
    1010 
    1111namespace GtpVisibility { 
    12    
     12 
     13 
    1314typedef std::vector<OcclusionQuery *> QueryList; 
    1415 
    … …  
    2526public: 
    2627    /** Constructor taking a hierarchy interface as an argument. This allows to operate 
    27         on different hierarchy types, while reusing the implementation of the query methods. 
     28                on different hierarchy types, while reusing the implementation of the query methods. 
    2829     */ 
    29     QueryManager(HierarchyInterface *hierarchyInterface, int queryModes); 
    30      
    31     /**  
    32         Computes restricted visibility from point by using an explicit camera to execute 
    33         the visibility query. 
    34         @param camera The camera to be used 
     30    //QueryManager(HierarchyInterface *hierarchyInterface, int queryModes); 
     31    QueryManager(int queryModes); 
    3532 
    36         @param visibleNodes Pointer to the container where visible nodes should be added. 
    37         This set is formed of visible leafs or fully visible interior nodes. 
    38         If NULL no visible nodes are not evaluated. 
     33    /** Computes restricted visibility from point by using an explicit camera to execute 
     34                the visibility query. 
     35                @param camera The camera to be used 
    3936 
    40         @param visibleGeometry Pointer to the container where visible meshes should be added. 
    41         If NULL no visible meshes are not evaluated. 
     37                @param visibleNodes Pointer to the container where visible nodes should be added. 
     38                This set is formed of visible leafs or fully visible interior nodes. 
     39                If NULL no visible nodes are not evaluated. 
    4240 
    43         @param visiblePatches Pointer to the container where visible patches should be added. 
    44         If NULL no visible meshes are not evaluated. 
     41                @param visibleGeometry Pointer to the container where visible meshes should be added. 
     42                If NULL no visible meshes are not evaluated. 
    4543 
    46         @param relativeVisibility If true the visibility member for 
    47         NodeInfo and MeshInfo represent relative visibility; i.e. the number of visible 
    48         pixels divided by the the number of projected pixels. 
     44                @param visiblePatches Pointer to the container where visible patches should be added. 
     45                If NULL no visible meshes are not evaluated. 
    4946 
    50         @return true if the corresponding PVS exists. 
     47                @param relativeVisibility If true the visibility member for 
     48                NodeInfo and MeshInfo represent relative visibility; i.e. the number of visible 
     49                pixels divided by the the number of projected pixels. 
     50 
     51                @return true if the corresponding PVS exists. 
    5152    */ 
    52     virtual void 
    53     ComputeCameraVisibility(const Camera &camera, 
    54                             NodeInfoContainer *visibleNodes, 
    55                             MeshInfoContainer *visibleGeometry, 
    56                                 PatchInfoContainer *visiblePatches, 
    57                             const bool relativeVisibility, 
    58                                 const bool approximateVisibility 
    59                             ) = 0; 
    60      
     53    /*virtual void ComputeCameraVisibility(const Camera &camera, 
     54                                                                                 NodeInfoContainer *visibleNodes, 
     55                                                                                 MeshInfoContainer *visibleGeometry, 
     56                                                                                 PatchInfoContainer *visiblePatches, 
     57                                                                                 const bool relativeVisibility, 
     58                                                                                 const bool approximateVisibility) = 0; 
     59    */ 
    6160    /**  
    6261        Uses the specified point to execute the visibility query in all directions.  
    6362        @sa ComputeCameraVisibility() 
    6463    */ 
    65     virtual void 
     64    /*virtual void 
    6665    ComputeFromPointVisibility(const Vector3 &point, 
    67                                NodeInfoContainer *visibleNodes, 
    68                                MeshInfoContainer *visibleGeometry, 
    69                                    PatchInfoContainer *visiblePatches, 
    70                                const bool relativeVisibility, 
    71                                    const bool approximateVisibility 
    72                                ) = 0; 
    73      
     66                                                           NodeInfoContainer *visibleNodes, 
     67                                                           MeshInfoContainer *visibleGeometry, 
     68                                                           PatchInfoContainer *visiblePatches, 
     69                                                           const bool relativeVisibility, 
     70                                                           const bool approximateVisibility) = 0; 
     71    */ 
    7472  /**  
    7573      Ray shooting interface: finds an intersection with objects in the scene. 
    7674 
    7775      @param ray The given input ray (assuming the ray direction is normalized) 
    78  
    7976      @param visibleMeshes List of meshes intersecting the ray 
    80  
    8177      @param isGlobalLine If false only first intersection with opaque object is returned. 
    8278      Otherwise all intersections of the ray with the scene are found. 
    8379 
    84       @return true if there is any intersection.  
     80          @return true if there is any intersection.  
    8581        */ 
    86     virtual bool 
    87                 ShootRay(const Ray &ray, 
    88              std::vector<Mesh *> *visibleMeshes, 
    89              bool isGlobalLine = false 
    90              ); 
    91    
     82    /*virtual bool ShootRay(const Ray &ray, 
     83                                                  std::vector<Mesh *> *visibleMeshes, 
     84                                                  bool isGlobalLine = false); 
     85*/ 
    9286        /** Sets the hierarchy interface. 
    9387      @remark the traversal depends on the type of hierarchyInterface the scene consists of. 
    … …  
    10195protected: 
    10296   
    103         HierarchyInterface *mHierarchyInterface; 
     97        //HierarchyInterface *mHierarchyInterface; 
    10498        int mQueryModes;   
    10599}; 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/include/VisibilityInfo.h

    r318 r2280  
    44#include <vector> 
    55 
    6 #include "VisibilityMesh.h" 
     6//#include "VisibilityMesh.h" 
    77#include "HierarchyInterface.h" 
    88 
    … …  
    132132} 
    133133 
    134 typedef VisibilityInfo<Patch *> PatchInfo; 
    135 typedef VisibilityInfo<Mesh *> MeshInfo; 
    136 typedef VisibilityInfo<HierarchyNode *> NodeInfo; 
    137  
    138  
    139134template<class T> 
    140135struct InfoContainer 
    … …  
    143138}; 
    144139 
    145 typedef std::vector<PatchInfo> PatchInfoContainer; 
    146 typedef std::vector<MeshInfo> MeshInfoContainer; 
    147 typedef std::vector<NodeInfo> NodeInfoContainer; 
    148140 
    149141} // namespace GtpVisibility 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/include/VisibilityManager.h

    r2278 r2280  
    6868        VisibilityEnvironment *GetVisibilityEnvironment(); 
    6969 
     70 
    7071protected: 
    7172         

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/BatchedQueriesCullingManager.cpp

    r951 r2280  
    11#include "BatchedQueriesCullingManager.h" 
    2 #include <OgreLogManager.h> 
     2 
    33 
    44namespace GtpVisibility { 
    … …  
    2121        QueryQueue queryQueue; 
    2222        unsigned int visiblePixels = 0; 
    23  
    24         //Ogre::LogManager::getSingleton().logMessage("Batched Culling"); 
    2523 
    2624        PendingQueue pendingQueue; 
    … …  
    9088                                        DecideVisible(node) && mHierarchyInterface->HasGeometry(node); 
    9189 
    92                                 //if (mHierarchyInterface->LastVisited(node) >= mHierarchyInterface->GetFrameId()) 
    93                                 //      Ogre::LogManager::getSingleton().logMessage("error"); 
    94                                  
    9590                                if (skipQuery) 
    9691                                { 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/CoherentHierarchicalCullingManager.cpp

    r2258 r2280  
    11#include "CoherentHierarchicalCullingManager.h" 
    2 #include <OgreLogManager.h> 
     2#include <time.h> 
    33 
    44namespace GtpVisibility { 
    … …  
    143143                        mThreshold = RAND_MAX; 
    144144        } 
    145         //std::stringstream d; d << "*** setting assumed vis: " << mAssumedVisibility; Ogre::LogManager::getSingleton().logMessage(d.str()); 
     145         
    146146} 
    147147//----------------------------------------------------------------------- 
    148148inline bool CoherentHierarchicalCullingManager::DecideVisible(HierarchyNode *node) const 
    149149{ 
    150         //bool result = rand() < mThreshold; std::stringstream d; d << "Assumed vis: " << mAssumedVisibility << ", result: " << result; 
    151         //Ogre::LogManager::getSingleton().logMessage(d.str()); return result; 
    152          
    153150        return rand() < mThreshold; 
    154151} 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/CullingManager.cpp

    r112 r2280  
    11#include "CullingManager.h" 
     2 
    23 
    34namespace GtpVisibility { 
    45 
     6 
     7 
    58//----------------------------------------------------------------------- 
    69CullingManager::CullingManager(): 
    7 mHierarchyInterface(NULL), mVisibilityThreshold(0), mNumQueryCulledNodes(0),  
    8 mNumFrustumCulledNodes(0), mNumQueriesIssued(0), 
     10mHierarchyInterface(NULL),  
     11mVisibilityThreshold(0),  
     12mNumQueryCulledNodes(0),  
     13mNumFrustumCulledNodes(0),  
     14mNumQueriesIssued(0), 
    915mVisualizeCulledNodes(false) 
    1016{ 
    1117} 
     18 
     19 
    1220//----------------------------------------------------------------------- 
    1321void CullingManager::SetHierarchyInterface(HierarchyInterface *hierarchyInterface) 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/DummyPreprocessingManager.cpp

    r316 r2280  
    11#include "DummyPreprocessingManager.h" 
     2#include <iostream> 
     3#include <fstream> 
    24 
    35namespace GtpVisibility { 
    … …  
    2527 
    2628   
    27   /**  
    28       Find viewcells intersecting a spherical neighborhood of a point. 
    29       Returns false if no viewcell was found. 
    30     */ 
    31 bool DummyPreprocessingManager::LocateViewCellIds(const Vector3 &center, 
     29   
     30/*bool DummyPreprocessingManager::LocateViewCellIds(const Vector3 &center, 
    3231                                                                                                  const float radius, 
    3332                                                                                                  vector<int> *viewCellIds) 
    3433{ 
    3534  return false; 
    36 } 
     35}*/ 
    3736   
    38 /**  
    39     Uses the specified viewcell to find its PVS 
    40 */ 
    41 int DummyPreprocessingManager::AddViewCellPVS(const int cellID, 
     37/*int DummyPreprocessingManager::AddViewCellPVS(const int cellID, 
    4238                                          NodeInfoContainer *visibleNodes, 
    4339                                          MeshInfoContainer *visibleMeshes ) 
    … …  
    4743  return false; 
    4844} 
    49  
     45*/ 
    5046} 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/FrustumCullingManager.cpp

    r925 r2280  
    11#include "FrustumCullingManager.h" 
    2 #include <OgreLogManager.h> 
     2 
    33 
    44namespace GtpVisibility { 
    … …  
    66//----------------------------------------------------------------------- 
    77void FrustumCullingManager::RenderScene() 
    8 { 
     8{        
    99        while (!mHierarchyInterface->GetQueue()->empty()) 
    10         { 
     10        {; 
    1111                HierarchyNode *node = mHierarchyInterface->GetQueue()->top(); 
    1212                mHierarchyInterface->GetQueue()->pop(); 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/GtpVisibility.vcproj

    r2278 r2280  
    189189                <Configuration 
    190190                        Name="Release Internal|Win32" 
    191                         OutputDirectory="$(ConfigurationName)" 
    192                         IntermediateDirectory="$(ConfigurationName)" 
     191                        OutputDirectory="..\lib\Release" 
     192                        IntermediateDirectory="..\obj\Release" 
    193193                        ConfigurationType="4" 
    194194                        CharacterSet="2"> 
    … …  
    204204                                OptimizeForProcessor="3" 
    205205                                OptimizeForWindowsApplication="TRUE" 
    206                                 AdditionalIncludeDirectories="..\include;&quot;$(OGRE_PATH)\OgreMain\include&quot;;..\..\Preprocessing\src" 
    207                                 PreprocessorDefinitions="WIN32;NDEBUG;_LIB" 
     206                                AdditionalIncludeDirectories="..\include" 
     207                                PreprocessorDefinitions="WIN32;NDEBUG;_LIB;GTP_VISIBILITY_MODIFIED_OGRE;GAMETOOLS_ILLUMINATION_MODULE" 
    208208                                RuntimeLibrary="2" 
    209209                                EnableEnhancedInstructionSet="2" 
    … …  
    297297                        </File> 
    298298                        <File 
     299                                RelativePath=".\CullingLogManager.cpp"> 
     300                        </File> 
     301                        <File 
    299302                                RelativePath="..\src\CullingManager.cpp"> 
    300303                        </File> 
    … …  
    338341                        </File> 
    339342                        <File 
     343                                RelativePath="..\include\CullingLogManager.h"> 
     344                        </File> 
     345                        <File 
    340346                                RelativePath="..\include\CullingManager.h"> 
    341347                        </File> 
    … …  
    347353                        </File> 
    348354                        <File 
    349                                 RelativePath="..\include\DummyQueryManager.h"> 
    350                         </File> 
    351                         <File 
    352355                                RelativePath="..\include\FrustumCullingManager.h"> 
    353356                        </File> 
    … …  
    378381                        <File 
    379382                                RelativePath="..\include\VisibilityManager.h"> 
    380                         </File> 
    381                         <File 
    382                                 RelativePath="..\include\VisibilityMesh.h"> 
    383383                        </File> 
    384384                </Filter> 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/PreprocessingManager.cpp

    r316 r2280  
    1111} 
    1212 
    13 bool PreprocessingManager::GetPVS(const Vector3 &center, 
     13/*bool PreprocessingManager::GetPVS(const Vector3 &center, 
    1414                                                                  const float radius, 
    1515                                                                  NodeInfoContainer *visibleNodes, 
    … …  
    2727    } 
    2828    return false; 
    29   } 
    30    
     29} 
     30  */ 
    3131}; 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/QueryManager.cpp

    r174 r2280  
    44namespace GtpVisibility { 
    55  
    6 QueryManager::QueryManager(HierarchyInterface *hierarchyInterface, int queryModes): 
     6/*QueryManager::QueryManager(HierarchyInterface *hierarchyInterface, int queryModes): 
    77mHierarchyInterface(hierarchyInterface), 
    88mQueryModes(queryModes) 
    … …  
    1515    return false; 
    1616} 
    17    
     17*/ 
     18QueryManager::QueryManager(int queryModes): 
     19mQueryModes(queryModes) 
     20{ 
     21} 
     22 
    1823} // namespace GtpVisibility 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/RandomUpdateCullingManager.cpp

    r2278 r2280  
    11#include "RandomUpdateCullingManager.h" 
    2 #include <OgreLogManager.h> 
     2#include <time.h> 
     3#include "CullingLogManager.h" 
     4 
    35 
    46namespace GtpVisibility { 
    … …  
    3133        ///////////// 
    3234        //-- PART 1: process finished occlusion queries 
    33  
     35        CullingLogManager::GetSingleton()->LogMessage("here55"); 
    3436        while (!mHierarchyInterface->GetQueue()->empty() || !queryQueue.empty()) 
    3537        { 
    … …  
    113115                                                Ogre::LogManager::getSingleton().logMessage("g"); 
    114116                                } 
    115  
     117                                 
    116118                                if (mHierarchyInterface->IsNodeFullyVisible(node)) 
    117119                                {Ogre::LogManager::getSingleton().logMessage("here8"); 
    … …  
    183185                        mThreshold = RAND_MAX; 
    184186        } 
    185         //std::stringstream d; d << "*** setting assumed vis: " << mAssumedVisibility; Ogre::LogManager::getSingleton().logMessage(d.str()); 
     187 
    186188} 
    187189//----------------------------------------------------------------------- 
    188190inline bool RandomUpdateCullingManager::DecideVisible(HierarchyNode *node) const 
    189191{ 
    190         //bool result = rand() < mThreshold; std::stringstream d; d << "Assumed vis: " << mAssumedVisibility << ", result: " << result; 
    191         //Ogre::LogManager::getSingleton().logMessage(d.str()); return result; 
    192          
    193192        return rand() < mThreshold; 
    194193} 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/StopAndWaitCullingManager.cpp

    r2171 r2280  
    11#include "StopAndWaitCullingManager.h" 
    2 #include <OgreLogManager.h> 
     2 
    33 
    44namespace GtpVisibility { 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/VisibilityEnvironment.cpp

    r2278 r2280  
    1515VisibilityEnvironment::~VisibilityEnvironment() 
    1616{ 
    17         //GtpVisibilityPreprocessor::Environment::DelSingleton(); 
     17//      GtpVisibilityPreprocessor::Environment::DelSingleton(); 
    1818} 
    1919//----------------------------------------------------------------------- 
    … …  
    2121{                
    2222        //-- parse environment 
    23         return false;//GtpVisibilityPreprocessor::Environment::GetSingleton()->ReadEnvFile(filename.c_str()); 
     23        //return GtpVisibilityPreprocessor::Environment::GetSingleton()->ReadEnvFile(filename.c_str()); 
     24        return false; 
    2425} 
    2526//----------------------------------------------------------------------- 

  • GTP/trunk/Lib/Vis/OnlineCullingCHC/src/VisibilityManager.cpp

    r2278 r2280  
    44#include "FrustumCullingManager.h" 
    55#include "DummyPreprocessingManager.h" 
    6 #include "DummyQueryManager.h" 
    76#include "RandomUpdateCullingManager.h" 
     7#include "CullingLogManager.h" 
     8 
    89 
    910namespace GtpVisibility { 
    … …  
    3334        delete mCullingManager; 
    3435        delete mPreprocessingManager; 
     36        CullingLogManager::DelSingleton(); 
    3537} 
    3638//----------------------------------------------------------------------- 
    … …  
    6567 
    6668                default: 
    67                         mCullingManager = new StopAndWaitCullingManager(); 
     69                        mCullingManager = new CoherentHierarchicalCullingManager(mAssumedVisibilityForChc); 
    6870                        break; 
    6971 
    7072                } 
    7173 
     74                ///////// 
    7275                //-- set threshold 
    73                 mCullingManager->SetVisibilityThreshold(mVisibilityThreshold);           
     76                mCullingManager->SetVisibilityThreshold(mVisibilityThreshold);   
    7477        } 
    7578} 

  • GTP/trunk/Lib/Vis/Preprocessing/EvalStats/EvalStats.vcproj

    r2100 r2280  
    199199                <Configuration 
    200200                        Name="Release Internal|Win32" 
    201                         OutputDirectory="$(ConfigurationName)" 
    202                         IntermediateDirectory="$(ConfigurationName)" 
     201                        OutputDirectory="..\bin\Release" 
     202                        IntermediateDirectory="..\obj\Release" 
    203203                        ConfigurationType="1" 
    204204                        CharacterSet="2"> 

  • GTP/trunk/Lib/Vis/Preprocessing/scripts/gi_final.sh

    r2255 r2280  
    3131 
    3232 
    33 #$PROGRAM $ENVIRONMENT \ 
     33$PROGRAM $ENVIRONMENT \ 
    3434  -scene_filename=$SCENE_FILENAME \ 
    3535  -view_cells_sampling_type=object_directional \ 
    … …  
    4646  -vsp_use_cost_heuristics=$USE_HEUR 
    4747 
    48 #sh movefiles.sh $LOG_PREFIX-$METHOD 
     48sh movefiles.sh $LOG_PREFIX-$METHOD 
     49 
     50####################################################### 
     51 
     52USE_HEUR=true 
     53 METHOD=int-2 
     54 echo "$SCENE $METHOD" 
     55 
     56 
     57$PROGRAM $ENVIRONMENT \ 
     58  -scene_filename=$SCENE_FILENAME \ 
     59  -view_cells_sampling_type=object_directional \ 
     60  -view_cells_evaluation_stats_prefix=$LOG_PREFIX-$METHOD \ 
     61  -view_cells_merge_stats=$LOG_PREFIX-$METHOD-mergeStats.log \ 
     62  -view_cells_filename=$LOG_PREFIX-$METHOD-viewcells.xml.gz \ 
     63  -vsp_subdivision_stats=$LOG_PREFIX-$METHOD-vsp-subdivisionStats.log \ 
     64  -bvh_subdivision_stats=$LOG_PREFIX-$METHOD-bvh-subdivisionStats.log \ 
     65  -hierarchy_subdivision_stats=$LOG_PREFIX-$METHOD-hierarchy-subdivisionStats.log \ 
     66  -hierarchy_construction_type=2 \ 
     67  -hierarchy_construction_min_avg_rays_per_object=1 \ 
     68  -hierarchy_construction_max_avg_rays_per_object=10 \ 
     69  -bvh_use_sah=false \ 
     70  -vsp_use_cost_heuristics=$USE_HEUR 
     71 
     72sh movefiles.sh $LOG_PREFIX-$METHOD 
    4973 
    5074####################################################### 
    … …  
    5882echo "$SCENE $METHOD" 
    5983 
    60 $PROGRAM $ENVIRONMENT \ 
     84#$PROGRAM $ENVIRONMENT \ 
    6185  -scene_filename=$SCENE_FILENAME \ 
    6286  -view_cells_evaluation_stats_prefix=$LOG_PREFIX-$METHOD \ 
    … …  
    7195  -bvh_term_max_leaves=$NODES 
    7296 
    73 sh movefiles.sh $LOG_PREFIX-$METHOD 
     97#sh movefiles.sh $LOG_PREFIX-$METHOD 
    7498 
    7599 
    … …  
    83107echo "$SCENE $METHOD" 
    84108 
    85 $PROGRAM $ENVIRONMENT \ 
     109#$PROGRAM $ENVIRONMENT \ 
    86110  -scene_filename=$SCENE_FILENAME \ 
    87111  -view_cells_evaluation_stats_prefix=$LOG_PREFIX-$METHOD \ 
    … …  
    96120  -bvh_term_max_leaves=$NODES 
    97121 
    98 sh movefiles.sh $LOG_PREFIX-$METHOD 
     122#sh movefiles.sh $LOG_PREFIX-$METHOD 

  • GTP/trunk/Lib/Vis/Preprocessing/src/ViewCellsManager.cpp

    r2258 r2280  
    10301030{ 
    10311031        ObjectContainer preprocessorObjects; 
     1032 
     1033        if (!Debug.is_open()) Debug.open("debug.log"); 
    10321034 
    10331035        return LoadViewCells(filename,  
Note: See TracChangeset for help on using the changeset viewer.