Changeset 1616 for GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include

Timestamp:

10/13/06 03:28:42 (18 years ago)

Author:

mattausch

Message:

some shit happen

Location:

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include

Files:

• OgreBoundingBoxConverter.h (modified) (7 diffs)
• OgreOcclusionCullingSceneManager.h (modified) (1 diff)

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreBoundingBoxConverter.h

@@ -7 +7 @@
 #include "BoundingBoxConverter.h"
 #include "Containers.h"
+#include "IntersectableWrapper.h"
+//#include "KdTree.h"
+
 
 namespace Ogre {
 
+#define USE_KD_PVS 1
 class Entity;
 class OctreeSceneManager;
@@ -15 +19 @@
 class BvHierarchySceneManager;
 
+typedef vector<Entity *> EntityContainer;
+
+class ObjectsIntersectable: public GtpVisibilityPreprocessor::IntersectableWrapper<EntityContainer *>
+{
+public:
+        ObjectsIntersectable(EntityContainer *item):
+        GtpVisibilityPreprocessor::IntersectableWrapper<EntityContainer *>(item) {}
+
+        // hack
+        ObjectsIntersectable::~ObjectsIntersectable() 
+        {
+                //CLEAR_CONTAINER(*mItem);
+                delete mItem;
+        }
+
+        int Type() const
+        {
+                return Intersectable::OBJECTS_INTERSECTABLE;
+        }
+};
 
 /**     Class which converts preprocessor types to OGRE types
@@ -42 +66 @@
         }
         
+        /** find object which fits best to this bounding box
+        */
         Entity *FindBestFittingObject(const AxisAlignedBox &box) const;
+        
+        /** find objects which are intersected by this box
+        */
+        void FindIntersectingObjects(const AxisAlignedBox &box,
+                                                                 vector<Entity *> &objects) const;
 
         T *mSceneMgr;
@@ -74 +105 @@
         list<SceneNode *>::const_iterator sit, sit_end = sceneNodeList.end();
         // find the bbox which is closest to the current bbox
+        for (sit = sceneNodeList.begin(); sit != sceneNodeList.end(); ++ sit)
+        {
+                SceneNode *sn = *sit;
+                SceneNode::ObjectIterator oit = sn->getAttachedObjectIterator();
+
+        while (oit.hasMoreElements())
+                {
+                        MovableObject *mo = oit.getNext();
+
+                        // we are only interested in scene entities
+                        if (mo->getMovableType() != "Entity")
+                        {
+                                continue;
+                        }
+                         mo->
+                        const AxisAlignedBox bbox = EnlargeBox(mo->getWorldBoundingBox());
+                                        
+                        // compute measure how much aabbs overlap
+                        overlap = RatioOfOverlap(OgreTypeConverter::ConvertFromOgre(mybox),
+                                                                         OgreTypeConverter::ConvertFromOgre(bbox));
+        
+                         if (overlap > bestFit)
+                         {
+                                 bestFit = overlap;
+                                 bestFittingObj = static_cast<Entity *>(mo);
+
+                                 // perfect fit => object found, early exit
+                                 if (overlap >= thresh)
+                                 {
+                                         return bestFittingObj; 
+                                 }
+                         }
+                }
+        }
+
+        if (0)
+        {
+                std::stringstream d; 
+                if (bestFittingObj)
+                        d << "best fit: " << bestFit;     
+                else
+                        d << "warning, no best fitting object\n" << box;
+        
+                Ogre::LogManager::getSingleton().logMessage(d.str());
+        }
+
+        return bestFittingObj;
+}
+//-----------------------------------------------------------------------
+template<typename T>
+void PlatFormBoundingBoxConverter<T>::FindIntersectingObjects(const AxisAlignedBox &box,
+                                                                                                                          EntityContainer &objects) const
+{
+        list<SceneNode *> sceneNodeList;
+                        
+        // get intersecting scene nodes (= candidates)
+        //AxisAlignedBox mybox = EnlargeBox(box);
+        //mSceneMgr->findNodesIn(mybox, sceneNodeList, NULL);
+        mSceneMgr->findNodesIn(box, sceneNodeList, NULL);
+
+        list<SceneNode *>::const_iterator sit, sit_end = sceneNodeList.end();
+
+        //GtpVisibilityPreprocessor::AxisAlignedBox nodeBox = OgreTypeConverter::ConvertFromOgre(mybox);
+        GtpVisibilityPreprocessor::AxisAlignedBox3 nodeBox = OgreTypeConverter::ConvertFromOgre(box);
+
+        // find really intersecting objects
         for (sit = sceneNodeList.begin(); sit != sceneNodeList.end(); ++ sit)
         {
@@ -89 +186 @@
                         }
                          
-                        const AxisAlignedBox bbox = EnlargeBox(mo->getWorldBoundingBox());
-                                        
-                        // compute measure how much aabbs overlap
-                        overlap = RatioOfOverlap(OgreTypeConverter::ConvertFromOgre(mybox),
-                                                                         OgreTypeConverter::ConvertFromOgre(bbox));
-        
-                         if (overlap > bestFit)
+                        //const AxisAlignedBox bbox = EnlargeBox(mo->getWorldBoundingBox());
+                        const AxisAlignedBox bbox = mo->getWorldBoundingBox();
+
+                        const bool overlaps = Overlap(nodeBox,
+                                                                                  OgreTypeConverter::ConvertFromOgre(bbox)
+                                                                                  );
+                                                                                  //,0.00001);
+        
+                         if (overlaps)
                          {
-                                 bestFit = overlap;
-                                 bestFittingObj = static_cast<Entity *>(mo);
-
-                                 // perfect fit => object found, early exit
-                                 if (overlap >= thresh)
-                                 {
-                                         return bestFittingObj; 
-                                 }
+                                 objects.push_back(static_cast<Entity *>(mo));
                          }
                 }
         }
-
-        if (0)
-        {
-                std::stringstream d; 
-                if (bestFittingObj)
-                        d << "best fit: " << bestFit;     
-                else
-                        d << "warning, no best fitting object\n" << box;
-        
-                Ogre::LogManager::getSingleton().logMessage(d.str());
-        }
-
-        return bestFittingObj;
-}
+}
+
+#if USE_KD_PVS
+//-------------------------------------------------------------------------
+template<typename T>
+bool PlatFormBoundingBoxConverter<T>::IdentifyObjects(
+        const GtpVisibilityPreprocessor::IndexedBoundingBoxContainer &iboxes,
+        GtpVisibilityPreprocessor::ObjectContainer &objects) const
+{
+        Ogre::LogManager().logMessage("pvs: intersecting objects");
+        const long startTime = GtpVisibilityPreprocessor::GetTime();
+
+        GtpVisibilityPreprocessor::IndexedBoundingBoxContainer::
+                const_iterator iit, iit_end = iboxes.end();
+  
+        int i = 0;
+
+        for (iit = iboxes.begin(); iit != iit_end; ++ iit, ++ i)
+        {
+                if ((i % 1000) == 0)
+                {
+                        std::stringstream d; d << "found " << i << " objects";
+                        Ogre::LogManager().getSingleton().logMessage(d.str());
+                }
+
+                const AxisAlignedBox box = OgreTypeConverter::ConvertToOgre((*iit).second);
+                
+                //GtpVisibilityPreprocessor::ObjectContainer *entryObjects = new EntityContainer();
+                EntityContainer *entryObjects = new EntityContainer();
+
+                // find all objects that intersect the bounding box
+                FindIntersectingObjects(box, *entryObjects);
+
+                /*vector<Entity *>::const_iterator mit, mit_end = sceneObjects.end();
+                
+                for (mit = sceneObjects.begin(); mit != mit_end; ++ mit)
+                {
+                        Entity *ent = *mit;
+                        // create new mesh instance
+                        OgreMeshInstance *omi = new OgreGetOrCreateOgreMeshInstance(ent);
+                        //omi->SetId((*iit).first);
+                        entryObjects->push_back(omi);
+                }*/
+
+                ObjectsIntersectable *entry = 
+                        new ObjectsIntersectable(entryObjects);
+                entry->SetId((*iit).first);
+                //kdObj->mBbox = (*iit).second;
+                objects.push_back(entry);
+        }
+
+        std::stringstream d; d << "finished object intersection in " << GtpVisibilityPreprocessor::TimeDiff(startTime, GtpVisibilityPreprocessor::GetTime()) * 1e-3 << "secs";
+        Ogre::LogManager().logMessage(d.str());
+
+        return true;
+}
+#else
 //-------------------------------------------------------------------------
 template<typename T>
@@ -138 +273 @@
                 Entity *ent = FindBestFittingObject(currentBox);
 
-                // create new mesh instance
                 if (ent)
                 {
+                        // create new mesh instance
                         OgreMeshInstance *omi = new OgreMeshInstance(ent);
                         omi->SetId((*iit).first);
@@ -149 +284 @@
         return true;
 }
-
+#endif
 
 typedef PlatFormBoundingBoxConverter<OctreeSceneManager> OctreeBoundingBoxConverter;

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreOcclusionCullingSceneManager.h

@@ -225 +225 @@
         int mCurrentEntityId;
 
-        typedef map<int, MovableObject *> MovableObjectsMap;
+        typedef map<int, MovableObject *> MovableMap;
 
         /// hash table for view cells geometry
-    MovableObjectsMap mViewCellsGeometry;
+    MovableMap mViewCellsGeometry;
+
+        bool mViewCellsGeometryLoaded;
 };