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

added visibility queries

Location:
trunk/VUT/GtpVisibility
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • trunk/VUT/GtpVisibility/include/CoherentHierarchicalCullingManager.h

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

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

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

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

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

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

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

    r119 r130  
    4848 
    4949                        if (!mHierarchyInterface->CheckFrustumVisible(node, intersects)) 
    50                         {//if (mHierarchyInterface->mIsShadowPass) 
     50                        { 
    5151                                mNumFrustumCulledNodes ++; 
    5252                                 
  • trunk/VUT/GtpVisibility/src/HierarchyInterface.cpp

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

    r71 r130  
    55  
    66QueryManager::QueryManager(HierarchyInterface *hierarchyInterface) 
     7:mHierarchyInterface(hierarchyInterface) 
    78{ 
    89} 
  • trunk/VUT/GtpVisibility/src/VisibilityManager.cpp

    r114 r130  
    8383        return mCullingManagerType; 
    8484} 
    85  
     85//----------------------------------------------------------------------- 
     86void VisibilityManager::SetQueryManager(QueryManager *queryManager) 
     87{ 
     88        mQueryManager = queryManager; 
     89} 
     90//----------------------------------------------------------------------- 
     91QueryManager *VisibilityManager::GetQueryManager() 
     92{ 
     93        return mQueryManager; 
     94} 
    8695} // namespace GtpVisibility 
Note: See TracChangeset for help on using the changeset viewer.