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

queries are realized as templates

Location:
trunk/VUT/GtpVisibility
Files:
1 deleted
11 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; 
Note: See TracChangeset for help on using the changeset viewer.