Changeset 2280 for GTP/trunk/Lib/Vis/OnlineCullingCHC/include/QueryManager.h

Timestamp:

03/22/07 18:24:13 (17 years ago)

Author:

mattausch

Message:

removed dependency on ogre in gtpvisibility

File:

• GTP/trunk/Lib/Vis/OnlineCullingCHC/include/QueryManager.h (modified) (3 diffs)

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

@@ -5 +5 @@
 
 #include "VisibilityInfo.h"
-#include "VisibilityVector3.h"
-#include "VisibilityCamera.h"
-#include "VisibilityRay.h"
+//#include "VisibilityCamera.h"
+//#include "VisibilityRay.h"
+
 
 namespace GtpVisibility {
-  
+
+
 typedef std::vector<OcclusionQuery *> QueryList;
 
@@ -25 +26 @@
 public:
     /** Constructor taking a hierarchy interface as an argument. This allows to operate
-        on different hierarchy types, while reusing the implementation of the query methods.
+                on different hierarchy types, while reusing the implementation of the query methods.
      */
-    QueryManager(HierarchyInterface *hierarchyInterface, int queryModes);
-    
-    /** 
-        Computes restricted visibility from point by using an explicit camera to execute
-        the visibility query.
-        @param camera The camera to be used
+    //QueryManager(HierarchyInterface *hierarchyInterface, int queryModes);
+    QueryManager(int queryModes);
 
-        @param visibleNodes Pointer to the container where visible nodes should be added.
-        This set is formed of visible leafs or fully visible interior nodes.
-        If NULL no visible nodes are not evaluated.
+    /** Computes restricted visibility from point by using an explicit camera to execute
+                the visibility query.
+                @param camera The camera to be used
 
-        @param visibleGeometry Pointer to the container where visible meshes should be added.
-        If NULL no visible meshes are not evaluated.
+                @param visibleNodes Pointer to the container where visible nodes should be added.
+                This set is formed of visible leafs or fully visible interior nodes.
+                If NULL no visible nodes are not evaluated.
 
-        @param visiblePatches Pointer to the container where visible patches should be added.
-        If NULL no visible meshes are not evaluated.
+                @param visibleGeometry Pointer to the container where visible meshes should be added.
+                If NULL no visible meshes are not evaluated.
 
-        @param relativeVisibility If true the visibility member for
-        NodeInfo and MeshInfo represent relative visibility; i.e. the number of visible
-        pixels divided by the the number of projected pixels.
+                @param visiblePatches Pointer to the container where visible patches should be added.
+                If NULL no visible meshes are not evaluated.
 
-        @return true if the corresponding PVS exists.
+                @param relativeVisibility If true the visibility member for
+                NodeInfo and MeshInfo represent relative visibility; i.e. the number of visible
+                pixels divided by the the number of projected pixels.
+
+                @return true if the corresponding PVS exists.
     */
-    virtual void
-    ComputeCameraVisibility(const Camera &camera,
-                            NodeInfoContainer *visibleNodes,
-                            MeshInfoContainer *visibleGeometry,
-                                PatchInfoContainer *visiblePatches,
-                            const bool relativeVisibility,
-                                const bool approximateVisibility
-                            ) = 0;
-    
+    /*virtual void ComputeCameraVisibility(const Camera &camera,
+                                                                                 NodeInfoContainer *visibleNodes,
+                                                                                 MeshInfoContainer *visibleGeometry,
+                                                                                 PatchInfoContainer *visiblePatches,
+                                                                                 const bool relativeVisibility,
+                                                                                 const bool approximateVisibility) = 0;
+    */
     /** 
         Uses the specified point to execute the visibility query in all directions. 
         @sa ComputeCameraVisibility()
     */
-    virtual void
+    /*virtual void
     ComputeFromPointVisibility(const Vector3 &point,
-                               NodeInfoContainer *visibleNodes,
-                               MeshInfoContainer *visibleGeometry,
-                                   PatchInfoContainer *visiblePatches,
-                               const bool relativeVisibility,
-                                   const bool approximateVisibility
-                               ) = 0;
-    
+                                                           NodeInfoContainer *visibleNodes,
+                                                           MeshInfoContainer *visibleGeometry,
+                                                           PatchInfoContainer *visiblePatches,
+                                                           const bool relativeVisibility,
+                                                           const bool approximateVisibility) = 0;
+    */
   /** 
       Ray shooting interface: finds an intersection with objects in the scene.
 
       @param ray The given input ray (assuming the ray direction is normalized)
-
       @param visibleMeshes List of meshes intersecting the ray
-
       @param isGlobalLine If false only first intersection with opaque object is returned.
       Otherwise all intersections of the ray with the scene are found.
 
-      @return true if there is any intersection. 
+          @return true if there is any intersection. 
         */
-    virtual bool
-                ShootRay(const Ray &ray,
-             std::vector<Mesh *> *visibleMeshes,
-             bool isGlobalLine = false
-             );
-  
+    /*virtual bool ShootRay(const Ray &ray,
+                                                  std::vector<Mesh *> *visibleMeshes,
+                                                  bool isGlobalLine = false);
+*/
         /** Sets the hierarchy interface.
       @remark the traversal depends on the type of hierarchyInterface the scene consists of.
@@ -101 +95 @@
 protected:
   
-        HierarchyInterface *mHierarchyInterface;
+        //HierarchyInterface *mHierarchyInterface;
         int mQueryModes;  
 };