Changeset 316


Ignore:
Timestamp:
10/10/05 15:23:32 (19 years ago)
Author:
mattausch
Message:

queries are realized as templates

Location:
trunk/VUT
Files:
1 deleted
34 edited

Legend:

Unmodified
Added
Removed

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

    r87 r316  
    1717        a greater distance has a lower priority in the queue. 
    1818*/ 
    19 template <typename T> class GreaterDistance 
     19template <typename T> class GtDistance 
    2020{ 
    2121public: 
    22         GreaterDistance(HierarchyInterface *hierarchyInterface): mHierarchyInterface(hierarchyInterface) 
     22        GtDistance(HierarchyInterface *hierarchyInterface): mHierarchyInterface(hierarchyInterface) 
    2323        {} 
    2424         
    … …  
    3434/** A priority queue where closer hierarchy nodes are given a higher priority. 
    3535*/ 
    36 typedef std::priority_queue<HierarchyNode *, std::vector<HierarchyNode *>, GreaterDistance<std::vector<HierarchyNode *>::value_type> > DistanceQueue; 
     36typedef std::priority_queue<HierarchyNode *, std::vector<HierarchyNode *>, GtDistance<std::vector<HierarchyNode *>::value_type> > DistanceQueue; 
    3737 
    3838} // namespace GtpVisibility 

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

    r65 r316  
    5252  */ 
    5353  virtual int AddViewCellPVS(const int cellID, 
    54                              InfoContainer<NodeInfo> *visibleNodes, 
    55                              InfoContainer<MeshInfo> *visibleMeshes ); 
     54                             NodeInfoContainer *visibleNodes, 
     55                             MeshInfoContainer *visibleMeshes); 
    5656 
    5757}; 

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

    r174 r316  
    2323    virtual void 
    2424    ComputeCameraVisibility(const Camera &camera, 
    25                             InfoContainer<NodeInfo> *visibleNodes, 
    26                             InfoContainer<MeshInfo> *visibleGeometry, 
    27                                 InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     25                            NodeInfoContainer *visibleNodes, 
     26                            MeshInfoContainer *visibleGeometry, 
     27                                PatchInfoContainer *visiblePatches, 
    2828                            bool relativeVisibility = false ); 
    2929     
    … …  
    3333    virtual void 
    3434    ComputeFromPointVisibility(const Vector3 &point, 
    35                                InfoContainer<NodeInfo> *visibleNodes, 
    36                                InfoContainer<MeshInfo> *visibleGeometry, 
    37                                         InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     35                               NodeInfoContainer *visibleNodes, 
     36                               MeshInfoContainer *visibleGeometry, 
     37                                   PatchInfoContainer *visiblePatches, 
    3838                               bool relativeVisibility = false 
    3939                               ); 

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

    r113 r316  
    8282    virtual bool GetPVS(const Vector3 &point, 
    8383                        const float radius, 
    84                         InfoContainer<NodeInfo> *visibleNodes, 
    85                         InfoContainer<MeshInfo> *visibleMeshes ); 
     84                        NodeInfoContainer *visibleNodes, 
     85                        MeshInfoContainer *visibleMeshes); 
    8686     
    8787     
    … …  
    125125    */ 
    126126    virtual int AddViewCellPVS(const int cellID, 
    127                                InfoContainer<NodeInfo> *visibleNodes, 
    128                                InfoContainer<MeshInfo> *visibleMeshes ) = 0; 
     127                                                           NodeInfoContainer *visibleNodes, 
     128                                                           MeshInfoContainer *visibleMeshes ) = 0; 
    129129     
    130130    HierarchyInterface *mSceneTraverser; 

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

    r174 r316  
    4949    virtual void 
    5050    ComputeCameraVisibility(const Camera &camera, 
    51                             InfoContainer<NodeInfo> *visibleNodes, 
    52                             InfoContainer<MeshInfo> *visibleGeometry, 
    53                                 InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     51                            NodeInfoContainer *visibleNodes, 
     52                            MeshInfoContainer *visibleGeometry, 
     53                                PatchInfoContainer *visiblePatches, 
    5454                            bool relativeVisibility = false 
    5555                            ) = 0; 
    … …  
    6161    virtual void 
    6262    ComputeFromPointVisibility(const Vector3 &point, 
    63                                InfoContainer<NodeInfo> *visibleNodes, 
    64                                InfoContainer<MeshInfo> *visibleGeometry, 
    65                                    InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     63                               NodeInfoContainer *visibleNodes, 
     64                               MeshInfoContainer *visibleGeometry, 
     65                                   PatchInfoContainer *visiblePatches, 
    6666                               bool relativeVisibility = false 
    6767                               ) = 0; 

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

    r159 r316  
    88 
    99namespace GtpVisibility { 
    10    
     10  
    1111/** Class storing visibility information. 
    1212*/ 
     13template<typename T> 
    1314class VisibilityInfo 
    1415{ 
    1516public: 
    16         VisibilityInfo(const int visiblePixels, const int projectedPixels); 
     17        VisibilityInfo(T source, const int visiblePixels, const int projectedPixels); 
     18 
     19        /** set source of the info.  
     20        */ 
     21        void SetSource(T source); 
     22        /** get source of the info.  
     23        */ 
     24        T GetSource() const; 
    1725 
    1826        int GetVisiblePixels() const; 
    … …  
    2735        /** Adds visibility to current visibility information. 
    2836        */ 
    29         void AddVisibility(const VisibilityInfo &info); 
     37        void AddVisibility(const VisibilityInfo<T> &info); 
    3038        /** Adds visibility to current visibility information. 
    3139        */ 
    32         void AddVisibility(const int visiblePixels, const int vrojectedPixels); 
     40        void AddVisibility(const int visiblePixels, const int projectedPixels); 
    3341 
    3442protected: 
    … …  
    3947        */ 
    4048        int mProjectedPixels; 
    41 }; 
    42 /** Class storing the visibility information of a hierarchy node.  
    43 */ 
    44 class NodeInfo: public VisibilityInfo 
    45 { 
    46 public: 
    47     NodeInfo(HierarchyNode *node, const int visiblePixels, const int projectedPixels); 
    4849 
    49         void SetNode(HierarchyNode *node); 
    50         HierarchyNode *GetNode() const; 
    51         //bool operator<(const NodeInfo& rhs) const {return mNode < rhs.mNode;} 
    52  
    53 protected: 
    54  
    55     /** Pointer to the hierarchy nnode. 
    56         */ 
    57     HierarchyNode *mNode; 
    58 }; 
    59    
    60 /** Class storing the visibility information of a mesh. 
    61 */ 
    62 class MeshInfo: public VisibilityInfo 
    63 { 
    64 public: 
    65         MeshInfo(Mesh *mesh, const int visiblePixels, const int projectedPixels); 
    66  
    67         Mesh *GetMesh() const; 
    68         void SetMesh(Mesh *mesh); 
    69  
    70         //bool operator<(const MeshInfo& rhs) const {return mMesh < rhs.mMesh;} 
    71         //bool operator==(const MeshInfo& rhs) const {return mMesh == rhs.mMesh;} 
    72          
    73 protected: 
    74  
    75     /** Pointer to the mesh. 
    76         */ 
    77     Mesh *mMesh; 
     50        T mSource; 
    7851}; 
    7952 
    80 /** Class storing the visibility information of a patch, i.e., parts of meshes having the same material 
    81         properties. 
    82 */ 
    83 class PatchInfo: public VisibilityInfo 
     53//----------------------------------------------------------------------- 
     54template <typename T> 
     55T VisibilityInfo<T>::GetSource() const 
    8456{ 
    85 public: 
    86         PatchInfo(Patch *Patch, const int visiblePixels, const int projectedPixels); 
     57        return mSource; 
     58} 
    8759 
    88         Patch *GetPatch() const; 
    89         void SetPatch(Patch *patch); 
    90          
    91 protected: 
     60//----------------------------------------------------------------------- 
     61template <typename T> 
     62void VisibilityInfo<T>::SetSource(T source) 
     63{ 
     64        return mSource; 
     65} 
    9266 
    93     /** Pointer to the patch. 
    94         */ 
    95     Patch *mPatch; 
     67//----------------------------------------------------------------------- 
     68template <typename T> 
     69VisibilityInfo<T>::VisibilityInfo(T source, const int visiblePixels, const int projectedPixels):  
     70mSource(source), mProjectedPixels(projectedPixels), mVisiblePixels(visiblePixels)  
     71{ 
     72} 
     73 
     74//----------------------------------------------------------------------- 
     75template <typename T> 
     76int VisibilityInfo<T>::GetVisiblePixels() const  
     77{ 
     78        return mVisiblePixels; 
     79} 
     80//----------------------------------------------------------------------- 
     81template <typename T> 
     82int VisibilityInfo<T>::GetProjectedPixels() const  
     83{ 
     84        return mProjectedPixels; 
     85} 
     86//----------------------------------------------------------------------- 
     87template <typename T> 
     88void VisibilityInfo<T>::SetVisiblePixels(int vis)  
     89{ 
     90        mVisiblePixels = vis; 
     91} 
     92//----------------------------------------------------------------------- 
     93template <typename T> 
     94void VisibilityInfo<T>::SetProjectedPixels(int vis)  
     95{ 
     96        mProjectedPixels = vis; 
     97} 
     98//----------------------------------------------------------------------- 
     99template <typename T> 
     100float VisibilityInfo<T>::ComputeRelativeVisibility()  
     101{  
     102        if (!mProjectedPixels)  
     103                return 0; 
     104 
     105        return (float)mVisiblePixels / (float)mProjectedPixels;  
     106} 
     107//----------------------------------------------------------------------- 
     108template <typename T> 
     109void VisibilityInfo<T>::AddVisibility(const VisibilityInfo<T> &info) 
     110{ 
     111        mVisiblePixels += info.GetVisiblePixels(); 
     112        mProjectedPixels += info.GetProjectedPixels(); 
     113} 
     114 
     115//----------------------------------------------------------------------- 
     116template <typename T> 
     117void VisibilityInfo<T>::AddVisibility(const int visiblePixels, const int projectedPixels) 
     118{ 
     119        mVisiblePixels += visiblePixels; 
     120        mProjectedPixels += projectedPixels; 
     121} 
     122 
     123typedef VisibilityInfo<Patch *> PatchInfo; 
     124typedef VisibilityInfo<Mesh *> MeshInfo; 
     125typedef VisibilityInfo<HierarchyNode *> NodeInfo; 
     126 
     127 
     128template<class T> 
     129struct InfoContainer 
     130{ 
     131        typedef std::vector<VisibilityInfo<T> > Type; 
    96132}; 
    97133 
    98 //TODO: this define shall be replaced by template typedef 
    99 #define InfoContainer std::vector 
    100 //#define InfoContainer std::set 
    101 }; 
     134typedef std::vector<PatchInfo> PatchInfoContainer; 
     135typedef std::vector<MeshInfo> MeshInfoContainer; 
     136typedef std::vector<NodeInfo> NodeInfoContainer; 
    102137 
     138} // namespace GtpVisibility 
    103139 
    104140#endif 

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

    r144 r316  
    112112                        </File> 
    113113                        <File 
    114                                 RelativePath="..\src\DummyQueryManager.cpp"> 
    115                         </File> 
    116                         <File 
    117114                                RelativePath="..\src\FrustumCullingManager.cpp"> 
    118115                        </File> 
    … …  
    133130                        </File> 
    134131                        <File 
    135                                 RelativePath="..\src\VisibilityInfo.cpp"> 
    136                         </File> 
    137                         <File 
    138132                                RelativePath="..\src\VisibilityManager.cpp"> 
    139133                        </File> 
    … …  
    151145                        <File 
    152146                                RelativePath="..\include\DistanceQueue.h"> 
     147                        </File> 
     148                        <File 
     149                                RelativePath="..\include\DummyPreprocessingManager.h"> 
    153150                        </File> 
    154151                        <File 

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

    r74 r316  
    4040*/ 
    4141int DummyPreprocessingManager::AddViewCellPVS(const int cellID, 
    42                                           InfoContainer<NodeInfo> *visibleNodes, 
    43                                           InfoContainer<MeshInfo> *visibleMeshes ) 
     42                                          NodeInfoContainer *visibleNodes, 
     43                                          MeshInfoContainer *visibleMeshes ) 
    4444{ 
    4545  // return the root of the hierarchyInterface regardless of the cellId 

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

    r159 r316  
    99  void 
    1010  DummyQueryManager::ComputeCameraVisibility(const Camera &camera, 
    11                                              InfoContainer<NodeInfo> *visibleNodes, 
    12                                              InfoContainer<MeshInfo> *visibleGeometry, 
    13                                                  InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     11                                             NodeInfoContainer *visibleNodes, 
     12                                             MeshInfoContainer *visibleGeometry, 
     13                                                 PatchInfoContainer *visiblePatches, 
    1414                                             bool relativeVisibility) 
    1515  { 
    16           visibleNodes->push_back(NodeInfo(mHierarchyInterface->GetHierarchyRoot(), 0, 0)); 
     16          visibleNodes->Type.push_back(NodeInfo(mHierarchyInterface->GetHierarchyRoot(), 0, 0)); 
    1717     
    1818//      HierarchyInterface::MeshIterator *mi = 
    … …  
    2828  void 
    2929  DummyQueryManager::ComputeFromPointVisibility(const Vector3 &point, 
    30                                                 InfoContainer<NodeInfo> *visibleNodes, 
    31                                                 InfoContainer<MeshInfo> *visibleGeometry, 
    32                                                 InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     30                                                NodeInfoContainer *visibleNodes, 
     31                                                MeshInfoContainer *visibleGeometry, 
     32                                                PatchInfoContainer *visiblePatches, 
    3333                                                bool relativeVisibility) 
    3434  { 
    35           visibleNodes->push_back(NodeInfo(mHierarchyInterface->GetHierarchyRoot(), 0, 0)); 
     35          visibleNodes->Type.push_back(NodeInfo(mHierarchyInterface->GetHierarchyRoot(), 0, 0)); 
    3636     
    3737//      HierarchyInterface::MeshIterator *mi = 

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

    r174 r316  
    1010mSavedNode(NULL), mCurrentTestIdx(0), mTestGeometryForVisibleLeaves(false) 
    1111{        
    12         mDistanceQueue = new DistanceQueue(GreaterDistance<HierarchyNode *>(this)); 
     12        mDistanceQueue = new DistanceQueue(GtDistance<HierarchyNode *>(this)); 
    1313} 
    1414//----------------------------------------------------------------------- 

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

    r71 r316  
    1313bool PreprocessingManager::GetPVS(const Vector3 &center, 
    1414                                                                  const float radius, 
    15                                                                   InfoContainer<NodeInfo> *visibleNodes, 
    16                                                                   InfoContainer<MeshInfo> *visibleMeshes) 
     15                                                                  NodeInfoContainer *visibleNodes, 
     16                                                                  MeshInfoContainer *visibleMeshes) 
    1717{ 
    1818    vector<int> viewCellIds; 

  • trunk/VUT/GtpVisibilityPreprocessor/src/SamplingPreprocessor.cpp

    r315 r316  
    465465                           exporter->ExportViewCell(vc); 
    466466 
    467                            Debug << "pvs size: " << (int)vc->GetPvs().GetSize() << " of " << objects.size(); 
     467                           Debug << "pvs size: " << (int)vc->GetPvs().GetSize() << " of " << (int)objects.size(); 
    468468                           Debug << " exporting rays: " << (int)vcRays[j].size() << endl; 
    469469 

  • trunk/VUT/GtpVisibilityPreprocessor/src/X3dExporter.cpp

    r313 r316  
    689689                        else 
    690690                        { 
    691                                 Debug << "polygon not valid: " << *planePoly << " size: " << planePoly->mVertices.size() << endl; 
     691                                Debug << "polygon not valid: " << *planePoly << " size: " << (int)planePoly->mVertices.size() << endl; 
    692692                                DEL_PTR(planePoly); 
    693693                        } 

  • trunk/VUT/GtpVisibilityPreprocessor/src/default.env

    r311 r316  
    99#       filename vienna.x3d 
    1010#       filename ../data/vienna/vienna-simple.x3d 
    11         filename ../data/vienna/vienna-buildings.x3d 
     11#       filename ../data/vienna/vienna-buildings.x3d 
    1212#       filename ../data/vienna/viewcells-25-sel.x3d 
    13 #       filename ../data/atlanta/atlanta2.x3d 
     13        filename ../data/atlanta/atlanta2.x3d 
    1414#       filename ../data/soda/soda.dat 
    1515#       filename ../data/soda/soda5.dat 
    … …  
    5656 
    5757Sampling { 
    58         totalSamples    1000000 
    59         samplesPerPass  5 
     58        totalSamples    200000 
     59        samplesPerPass  10 
    6060} 
    6161 
    6262ViewCells { 
    6363        hierarchyType bspTree 
     64        height 7.0 
     65        maxViewCells 20 
    6466        #hierarchyType kdTree 
    6567        #hierarchyType sceneDependent 
    66 #       filename ../data/atlanta/atlanta_viewcells_large.x3d 
    67 #       filename ../data/atlanta/atlanta_viewcells_large2.x3d 
    68         filename ../data/vienna/viewcells-25-sel.x3d 
     68        filename ../data/atlanta/atlanta_viewcells_large.x3d 
     69#       filename ../data/vienna/viewcells-25-sel.x3d 
    6970#       filename ../data/vienna/viewcells-25.x3d 
    7071#       filename ../data/vienna/viewcells-large-sel.x3d 
    … …  
    101102         
    102103        maxCandidates 50 
    103         maxViewCells 999999 
     104         
    104105        Termination { 
    105106                maxPolysForAxisAligned 100 

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

    r174 r316  
    1919     
    2020    void ComputeCameraVisibility(const Camera &camera, 
    21                             InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
    22                             InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    23                                 InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     21                            GtpVisibility::NodeInfoContainer *visibleNodes, 
     22                            GtpVisibility::MeshInfoContainer *visibleGeometry, 
     23                                GtpVisibility::PatchInfoContainer *visiblePatches, 
    2424                            bool relativeVisibility = false); 
    2525     
    … …  
    2929    */ 
    3030    void ComputeFromPointVisibility(const Vector3 &point, 
    31                                InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
    32                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    33                                    InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     31                               GtpVisibility::NodeInfoContainer *visibleNodes, 
     32                               GtpVisibility::MeshInfoContainer *visibleGeometry, 
     33                                   GtpVisibility::PatchInfoContainer *visiblePatches, 
    3434                               bool relativeVisibility = false); 
    3535     
    … …  
    4040                                                                   GtpVisibility::QueryList::iterator &projQueryIt, 
    4141                                                                   GtpVisibility::GeometryList *geometryList,  
    42                                                                    InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
     42                                                                   GtpVisibility::MeshInfoContainer *visibleGeometry, 
    4343                                                                   bool relativeVisibility); 
    4444 
    … …  
    4646                                                           GtpVisibility::QueryList::iterator &projQueryIt, 
    4747                                                           GtpVisibility::HierarchyNodeList *nodeList,  
    48                                                            InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
     48                                                           GtpVisibility::NodeInfoContainer *visibleNodes, 
    4949                                                           bool relativeVisibility); 
    5050 
    5151        void CollectRelativeGeometryVisibilityForItemBuffer(GtpVisibility::QueryList::iterator &projQueryIt, 
    5252                                                                                                GtpVisibility::GeometryList *geometryList,  
    53                                                                                                 InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry); 
     53                                                                                                GtpVisibility::MeshInfoContainer *visibleGeometry); 
    5454 
    5555        void CollectRelativePatchVisibilityForItemBuffer( 
    5656                                                                        GtpVisibility::QueryList::iterator &projQueryIt, 
    5757                                                                        GtpVisibility::PatchList *patchList,  
    58                                                                         InfoContainer<GtpVisibility::PatchInfo> *visiblePatches); 
     58                                                                        GtpVisibility::PatchInfoContainer *visiblePatches); 
    5959 
    6060        void CollectPatchVisibility(GtpVisibility::QueryList::iterator &visQueryIt,  
    6161                                                                GtpVisibility::QueryList::iterator &projQueryIt, 
    6262                                                                GtpVisibility::PatchList *patchList,  
    63                                                                 InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     63                                                                GtpVisibility::PatchInfoContainer *visiblePatches, 
    6464                                                                bool relativeVisibility); 
    6565 
    66         void RemoveDuplicateNodes(InfoContainer<GtpVisibility::NodeInfo> *visibleNodes); 
    67         void RemoveDuplicateGeometry(InfoContainer<GtpVisibility::MeshInfo> *visibleMesh); 
    68         void RemoveDuplicatePatches(InfoContainer<GtpVisibility::PatchInfo> *visiblePatches); 
     66        void RemoveDuplicateNodes(GtpVisibility::NodeInfoContainer *visibleNodes); 
     67        void RemoveDuplicateGeometry(GtpVisibility::MeshInfoContainer *visibleMesh); 
     68        void RemoveDuplicatePatches(GtpVisibility::PatchInfoContainer *visiblePatches); 
    6969 
    7070        /** Returns the patches of the geometry of a given node.  

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

    r174 r316  
    2525    */ 
    2626    void ComputeFromPointVisibility(const Vector3 &point, 
    27                                InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
    28                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    29                                    InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     27                               GtpVisibility::NodeInfoContainer *visibleNodes, 
     28                               GtpVisibility::MeshInfoContainer *visibleGeometry, 
     29                                   GtpVisibility::PatchInfoContainer *visiblePatches, 
    3030                               bool relativeVisibility = false); 
    3131   
    3232        void ComputeCameraVisibility(const Camera &camera, 
    33                                InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
    34                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    35                                    InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     33                               GtpVisibility::NodeInfoContainer *visibleNodes, 
     34                               GtpVisibility::MeshInfoContainer *visibleGeometry, 
     35                                   GtpVisibility::PatchInfoContainer *visiblePatches, 
    3636                               bool relativeVisibility = false); 
    3737   
    … …  
    4545 
    4646        void CollectItemBufferResults( 
    47                                 InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    48                                 InfoContainer<GtpVisibility::PatchInfo> *visiblePatches); 
     47                                GtpVisibility::MeshInfoContainer *visibleGeometry, 
     48                                GtpVisibility::PatchInfoContainer *visiblePatches); 
    4949 
    50         void InitItemBuffer(InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    51                                                 InfoContainer<GtpVisibility::PatchInfo> *visiblePatches); 
     50        void InitItemBuffer(GtpVisibility::MeshInfoContainer *visibleGeometry, 
     51                                                GtpVisibility::PatchInfoContainer *visiblePatches); 
    5252 
    5353        Viewport *mViewport; 

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

    r171 r316  
    150150                                Filter=""> 
    151151                                <File 
    152                                         RelativePath="..\include\OgreBspHierarchyInterface.h"> 
    153                                 </File> 
    154                                 <File 
    155152                                        RelativePath="..\include\OgreOctreeHierarchyInterface.h"> 
    156153                                </File> 
    … …  
    191188                                Name="Header Files" 
    192189                                Filter="h;hpp;hxx;hm;inl;inc"> 
     190                                <File 
     191                                        RelativePath="..\include\OgreBspHierarchyInterface.h"> 
     192                                </File> 
    193193                                <File 
    194194                                        RelativePath="..\include\OgreOcclusionQueriesQueryManager.h"> 

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

    r175 r316  
    88namespace Ogre { 
    99 
    10 /** 
    11    These functions necessary to enable sorting of node / mesh / patch info. 
    12 */ 
    13 //----------------------------------------------------------------------- 
    14 inline bool nodeinfo_eq(const GtpVisibility::NodeInfo &info1, const GtpVisibility::NodeInfo &info2)  
    15 {  
    16         return info1.GetNode() == info2.GetNode();  
    17 } 
    18 //----------------------------------------------------------------------- 
    19 inline bool meshinfo_eq(const GtpVisibility::MeshInfo &info1, const GtpVisibility::MeshInfo &info2)  
    20 {  
    21         return info1.GetMesh() == info2.GetMesh();  
    22 } 
    23 //----------------------------------------------------------------------- 
    24 inline bool patchinfo_eq(const GtpVisibility::PatchInfo &info1, const GtpVisibility::PatchInfo &info2)  
    25 {  
    26         return info1.GetPatch() == info2.GetPatch();  
    27 } 
    28 //----------------------------------------------------------------------- 
    29 inline bool nodeinfo_lower(const GtpVisibility::NodeInfo &info1, const GtpVisibility::NodeInfo &info2)  
    30 {  
    31         return info1.GetNode() < info2.GetNode();  
    32 } 
    33 //----------------------------------------------------------------------- 
    34 inline bool meshinfo_lower(const GtpVisibility::MeshInfo &info1, const GtpVisibility::MeshInfo &info2)  
    35 {  
    36         return info1.GetMesh() < info2.GetMesh();  
    37 } 
    38 //----------------------------------------------------------------------- 
    39 inline bool patchinfo_lower(const GtpVisibility::PatchInfo &info1, const GtpVisibility::PatchInfo &info2)  
    40 {  
    41         return info1.GetPatch() < info2.GetPatch();  
    42 } 
    43  
     10//----------------------------------------------------------------------- 
     11bool nodeinfo_eq(const GtpVisibility::NodeInfo &a, const GtpVisibility::NodeInfo &b) 
     12{ 
     13        return a.GetSource() == b.GetSource(); 
     14}  
     15bool nodeinfo_lt(const GtpVisibility::NodeInfo &a, const GtpVisibility::NodeInfo &b) 
     16{ 
     17        return a.GetSource() < b.GetSource(); 
     18} 
     19bool meshinfo_eq(const GtpVisibility::MeshInfo &a, const GtpVisibility::MeshInfo &b) 
     20{ 
     21        return a.GetSource() == b.GetSource(); 
     22}  
     23bool meshinfo_lt(const GtpVisibility::MeshInfo &a, const GtpVisibility::MeshInfo &b) 
     24{        
     25        return a.GetSource() < b.GetSource(); 
     26} 
     27bool patchinfo_eq(const GtpVisibility::PatchInfo &a, const GtpVisibility::PatchInfo &b) 
     28{ 
     29        return a.GetSource() == b.GetSource(); 
     30}  
     31bool patchinfo_lt(const GtpVisibility::PatchInfo &a, const GtpVisibility::PatchInfo &b) 
     32{ 
     33        return a.GetSource() < b.GetSource(); 
     34} 
    4435 
    4536//-----------------------------------------------------------------------  
    … …  
    5546//----------------------------------------------------------------------- 
    5647void OcclusionQueriesQueryManager::ComputeCameraVisibility(const Camera &camera, 
    57                             InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
    58                             InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    59                                 InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     48                            GtpVisibility::NodeInfoContainer *visibleNodes, 
     49                            GtpVisibility::MeshInfoContainer *visibleGeometry, 
     50                                GtpVisibility::PatchInfoContainer *visiblePatches, 
    6051                            bool relativeVisibility) 
    6152{ 
    … …  
    238229//----------------------------------------------------------------------- 
    239230void OcclusionQueriesQueryManager::ComputeFromPointVisibility(const Vector3 &point, 
    240                                InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
    241                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    242                                    InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     231                               GtpVisibility::NodeInfoContainer *visibleNodes, 
     232                               GtpVisibility::MeshInfoContainer *visibleGeometry, 
     233                                   GtpVisibility::PatchInfoContainer *visiblePatches, 
    243234                               bool relativeVisibility) 
    244235{ 
    … …  
    265256                                                GtpVisibility::QueryList::iterator &projQueryIt, 
    266257                                                GtpVisibility::HierarchyNodeList *nodeList,   
    267                                                 InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
     258                                                GtpVisibility::NodeInfoContainer *visibleNodes, 
    268259                                                bool relativeVisibility) 
    269260{ 
    … …  
    299290                                                                        GtpVisibility::QueryList::iterator &projQueryIt, 
    300291                                                                        GtpVisibility::GeometryList *geometryList,  
    301                                                                         InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry) 
     292                                                                        GtpVisibility::MeshInfoContainer *visibleGeometry) 
    302293{ 
    303294        GtpVisibility::GeometryList::iterator geometryIt; 
    … …  
    323314                                                                        GtpVisibility::QueryList::iterator &projQueryIt, 
    324315                                                                        GtpVisibility::PatchList *patchList,  
    325                                                                         InfoContainer<GtpVisibility::PatchInfo> *visiblePatches) 
     316                                                                        GtpVisibility::PatchInfoContainer *visiblePatches) 
    326317{ 
    327318        GtpVisibility::PatchList::iterator patchIt; 
    … …  
    348339                                                        GtpVisibility::QueryList::iterator &projQueryIt, 
    349340                                                        GtpVisibility::GeometryList *geometryList,  
    350                                                         InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
     341                                                        GtpVisibility::MeshInfoContainer *visibleGeometry, 
    351342                                                        bool relativeVisibility) 
    352343{ 
    … …  
    383374                                                        GtpVisibility::QueryList::iterator &projQueryIt, 
    384375                                                        GtpVisibility::PatchList *patchList,  
    385                                                         InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     376                                                        GtpVisibility::PatchInfoContainer *visiblePatches, 
    386377                                                        bool relativeVisibility) 
    387378{ 
    … …  
    415406//----------------------------------------------------------------------- 
    416407void  OcclusionQueriesQueryManager::RemoveDuplicateNodes( 
    417                                         InfoContainer<GtpVisibility::NodeInfo> *visibleNodes) 
    418 { 
    419         sort(visibleNodes->begin(), visibleNodes->end(), nodeinfo_lower); 
    420         InfoContainer<GtpVisibility::NodeInfo>::iterator visibleNodesIt, 
     408                                        GtpVisibility::NodeInfoContainer *visibleNodes) 
     409{ 
     410        sort(visibleNodes->begin(), visibleNodes->end(), nodeinfo_lt); 
     411 
     412        GtpVisibility::NodeInfoContainer::iterator visibleNodesIt, 
    421413                visibleNodesIt_end = visibleNodes->end(); 
    422414         
    … …  
    426418                ++visibleNodesIt) 
    427419        { 
    428                 if (!nodeInfo || (nodeInfo->GetNode() != (*visibleNodesIt).GetNode())) 
     420                if (!nodeInfo || (nodeInfo->GetSource() != (*visibleNodesIt).GetSource())) 
    429421                { 
    430422                        nodeInfo = &(*visibleNodesIt); 
    … …  
    437429         
    438430        // physically delete duplicates 
    439         visibleNodes->erase( std::unique(visibleNodes->begin(),  
    440                 visibleNodes->end(), nodeinfo_eq), visibleNodes->end()); 
     431        visibleNodes->erase(std::unique(visibleNodes->begin(), visibleNodes->end(), nodeinfo_eq), 
     432                                                visibleNodes->end()); 
    441433} 
    442434//----------------------------------------------------------------------- 
    443435void  OcclusionQueriesQueryManager::RemoveDuplicateGeometry( 
    444                                 InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry) 
    445 { 
    446         sort(visibleGeometry->begin(), visibleGeometry->end(), meshinfo_lower); 
    447          
    448         InfoContainer<GtpVisibility::MeshInfo>::iterator visibleGeomIt, 
     436                                GtpVisibility::MeshInfoContainer *visibleGeometry) 
     437{ 
     438        sort(visibleGeometry->begin(), visibleGeometry->end(), meshinfo_lt); 
     439         
     440        GtpVisibility::MeshInfoContainer::iterator visibleGeomIt, 
    449441                        visibleGeomIt_end = visibleGeometry->end(); 
    450442 
    … …  
    454446                ++visibleGeomIt) 
    455447        { 
    456                 if (!geomInfo || (geomInfo->GetMesh() != (*visibleGeomIt).GetMesh())) 
     448                if (!geomInfo || (geomInfo->GetSource() != (*visibleGeomIt).GetSource())) 
    457449                { 
    458450                        geomInfo = &(*visibleGeomIt); 
    … …  
    465457 
    466458        // physically delete duplicates 
    467         visibleGeometry->erase(std::unique(visibleGeometry->begin(), visibleGeometry->end(),  
    468                 meshinfo_eq), visibleGeometry->end()); 
     459        visibleGeometry->erase(std::unique(visibleGeometry->begin(), visibleGeometry->end(), meshinfo_eq),  
     460                                                  visibleGeometry->end()); 
    469461} 
    470462//----------------------------------------------------------------------- 
    471463void  OcclusionQueriesQueryManager::RemoveDuplicatePatches( 
    472                                 InfoContainer<GtpVisibility::PatchInfo> *visiblePatches) 
    473 { 
    474         sort(visiblePatches->begin(), visiblePatches->end(), patchinfo_lower); 
    475          
    476         InfoContainer<GtpVisibility::PatchInfo>::iterator visiblePatchIt, 
     464                                GtpVisibility::PatchInfoContainer *visiblePatches) 
     465{ 
     466        sort(visiblePatches->begin(), visiblePatches->end(), patchinfo_lt); 
     467         
     468        GtpVisibility::PatchInfoContainer::iterator visiblePatchIt, 
    477469                        visiblePatchIt_end = visiblePatches->end(); 
    478470 
    … …  
    482474                ++visiblePatchIt) 
    483475        { 
    484                 if (!patchInfo || (patchInfo->GetPatch() != (*visiblePatchIt).GetPatch())) 
     476                if (!patchInfo || (patchInfo->GetSource() != (*visiblePatchIt).GetSource())) 
    485477                { 
    486478                        patchInfo = &(*visiblePatchIt); 
    … …  
    493485 
    494486        // physically delete duplicates 
    495         visiblePatches->erase(std::unique(visiblePatches->begin(), visiblePatches->end(),  
    496                 patchinfo_eq), visiblePatches->end()); 
     487        visiblePatches->erase(std::unique(visiblePatches->begin(), visiblePatches->end(), patchinfo_eq),  
     488                                                  visiblePatches->end()); 
    497489} 
    498490//----------------------------------------------------------------------- 

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

    r187 r316  
    8787         
    8888        mRenderSystem->_setWorldMatrix(Ogre::Matrix4::IDENTITY); 
    89         mSceneManager->useRenderableViewProjMode(solidBox); 
     89        mSceneManager->useRenderableViewProjModeWrapper(solidBox); 
    9090         
    9191        // set no depth write, no color, no lighting material 
    92         mSceneManager->setPass(solidBox->getTechnique()->getPass(0)); 
     92        mSceneManager->setPassWrapper(solidBox->getTechnique()->getPass(0)); // HACK! (mySetPass should be setPass) 
    9393        //SetOcclusionPass(); 
    9494 

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

    r174 r316  
    2626//----------------------------------------------------------------------- 
    2727void PlatformQueryManager::ComputeFromPointVisibility(const Vector3 &point, 
    28                                InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
    29                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    30                                    InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     28                               GtpVisibility::NodeInfoContainer *visibleNodes, 
     29                               GtpVisibility::MeshInfoContainer *visibleGeometry, 
     30                                   GtpVisibility::PatchInfoContainer *visiblePatches, 
    3131                               bool relativeVisibility) 
    3232{ 
    … …  
    8686//----------------------------------------------------------------------- 
    8787void PlatformQueryManager::ComputeCameraVisibility(const Camera &camera, 
    88                             InfoContainer<GtpVisibility::NodeInfo> *visibleNodes, 
    89                             InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    90                                 InfoContainer<GtpVisibility::PatchInfo> *visiblePatches, 
     88                            GtpVisibility::NodeInfoContainer *visibleNodes, 
     89                            GtpVisibility::MeshInfoContainer *visibleGeometry, 
     90                                GtpVisibility::PatchInfoContainer *visiblePatches, 
    9191                            bool relativeVisibility) 
    9292{ 
    … …  
    137137//----------------------------------------------------------------------- 
    138138void PlatformQueryManager::CollectItemBufferResults( 
    139                                 InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    140                                 InfoContainer<GtpVisibility::PatchInfo> *visiblePatches) 
     139                                GtpVisibility::MeshInfoContainer *visibleGeometry, 
     140                                GtpVisibility::PatchInfoContainer *visiblePatches) 
    141141{ 
    142142        int dimx = 0; 
    … …  
    180180//----------------------------------------------------------------------- 
    181181void PlatformQueryManager::InitItemBuffer( 
    182                                 InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry, 
    183                                 InfoContainer<GtpVisibility::PatchInfo> *visiblePatches) 
     182                                GtpVisibility::MeshInfoContainer *visibleGeometry, 
     183                                GtpVisibility::PatchInfoContainer *visiblePatches) 
    184184{ 
    185185        if (mWasInitialised) 

  • trunk/VUT/work/README_ONLINE.txt

    r227 r316  
    2424   RenderSystem_Direct7 
    2525   OgreMain 
    26    example projects 
     26   GuiRenderer 
     27    
     28   Also add the flag to the example projects you want to use 
    2729 
    28305) Add following resources to OGRE_PATH\Samples\Common\bin\Release\resource.cfg: 

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

    r259 r316  
    450450        sm->GetVisibilityManager()->SetQueryManager(mQueryManager); 
    451451 
    452         InfoContainer<GtpVisibility::NodeInfo> visibleNodes; 
    453         InfoContainer<GtpVisibility::MeshInfo> visibleGeometry; 
    454         InfoContainer<GtpVisibility::PatchInfo> visiblePatches; 
     452        GtpVisibility::NodeInfoContainer visibleNodes; 
     453        GtpVisibility::MeshInfoContainer visibleGeometry; 
     454        GtpVisibility::PatchInfoContainer visiblePatches; 
    455455 
    456456 
    … …  
    478478        int geomSize = 0, nodesSize = 0, patchSize = 0; 
    479479 
    480         InfoContainer<GtpVisibility::MeshInfo>::iterator geomIt, geomIt_end = visibleGeometry.end(); 
     480        GtpVisibility::MeshInfoContainer::iterator geomIt, geomIt_end = visibleGeometry.end(); 
    481481 
    482482        for (geomIt = visibleGeometry.begin(); geomIt != geomIt_end; ++geomIt) 
    … …  
    492492                         
    493493                        std::stringstream d;  
    494                         d << "Geometry " << geomSize << " id: " << (*geomIt).GetMesh()->getSubEntity(0)->getId()  
     494                        d << "Geometry " << geomSize << " id: " << (*geomIt).GetSource()->getSubEntity(0)->getId()  
    495495                          << " visibility: "  << (*geomIt).GetVisiblePixels() << ", " << (*geomIt).GetProjectedPixels(); 
    496496                        LogManager::getSingleton().logMessage(d.str()); 
    … …  
    498498        } 
    499499 
    500         InfoContainer<GtpVisibility::NodeInfo>::iterator nodesIt, nodesIt_end = visibleNodes.end(); 
     500        GtpVisibility::NodeInfoContainer::iterator nodesIt, nodesIt_end = visibleNodes.end(); 
    501501 
    502502        for (nodesIt = visibleNodes.begin(); nodesIt != nodesIt_end; ++nodesIt) 
    … …  
    516516        } 
    517517 
    518         InfoContainer<GtpVisibility::PatchInfo>::iterator patchIt, patchIt_end = visiblePatches.end(); 
     518        GtpVisibility::PatchInfoContainer::iterator patchIt, patchIt_end = visiblePatches.end(); 
    519519 
    520520        for (patchIt = visiblePatches.begin(); patchIt != patchIt_end; ++ patchIt) 

  • trunk/VUT/work/iv/IVFrameListener.cpp

    r259 r316  
    436436                  << "worst frame time: " << mWindow->getWorstFrameTime() << "\n" 
    437437                  << "avg. #triangles: " << avgTris << " M\n" 
    438                   << "#frames: " << mFrameCount < "\n"; 
     438                  << "#frames: " << mFrameCount << "\n"; 
    439439 
    440440                LogManager::getSingleton().logMessage(d.str()); 

  • trunk/VUT/work/ogre_changes/OgreMain/include/OgreRenderSystem.h

    r193 r316  
    947947        virtual Real getMaximumDepthInputValue(void) = 0; 
    948948 
    949 #ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    950                 /** sets colour. 
    951                 */ 
    952                 void setColour(int r, int g, int b, int a); 
    953 #endif // GTP_VISIBILITY_MODIFIED_OGRE 
    954  
    955949    protected: 
    956950 
    … …  
    990984 
    991985        bool mInvertVertexWinding; 
    992  
    993 #ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    994                 int mColour[4]; 
    995 #endif // GTP_VISIBILITY_MODIFIED_OGRE 
    996986    }; 
    997987} 

  • trunk/VUT/work/ogre_changes/OgreMain/include/OgreSceneManager.h

    r183 r316  
    136136                */ 
    137137                void _deleteRenderedQueueGroups(int leavePassesInQueue = 0); 
    138                 /** Internal method used by _renderVisibleObjects to deal with renderables 
     138                /** Wrapper for useRenderableViewProjMde with is an  
     139                        Internal method used by _renderVisibleObjects to deal with renderables 
    139140            which override the camera's own view / projection materices.  
    140                         @remark made public by matt  
    141                 */ 
    142         void useRenderableViewProjMode(Renderable* pRend); 
    143                 /** Method for setting up the renderstate for a rendering pass. 
     141                */ 
     142        void useRenderableViewProjModeWrapper(Renderable* pRend); // HACK 
     143                /** HACK: A public wrapper method for setting up the renderstate for a rendering pass. 
    144144            @param 
    145145                pass The Pass details to set. 
    … …  
    149149                        @remark made public by matt 
    150150        */ 
    151         virtual Pass* setPass(Pass* pass); 
     151        virtual Pass* setPassWrapper(Pass* pass); 
    152152 
    153153                /** Renders an Ogre Entity. 
    … …  
    273273        /** Retrieves the internal render queue. */ 
    274274        virtual RenderQueue* getRenderQueue(void); 
    275 #ifndef GTP_VISIBILITY_MODIFIED_OGRE // made public, is found in the modfified section 
     275 
    276276        /** Internal method for setting up the renderstate for a rendering pass. 
    277277            @param 
    … …  
    282282        */ 
    283283        virtual Pass* setPass(Pass* pass); 
    284 #endif 
     284 
    285285        /// A pass designed to let us render shadow colour on white for texture shadows 
    286286        Pass* mShadowCasterPlainBlackPass; 
    … …  
    357357        AnimationList mAnimationsList; 
    358358        AnimationStateSet mAnimationStates; 
    359 #ifndef GTP_VISIBILITY_MODIFIED_OGRE // made public, is found in the modfified section 
     359 
    360360        /** Internal method used by _renderVisibleObjects to deal with renderables 
    361361            which override the camera's own view / projection materices. */ 
    362362        void useRenderableViewProjMode(Renderable* pRend); 
    363 #endif 
     363 
    364364        /// Controller flag for determining if we need to set view/proj matrices 
    365365        bool mCamChanged; 

  • trunk/VUT/work/ogre_changes/OgreMain/src/OgreRenderSystem.cpp

    r150 r316  
    6363        // instanciate RenderSystemCapabilities 
    6464        mCapabilities = new RenderSystemCapabilities(); 
    65  
    66 #ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    67                 mColour[0] = mColour[1] = mColour[2] = mColour[3] = 255; 
    68 #endif // GTP_VISIBILITY_MODIFIED_OGRE 
    6965    } 
    7066 
    … …  
    420416        } 
    421417    } 
    422 #ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    423         // ------------------------------------------------------------------ 
    424         void RenderSystem::setColour(int r, int g, int b, int a) 
    425         { 
    426                 mColour[0] = r; 
    427                 mColour[1] = g; 
    428                 mColour[2] = b; 
    429                 mColour[3] = a; 
    430         } 
    431 #endif //  GTP_VISIBILITY_MODIFIED_OGRE 
    432418} 
    433419 

  • trunk/VUT/work/ogre_changes/OgreMain/src/OgreSceneManager.cpp

    r193 r316  
    42004200#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    42014201//----------------------------------------------------------------------- 
     4202Pass* SceneManager::setPassWrapper(Pass* pass) 
     4203{ 
     4204        return setPass(pass); 
     4205} 
     4206//----------------------------------------------------------------------- 
    42024207void SceneManager::_renderSceneNode(Camera *cam, SceneNode *node, const int leavePassesInQueue) 
    42034208{ 
    … …  
    42594264        renderSingleObject(rend, pass, false); 
    42604265} 
     4266//----------------------------------------------------------------------- 
     4267void SceneManager::useRenderableViewProjModeWrapper(Renderable* pRend) 
     4268{ 
     4269        useRenderableViewProjMode(pRend); 
     4270} 
    42614271#endif //GTP_VISIBILITY_MODIFIED_OGRE 
    42624272} 

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

    r193 r316  
    208208        int mDepth; 
    209209         
    210  
    211210#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    212211}; 

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

    r193 r316  
    261261 
    262262#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    263         /* the number of nodes in the octree. do not confuse this with the OctreeNode 
    264         class with is derived from SceneNode. 
     263        /** The number of nodes in the octree. 
     264                @remark counts the octree hierarchy nodes in the tree. 
    265265        */ 
    266         int mNumOctreeNodes; 
     266        int mNumOctants; 
    267267#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    268268 

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

    r193 r316  
    4949 
    5050#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    51 #define MAX_RENDERLEVEL_INDEX 15 
     51#define MAX_RENDERLEVEL_INDEX 15 // maximal different number of render levels, e.g., used for chc 
    5252#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    5353 

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

    r193 r316  
    108108        else 
    109109                mDepth = 0; 
    110  
     110        // update bounds because we want tight octree 
    111111        _updateBounds(); 
     112         
    112113#endif //GTP_VISIBILITY_MODIFIED_OGRE 
    113114    mNumNodes = 0; 
    … …  
    133134 
    134135    mParent = 0; 
     136 
    135137} 
    136138 

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

    r158 r316  
    318318 
    319319#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    320         mNumOctreeNodes = 1; // count number of octants 
     320        mNumOctants = 1; // initialise number of octants in tree 
    321321#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    322322 
    … …  
    470470            octant -> mChildren[ x ][ y ][ z ] = new Octree( octant ); 
    471471#ifdef GTP_VISIBILITY_MODIFIED_OGRE 
    472         ++ mNumOctreeNodes; 
     472                        ++ mNumOctants; 
    473473#endif // GTP_VISIBILITY_MODIFIED_OGRE 
    474474 

  • trunk/VUT/work/ogre_changes/RenderSystems/GL/src/OgreGLRenderSystem.cpp

    r193 r316  
    23282328            glDisableVertexAttribArrayARB_ptr(1); // disable weights 
    23292329        } 
    2330 #ifndef GTP_VISIBILITY_MODIFIED_OGRE 
    2331         glColor4f(1,1,1,1); 
    2332 #else 
    2333                 glColor4ub(mColour[0], mColour[1], mColour[2], mColour[3]); 
    2334 #endif  // GTP_VISIBILITY_MODIFIED_OGRE 
    23352330 
    23362331        glSecondaryColor3fEXT_ptr(0.0f, 0.0f, 0.0f); 
Note: See TracChangeset for help on using the changeset viewer.