Changeset 870 for GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE

Timestamp:

05/02/06 10:26:43 (19 years ago)

Author:

mattausch

Message:

added pvs

Location:

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE

Files:

• include/OgreMeshInstance.h (added)
• include/OgreVisibilityOctreeSceneManager.h (modified) (3 diffs)
• src/OgreMeshInstance.cpp (added)
• src/OgreVisibilityOctreeSceneManager.cpp (modified) (14 diffs)
• src/OgreVisibilitySceneManagerDll.cpp (modified) (1 diff)

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

@@ -123 +123 @@
         /** Finds object corresponding to this bounding box in the scene.
         */
-        MovableObject *FindCorrespondingObject(const AxisAlignedBox &box);
+        Entity *FindCorrespondingObject(const AxisAlignedBox &box);
 
         /** Identifies objects in the scene and gives them unique ids that
@@ -129 +129 @@
         */
         void IdentifyObjects(GtpVisibilityPreprocessor::ObjectContainer &objects);
+
+        /** Loads / unloads pvs of the view cell to set the visibility in the scene.
+        */
+        void applyViewCellPvs(GtpVisibilityPreprocessor::ViewCell *vc, const bool load);
+
+        /** updates pvs in current frame.
+        */
+        void updatePvs(Camera *cam);
+
+        /** Sets all objects invisible.
+        */
+        void SetObjectsVisible(const bool visible);
 
         /// the interface to the scene hierarchy.
@@ -183 +195 @@
         bool mViewCellsLoaded;
         GtpVisibilityPreprocessor::ViewCellsManager *mViewCellsManager;
+
+        /** Used to assign Ogre meshes to view cell entries.
+        */
+        GtpVisibilityPreprocessor::ObjectContainer mObjects;
+
+        GtpVisibilityPreprocessor::ViewCell *mOldViewCell;
+        GtpVisibilityPreprocessor::ViewCell *mCurrentViewCell;
+
+        /** If view cells are used.
+        */
+        bool mUseViewCells;
 };
 

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreVisibilityOctreeSceneManager.cpp

@@ -15 +15 @@
 #include <OgreConfigFile.h>
 #include "OgreTypeConverter.h"
+#include "OgreMeshInstance.h"
+#include "common.h"
 
 // normal terrain rendering
@@ -42 +44 @@
 mExecuteVertexProgramForAllPasses(true),
 mIsHierarchicalCulling(false),
-mViewCellsLoaded(false)
+mViewCellsLoaded(false),
+mCurrentViewCell(NULL),
+mOldViewCell(NULL),
+mUseViewCells(false)
 {
         mHierarchyInterface = new OctreeHierarchyInterface(this, mDestRenderSystem);
@@ -85 +90 @@
 {
         OGRE_DELETE(mHierarchyInterface);
+        CLEAR_CONTAINER(mObjects);
 }
 //-----------------------------------------------------------------------
@@ -127 +133 @@
     }
         // add bounding boxes of rendered objects
+        if (0)
         for (BoxList::iterator it = mBoxes.begin(); it != mBoxes.end(); ++it)
 {
@@ -145 +152 @@
                         {
                                 // render the leaf nodes
-                                if (((*it)->numAttachedObjects() > 0) && ((*it)->numChildren() == 0) && 
-                                         (*it)->getAttachedObject(0)->getMovableType() == "Entity")
+                                if ((*it)->numAttachedObjects() && 
+                                        !(*it)->numChildren() && 
+                                        ((*it)->getAttachedObject(0)->getMovableType() == "Entity") &&
+                                        (*it)->getAttachedObject(0)->isVisible())
                                 {
                                         getRenderQueue()->addRenderable((*it));
-                                        std::stringstream d;
-                                        d << "here 223 " <<  (*it)->getAttachedObject(0)->getWorldBoundingBox();
-                                        Ogre::LogManager::getSingleton().logMessage(d.str());
                                 }
-
-                                // addbounding boxes instead of node itself
-                                //(*it)->_addBoundingBoxToQueue(getRenderQueue());
                         }
                         // add renderables itself
@@ -247 +250 @@
                 return;
         }
+        
 
         //-- show visible scene nodes and octree bounding boxes from last frame
@@ -265 +269 @@
                         OctreeSceneManager::_findVisibleObjects(cam, onlyShadowCasters);
                 }
+
                 // only shadow casters will be rendered in shadow texture pass
                 if (0) mHierarchyInterface->SetOnlyShadowCasters(onlyShadowCasters);
+
+
+                //-- apply view cell pvs
+                updatePvs(cam);
         }
         
@@ -311 +320 @@
         else //-- the hierarchical culling algorithm
         {       
-                // this is also called in TerrainSceneManager: really
-                // nexessary?
+                // this is also called in TerrainSceneManager: really necessary?
                 //mDestRenderSystem -> setLightingEnabled(false);
 
@@ -498 +506 @@
                 if (!mViewCellsLoaded)
                 {
-                        LoadViewCells("");
-                        mViewCellsLoaded = true;
-                }
-
-                return true;
-        }
-
+                        LoadViewCells(static_cast<const char *>(val));
+                        mViewCellsLoaded = true;        
+                }
+
+                return true;
+        }
+        if (key == "UseViewCells")
+        { 
+                if (mViewCellsLoaded)
+                {
+                        mUseViewCells = *static_cast<const bool *>(val);
+                        
+                        if (mUseViewCells)
+                        {
+                                SetObjectsVisible(false);
+                                mCurrentViewCell = mOldViewCell = NULL;
+                        }
+                        else
+                        {
+                                SetObjectsVisible(true);
+                        }
+                }
+
+                return true;
+        }
         return VisibilityOptionsManager(mVisibilityManager, mHierarchyInterface).
                 setOption(key, val) || OctreeSceneManager::setOption(key, val);
@@ -876 +902 @@
    }
 }
-//-----------------------------------------------------------------------
-MovableObject *VisibilityOctreeSceneManager::FindCorrespondingObject(const AxisAlignedBox &box)
+
+inline static AxisAlignedBox EnlargeBox(const AxisAlignedBox &box)
+{
+        const float eps = 1e-3f;
+        const Vector3 veps(eps, eps, eps);
+        Vector3 max = box.getMaximum();
+        Vector3 min = box.getMinimum();
+
+        return AxisAlignedBox(min - veps, max + veps);
+}
+//-----------------------------------------------------------------------
+Entity *VisibilityOctreeSceneManager::FindCorrespondingObject(const AxisAlignedBox &box)
 {
         list<SceneNode *> sceneNodeList;
-
-        findNodesIn(box, sceneNodeList, NULL);
-        std::stringstream d; 
-        d << "\n*******************";
-        Ogre::LogManager::getSingleton().logMessage(d.str());
+        AxisAlignedBox mybox = EnlargeBox(box);
+        //AxisAlignedBox dummy(Vector3(-50000, -50000, -50000), Vector3(50000, 50000, 50000));
+        
+        // get intersecting scene nodes
+        findNodesIn(mybox, sceneNodeList, NULL);
+        
+
         list<SceneNode *>::const_iterator sit, sit_end = sceneNodeList.end();
 
-        float overlap = GtpVisibilityPreprocessor::Limits::Small;
-
-        
-        d << "here23 " << box;
-        Ogre::LogManager::getSingleton().logMessage(d.str());
-
-        MovableObject *bestFittingObj = NULL;
+        float overlap = 0;//GtpVisibilityPreprocessor::Limits::Small;
+
+        Entity *bestFittingObj = NULL;
         float bestFit = overlap;
 
@@ -908 +942 @@
         while (oit.hasMoreElements())
                 {
-                         MovableObject *mo = oit.getNext();
-                         const AxisAlignedBox bbox = mo->getWorldBoundingBox(true);
-                        
-                         overlap = RatioOfOverlap(OgreTypeConverter::ConvertFromOgre(box),
-                                                                          OgreTypeConverter::ConvertFromOgre(bbox));
+                        MovableObject *mo = oit.getNext();
+
+                        // we are only interested in scene entities
+                        if (mo->getMovableType() != "Entity")
+                        {
+                                continue;
+                        }
+                         
+                        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 = mo;
-                                d << "new bestfit " << bestFit << endl;Ogre::LogManager::getSingleton().logMessage(d.str());
-                                 // perfect fit => object found
+                        
+                                 bestFittingObj = static_cast<Entity *>(mo);
+
+                                 // perfect fit => object found, eraly exit
                                  if (overlap >= thresh)
-                                 {
-                                         std::stringstream d2; 
-        
-                        d2 << "!!best fit " << bestFittingObj->getWorldBoundingBox(true);
-        Ogre::LogManager::getSingleton().logMessage(d2.str());
-                                        return bestFittingObj;
-                                        }
+                                         return bestFittingObj;                         
                          }
                 }
         }
 
-        std::stringstream d2; 
-        if (bestFittingObj)
-        {
-                d2 << "best fit " << bestFittingObj->getWorldBoundingBox(true);
-        }
-        else
-        {
-                d2 << "warning, no best fitting objects";
-        }
-
-        Ogre::LogManager::getSingleton().logMessage(d2.str());
+        if (0)
+        {
+                std::stringstream d; 
+                if (bestFittingObj)
+                        d << "best fit: " << bestFit;     
+                else
+                        d << "warning, objects do not fit\n" << box;
+        
+                Ogre::LogManager::getSingleton().logMessage(d.str());
+        }
 
         return bestFittingObj;
@@ -948 +986 @@
 void VisibilityOctreeSceneManager::LoadViewCells(string filename)
 {
-        GtpVisibilityPreprocessor::ObjectContainer objects;
+        // the objects are set to invisible a prioriy
+        SetObjectsVisible(false);
+
         // identify the corresponding Ogre meshes using the bounding boxes
-        IdentifyObjects(objects);
+        IdentifyObjects(mObjects);
 
         // load the view cells assigning the found objects to the pvss
-        //mViewCellsManager->LoadViewCells(filename, &objects);
+        mViewCellsManager = 
+                GtpVisibilityPreprocessor::ViewCellsManager::LoadViewCells(filename, &mObjects);
+
+        std::stringstream d;
+        d << "view cells loaded" << endl;
+        Ogre::LogManager::getSingleton().logMessage(d.str());
 }
 //-----------------------------------------------------------------------
@@ -970 +1015 @@
                   const GtpVisibilityPreprocessor::AxisAlignedBox3 box = (*iit).second;
                   const AxisAlignedBox currentBox = OgreTypeConverter::ConvertToOgre(box);
-                  
-                  MovableObject *mo = FindCorrespondingObject(currentBox);
-
-                  //objects.push_back(mi);
-        }
-}
-
+                 
+                  Entity *ent = FindCorrespondingObject(currentBox);
+
+                  // create new mesh instance
+                  OgreMeshInstance *omi = new OgreMeshInstance(ent);
+                  omi->SetId((*iit).first);
+                  objects.push_back(omi);
+        }
+}
 //-------------------------------------------------------------------------
-void VisibilityOctreeSceneManager::loadVisibilityConfig(const String& filename)
-{
-        /// Set up the options
+void VisibilityOctreeSceneManager::applyViewCellPvs(GtpVisibilityPreprocessor::ViewCell *vc, 
+                                                                                                        const bool load)
+{       GtpVisibilityPreprocessor::Debug << "here9 " << endl;
+        // NOTE: should not happen, rather apply view cell representing unbounded space then
+        if (!vc) return;
+
+        GtpVisibilityPreprocessor::ObjectPvsMap::const_iterator oit,
+                        oit_end = vc->GetPvs().mEntries.end();
+
+        //-- PVS of view cell
+        for (oit = vc->GetPvs().mEntries.begin(); oit != oit_end; ++ oit)
+        {
+                if (!(*oit).first) continue;
+
+                OgreMeshInstance *omi = dynamic_cast<OgreMeshInstance*>((*oit).first);
+                omi->GetMesh()->setVisible(load);
+                GtpVisibilityPreprocessor::Debug << "here45 " << omi->GetId() << endl;
+        }
+}
+//-------------------------------------------------------------------------
+void VisibilityOctreeSceneManager::SetObjectsVisible(const bool visible)
+{
+        // for OGRE 1.2
+#ifdef OGRE12
+        MovableObjectIterator mit = getMovableObjectIterator("Entity");
+#else
+        EntityIterator eit = getEntityIterator();
+
+        // set all objects to invisible (initially);
+        while (eit.hasMoreElements())
+        {
+                Entity *ent = eit.getNext();
+                ent->setVisible(visible);
+        }
+
+#endif
+}
+//-------------------------------------------------------------------------
+void VisibilityOctreeSceneManager::loadVisibilityConfig(const String &filename)
+{
+        // TODO matt
+        // Set up the options
         ConfigFile config;
         String val;
@@ -1000 +1086 @@
         }
 }
+//-------------------------------------------------------------------------
+void VisibilityOctreeSceneManager::updatePvs(Camera *cam)
+{
+        Ogre::LogManager::getSingleton().logMessage("here196");
+        if (mViewCellsLoaded && mUseViewCells)
+        {
+                GtpVisibilityPreprocessor::ViewCell *vc = 
+                        mViewCellsManager->GetViewCell(OgreTypeConverter::ConvertFromOgre(cam->getDerivedPosition()));
+
+                std::stringstream d; d << "pos " << cam->getDerivedPosition() << "vc: " << vc;
+                Ogre::LogManager::getSingleton().logMessage(d.str());
+
+                // view cell changed => unload old objects and load new objects
+                if (vc != mCurrentViewCell)
+                {
+                        //-- unload old pvs
+                        if (mOldViewCell)
+                        {
+                                const bool load = false;
+
+                                applyViewCellPvs(mOldViewCell, load);
+                                Ogre::LogManager::getSingleton().logMessage("here16");
+                        }
+
+                        mOldViewCell = mCurrentViewCell;
+
+                        //-- load new pvs
+                        mCurrentViewCell = vc;
+                        const bool load = true;
+
+                        applyViewCellPvs(mCurrentViewCell, load);
+                        Ogre::LogManager::getSingleton().logMessage("here106");
+                }
+        }
+}
+
 }  // namespace Ogre

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreVisibilitySceneManagerDll.cpp

@@ -49 +49 @@
 {
         visEnv = new GtpVisibility::VisibilityEnvironment();
+        visEnv->LoadEnvironment("vienna_simple.env");
         visManager = new GtpVisibility::VisibilityManager(visEnv);