Changeset 143

Timestamp:

06/21/05 18:14:30 (20 years ago)

Author:

mattausch

Message:

updated visibility queries

Location:

trunk/VUT

Files:

• GtpVisibility/include/DummyQueryManager.h (modified) (2 diffs)
• GtpVisibility/include/QueryManager.h (modified) (3 diffs)
• GtpVisibility/include/VisibilityInfo.h (modified) (4 diffs)
• GtpVisibility/src/DummyQueryManager.cpp (modified) (2 diffs)
• Ogre/include/OgrePlatformQueryManager.h (modified) (3 diffs)
• Ogre/src/OgrePlatformQueryManager.cpp (modified) (9 diffs)
• work/TestCullingTerrain/TerrainFrameListener.cpp (modified) (5 diffs)
• work/TestCullingTerrain/TerrainFrameListener.h (modified) (1 diff)

trunk/VUT/GtpVisibility/include/DummyQueryManager.h

@@ -25 +25 @@
                             InfoContainer<NodeInfo> *visibleNodes,
                             InfoContainer<MeshInfo> *visibleGeometry,
-                            bool relativeVisibility = false
+                            bool projectedPixels = false
                             );
     
@@ -35 +35 @@
                                InfoContainer<NodeInfo> *visibleNodes,
                                InfoContainer<MeshInfo> *visibleGeometry,
-                               bool relativeVisibility = false
+                               bool projectedPixels = false
                                );
     

trunk/VUT/GtpVisibility/include/QueryManager.h

@@ -41 +41 @@
         If NULL no visible meshes are not evaluated.
 
-        @param relativeVisibility If true the visibility member for
+        @param projectedPixels 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.
@@ -51 +51 @@
                             InfoContainer<NodeInfo> *visibleNodes,
                             InfoContainer<MeshInfo> *visibleGeometry,
-                            bool relativeVisibility = false
+                            bool projectedPixels = false
                             ) = 0;
     
@@ -62 +62 @@
                                InfoContainer<NodeInfo> *visibleNodes,
                                InfoContainer<MeshInfo> *visibleGeometry,
-                               bool relativeVisibility = false
+                               bool projectedPixels = false
                                ) = 0;
     

trunk/VUT/GtpVisibility/include/VisibilityInfo.h

@@ -14 +14 @@
 {
 public:
-    NodeInfo(HierarchyNode *node,const float v): mNode(node), mVisibility(v) {}
+    NodeInfo(HierarchyNode *node, const int projectedPixels, const int visiblePixels): 
+        mNode(node)//, mProjectedPixels(projectedPixels), mVisiblePixels(visiblePixels) 
+        {}
 
-        float GetVisibility() const {return mVisibility;}
-        void SetVisibility(float vis) { mVisibility = vis;}
-        bool operator<(const NodeInfo& rhs) const {return mNode < rhs.mNode;}
-        //bool operator>(const NodeInfo& rhs) const {return mNode > rhs.mNode;}
-        //bool operator==(const NodeInfo& rhs) const {return mNode == rhs.mNode;}
+        int GetVisiblePixels() const {return mVisiblePixels;}
+        int GetProjectedPixels() const {return mProjectedPixels;}
+
+        void SetVisiblePixels(int vis) {mVisiblePixels = vis;}
+        void SetProjectedPixels(int vis) {mProjectedPixels = vis;}
+
+        void SetNode(HierarchyNode *node) {mNode = node;}
+        HierarchyNode *GetNode() const {return mNode;}
+
+        //bool operator<(const NodeInfo& rhs) const {return mNode < rhs.mNode;}
 
 protected:
@@ -26 +33 @@
     /** pointer to the scene node */
     HierarchyNode *mNode;
-    /** node visibility can either be a number of visible pixels or relative
-        number of visible pixels (if the hardware queries will provide the
-        total number of ratsterized pixels */
-    float mVisibility;
+    
+    int mVisiblePixels;
+        int mProjectedPixels;
 };
   
@@ -37 +43 @@
 {
 public:
-        MeshInfo(Mesh *mesh, const float v): mMesh(mesh), mVisibility(v) {}
+        MeshInfo(Mesh *mesh,  const int projectedPixels, const int visiblePixels): 
+        mMesh(mesh), mProjectedPixels(projectedPixels), mVisiblePixels(visiblePixels) 
+        {}
 
-        float GetVisibility() const {return mVisibility;}
-        void SetVisibility(float vis) { mVisibility = vis;}
+        int GetVisiblePixels() const {return mVisiblePixels;}
+        int GetProjectedPixels() const {return mProjectedPixels;}
+
+        void SetVisiblePixels(float vis) { mVisiblePixels = vis;}
+        void SetProjectedPixels(float vis) { mProjectedPixels = vis;}
+
+        Mesh *GetMesh() const {return mMesh;}
+        void SetMesh(Mesh *mesh) {mMesh = mesh;}
 
         bool operator<(const MeshInfo& rhs) const {return mMesh < rhs.mMesh;}
@@ -51 +65 @@
         */
     Mesh *mMesh;
-    /** Node visibility can either be a number of visible pixels or relative
-        number of visible pixels (if the hardware queries will provide the
-        total number of ratsterized pixels.
-        */
-    float mVisibility;
+  
+    int mVisiblePixels;
+        int mProjectedPixels;
 };
   
 //TODO: this define shall be replaced by template typedef
-//#define InfoContainer std::vector
-#define InfoContainer std::set
+#define InfoContainer std::vector
+//#define InfoContainer std::set
 };
 

trunk/VUT/GtpVisibility/src/DummyQueryManager.cpp

@@ -11 +11 @@
                                              InfoContainer<NodeInfo> *visibleNodes,
                                              InfoContainer<MeshInfo> *visibleGeometry,
-                                             bool relativeVisibility
+                                             bool projectedPixels
                                              )
   {
-          visibleNodes->insert(NodeInfo(mHierarchyInterface->GetSceneRoot(), 1.0f));
+          visibleNodes->push_back(NodeInfo(mHierarchyInterface->GetSceneRoot(), 0, 0));
     
 //      HierarchyInterface::MeshIterator *mi =
@@ -30 +30 @@
                                                 InfoContainer<NodeInfo> *visibleNodes,
                                                 InfoContainer<MeshInfo> *visibleGeometry,
-                                                bool relativeVisibility
+                                                bool projectedPixels
                                                 )
   {
-          visibleNodes->insert(NodeInfo(mHierarchyInterface->GetSceneRoot(), 1.0f));
+          visibleNodes->push_back(NodeInfo(mHierarchyInterface->GetSceneRoot(), 0, 0));
     
 //      HierarchyInterface::MeshIterator *mi =

trunk/VUT/Ogre/include/OgrePlatformQueryManager.h

@@ -31 +31 @@
         If NULL no visible meshes are not evaluated.
 
-        @param relativeVisibility If true the visibility member for
+        @param projectedPixels 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.
@@ -41 +41 @@
                             InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
                             InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,
-                            bool relativeVisibility = false
+                            bool projectedPixels = false
                             );
     
@@ -52 +52 @@
                                InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,
-                               bool relativeVisibility = false
+                               bool projectedPixels = false
                                );
     

trunk/VUT/Ogre/src/OgrePlatformQueryManager.cpp

@@ -23 +23 @@
                             InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
                             InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,
-                            bool relativeVisibility)
+                            bool projectedPixels)
 {
         // we need access to the scene manager and the rendersystem
@@ -68 +68 @@
         */
         // for relative visibility we need 2 rendering passes
-        int n = relativeVisibility ? 2 : 1;
+        int n = projectedPixels ? 2 : 1;
         
         for (int i=0; i<n; ++i)
@@ -118 +118 @@
                 (*visQueryIt)->GetQueryResult(visiblePixels, true);
         
-                float vis = (float)visiblePixels;
-                bool isVisible = visiblePixels > 0;
-
-                if (relativeVisibility)
+                int visiblePixels = visiblePixels;
+                int projectedPixels = 0;
+
+                if (projectedPixels)
                 {
                         (*projQueryIt)->GetQueryResult(visiblePixels, true);
         
-                        if (visiblePixels > 0)
-                        {                               
-                                vis /= (float) visiblePixels;
-                        }
+                        mProjectedPixels = visiblePixels;
+                
                         ++projQueryIt;
                 }
@@ -136 +134 @@
                 // nodes with visibilty 0 in queue: 
                 // happens if node is intersected by near plane
-                if (isVisible)
-                {
-                        insertNode = visibleNodes->insert(GtpVisibility::NodeInfo(*nodeIt, vis));
-
-                        if (!insertNode.second) // element already in list
-                        {
-                                //LogManager::getSingleton().logMessage("element already in list");
-                (*insertNode.first).SetVisibility((*insertNode.first).GetVisibility() + vis);
-
-                                if (relativeVisibility) // relative visibility between zero and one
-                                {
-                                        (*insertNode.first).SetVisibility((*insertNode.first).GetVisibility() * 0.5);
-                                }
-                        }
+                if (visiblePixels > 0)
+                {
+                        visibleNodes->push_back(GtpVisibility::NodeInfo(*nodeIt, visiblePixels, projectedPixels));
                 }
         }
@@ -160 +147 @@
                 (*visQueryIt)->GetQueryResult(visiblePixels, true);
                 
-
-                float vis = (float)visiblePixels;
-                bool isVisible = visiblePixels > 0;
-                
-                if (relativeVisibility)
+                int visiblePixels = visiblePixels;
+                int projectedPixels = 0;
+
+                if (projectedPixels)
                 {
                         (*projQueryIt)->GetQueryResult(visiblePixels, true);
 
-                        if (visiblePixels)
-                        {
-                                vis /= (float) visiblePixels;
-                        }
+                        mProjectedPixels = visiblePixels;
+
                         ++projQueryIt;
                 }
@@ -181 +165 @@
                 if (isVisible)
                 {                        
-                        insertGeom = visibleGeometry->insert(GtpVisibility::MeshInfo(*geometryIt, vis));
-                        if (!insertGeom.second) // element already in list
-                        {
-                                //LogManager::getSingleton().logMessage("element already in list");
-                (*insertGeom.first).SetVisibility((*insertGeom.first).GetVisibility() + vis);
-
-                                if (relativeVisibility) // relative visibility between zero and one
-                                {
-                                        (*insertGeom.first).SetVisibility((*insertGeom.first).GetVisibility() * 0.5);
-                                }
-                        }
-                }
-        }
-
+                        visibleGeometry->push_back(GtpVisibility::MeshInfo(*geometryIt,visiblePixels, projectedPixels));
+                }
+        }
+
+}
+//-----------------------------------------------------------------------
+inline bool nodeinfo_eq(const GtpVisibility::NodeInfo &info1, const GtpVisibility::NodeInfo &info2) 
+{ 
+        return info1.GetNode() == info2.GetNode(); 
+}
+//-----------------------------------------------------------------------
+inline bool meshinfo_eq(const GtpVisibility::MeshInfo &info1, const GtpVisibility::MeshInfo &info2) 
+{ 
+        return info1.GetMesh() == info2.GetMesh(); 
 }
 //-----------------------------------------------------------------------
@@ -200 +184 @@
                                InfoContainer<GtpVisibility::NodeInfo> *visibleNodes,
                                InfoContainer<GtpVisibility::MeshInfo> *visibleGeometry,
-                               bool relativeVisibility)
+                               bool projectedPixels)
 {
         SceneManager *sm = dynamic_cast<PlatformHierarchyInterface *>(mHierarchyInterface)->GetSceneManager();
@@ -237 +221 @@
                 LogManager::getSingleton().logMessage(d.str());
 
-                ComputeCameraVisibility(*cam, visibleNodes, visibleGeometry, relativeVisibility);
-                           
+                ComputeCameraVisibility(*cam, visibleNodes, visibleGeometry, projectedPixels);
+                
                 //mViewport->getTarget()->update(); for(int j=0; j<10000000; j++)       printf("HAAHHAHAHAHAH");
 
@@ -248 +232 @@
         }
         
-
         // reset camera
         mViewport->setCamera(savedCam);
+
+        // --- single out duplicates
+
+        // before duplicates can be deleted we have to add up visibility
+
+        // --- visible nodes
+        sort(visibleNodes->begin(), visibleNodes->end());
+        InfoContainer<GtpVisibility::NodeInfo>::iterator visibleNodesIt,
+                visibleNodesIt_end = visibleNodes->end();
+        
+        GtpVisibility::NodeInfo *nodeInfo = NULL;
+
+        for (visibleNodesIt = visibleNodes->begin(); visibleNodesIt != visibleNodesIt_end; 
+                ++visibleNodesIt);
+        {
+                if (!nodeInfo || (nodeInfo->GetNode() != (*visibleNodesIt).GetNode()))
+                {
+                        nodeInfo = &(*visibleNodesIt);
+                }
+                else
+                {
+                        // add visibility
+                        nodeInfo->SetVisibility(nodeInfo->GetVisiblePixels() + 
+                                (*visibleNodesIt).GetVisiblePixels());
+                }
+
+        }
+        
+        // now delete duplicates
+        visibleNodes->erase( std::unique(visibleNodes->begin(), 
+                visibleNodes->end(), nodeinfo_eq), visibleNodes->end());
+
+        // --- visible geometry
+        sort(visibleGeometry->begin(), visibleGeometry->end());
+        InfoContainer<GtpVisibility::MeshInfo>::iterator visibleGeomIt,
+                visibleGeomIt_end = visibleGeometry->end();
+
+        GtpVisibility::MeshInfo *geomInfo = NULL;
+
+        for (visibleGeomIt = visibleGeometry->begin(); visibleGeomIt != visibleGeomIt_end; 
+                ++visibleGeomIt);
+        {
+                if (!geomInfo || (geomInfo->GetMesh() != (*visibleGeomIt).GetMesh()))
+                {
+                        geomInfo = &(*visibleGeomIt);
+                }
+                else // info points to equal mesh
+                {
+                        // add visibility
+                        geomInfo->SetVisibility(geomInfo->GetVisiblePixels() + 
+                                (*visibleGeomIt).GetVisiblePixels());
+                }
+        }
+
+        // now delete duplicates
+        visibleGeometry->erase(std::unique(visibleGeometry->begin(), 
+                visibleGeometry->end(), meshinfo_eq), visibleGeometry->end());
+        
 }
 //-----------------------------------------------------------------------

trunk/VUT/work/TestCullingTerrain/TerrainFrameListener.cpp

@@ -353 +353 @@
 }
 //-----------------------------------------------------------------------
-void TerrainFrameListener::ApplyVisibilityQuery(bool fromPoint, bool relativeVisibility)
+void TerrainFrameListener::ApplyVisibilityQuery(bool fromPoint, bool projectedPixels)
 {
         InfoContainer<GtpVisibility::NodeInfo> visibleNodes;
@@ -362 +362 @@
                 mVisibilityManager->GetQueryManager()->
                         ComputeFromPointVisibility(mCamNode->getPosition(), &visibleNodes, 
-                                                                           &visibleGeometry, relativeVisibility);
+                                                                           &visibleGeometry, projectedPixels);
         }
         else
         {
                 mVisibilityManager->GetQueryManager()->ComputeCameraVisibility(*mCamera,
-                            &visibleNodes, &visibleGeometry, relativeVisibility);
+                            &visibleNodes, &visibleGeometry, projectedPixels);
         }
 
@@ -377 +377 @@
         for (geomIt = visibleGeometry.begin(); geomIt != geomIt_end; ++geomIt)
         {
-                averageGeometryVis += (*geomIt).GetVisibility();
-
-                std::stringstream d; d << "Geometry visibility: " << (*geomIt).GetVisibility();
+                averageGeometryVis += (*geomIt).GetVisiblePixels();
+
+                std::stringstream d; d << "Geometry visibility: " << (*geomIt).GetVisiblePixels();
                 LogManager::getSingleton().logMessage(d.str());
         }
@@ -387 +387 @@
         for (nodesIt = visibleNodes.begin(); nodesIt != nodesIt_end; ++nodesIt)
         {
-                averageNodeVis += (*nodesIt).GetVisibility();
-
-                std::stringstream d; d << "Node visibility: " << (*nodesIt).GetVisibility();
+                averageNodeVis += (*nodesIt).GetVisiblePixels();
+
+                std::stringstream d; d << "Node visibility: " << (*nodesIt).GetVisiblePixels();
                 LogManager::getSingleton().logMessage(d.str());
         }
@@ -405 +405 @@
                 //-- visibility queries stats
                 int idx = fromPoint ?  1 : 0;
-                idx += relativeVisibility ? 2 : 0;
+                idx += projectedPixels ? 2 : 0;
 
                 sprintf(str, ": %s", queryTypeCaptions[idx].c_str()); 

trunk/VUT/work/TestCullingTerrain/TerrainFrameListener.h

@@ -117 +117 @@
                 and their visibility information.
                 @param fromnPoint if query should be from point or from camera
-                @param relativeVisibility if query should return number of visible pixels or the ratio
+                @param projectedPixels if query should return number of visible pixels or the ratio
                 visible pixels / projected pixels.
         */
-        void ApplyVisibilityQuery(bool fromPoint, bool relativeVisibility);
+        void ApplyVisibilityQuery(bool fromPoint, bool projectedPixels);
 
         void toggleShowQueryStats();