source: GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/include/OgreBoundingBoxConverter.h @ 1623

#ifndef _PlatFormBoundingBoxConverter_H__
#define _PlatFormBoundingBoxConverter_H__
 
#include "OgreAxisAlignedBox.h"
#include "AxisAlignedBox3.h"
#include "Vector3.h"
#include "BoundingBoxConverter.h"
#include "Containers.h"
#include "IntersectableWrapper.h"
//#include "KdTree.h"


namespace Ogre {

#define USE_KD_PVS 1
class Entity;
class OctreeSceneManager;
class KdTreeSceneManager;
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
*/
template<typename T>
class __declspec(dllexport) PlatFormBoundingBoxConverter: public GtpVisibilityPreprocessor::BoundingBoxConverter
{
public:
        PlatFormBoundingBoxConverter(T *sm);
        
        bool IdentifyObjects(const GtpVisibilityPreprocessor::IndexedBoundingBoxContainer &iboxes,
                                                 GtpVisibilityPreprocessor::ObjectContainer &objects) const;


protected:

        //-------------------------------------------------------------------------
        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);
        }
        
        //-------------------------------------------------------------------------
        inline static AxisAlignedBox ScaleBox(const AxisAlignedBox &box)
        {
                const float scale = 1.5f;
        Vector3 max = box.getMaximum();
        Vector3 min = box.getMinimum();
                Vector3 size = max - min;
                Vector3 newSize = size*(scale*0.5f);
                Vector3 center = 0.5f * (min + max); 

                Vector3 min = center - newSize;
                Vector3 max = center + newSize;

                return AxisAlignedBox(min, max);
        }
        /** 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;
};

//-------------------------------------------------------------------------
template<typename T>
PlatFormBoundingBoxConverter<T>::PlatFormBoundingBoxConverter(T *sm):
mSceneMgr(sm)
{
}
//-----------------------------------------------------------------------
template<typename T>
Entity *PlatFormBoundingBoxConverter<T>::FindBestFittingObject(const AxisAlignedBox &box) const
{
        list<SceneNode *> sceneNodeList;
        AxisAlignedBox3 enlargedBox = 
        AxisAlignedBox mybox = EnlargeBox(box);
                
        // get intersecting scene nodes
        mSceneMgr->findNodesIn(mybox, sceneNodeList, NULL);
                
        // minimal overlap
        float overlap = 0;//1e-6;

        Entity *bestFittingObj = NULL;
        float bestFit = overlap;

        // perfect fit threshold
        const float thresh = 1.0 - GtpVisibilityPreprocessor::Limits::Small;

        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
{//return;
        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::AxisAlignedBox3 nodeBox = OgreTypeConverter::ConvertFromOgre(mybox);
        //GtpVisibilityPreprocessor::AxisAlignedBox3 nodeBox = OgreTypeConverter::ConvertFromOgre(box);

        // find really intersecting objects
        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;
                        }
                         
                        //const AxisAlignedBox bbox = EnlargeBox(mo->getWorldBoundingBox());
                        const AxisAlignedBox bbox = mo->getWorldBoundingBox();

                        const bool overlaps = Overlap(nodeBox,
                                                                                  OgreTypeConverter::ConvertFromOgre(bbox)
                                                                                  );
                                                                                  //,0.00001);
        
                         if (overlaps)
                         {
                                 objects.push_back(static_cast<Entity *>(mo));
                         }
                }
        }
}
*/
template<typename T>
void PlatFormBoundingBoxConverter<T>::FindIntersectingObjects(const AxisAlignedBox &box,
                                                                                                                          EntityContainer &objects) const
{//return;
        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::AxisAlignedBox3 nodeBox = OgreTypeConverter::ConvertFromOgre(mybox);
        GtpVisibilityPreprocessor::AxisAlignedBox3 nodeBox = OgreTypeConverter::ConvertFromOgre(box);

        // find really intersecting objects
        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;
                        }
                         
                        //const AxisAlignedBox bbox = EnlargeBox(mo->getWorldBoundingBox());
                        const AxisAlignedBox bbox = mo->getWorldBoundingBox();

                        const bool overlaps = Overlap(nodeBox,
                                                                                  OgreTypeConverter::ConvertFromOgre(bbox)
                                                                                  );
                                                                                  //,0.00001);
        
                         if (overlaps)
                         {
                                 objects.push_back(static_cast<Entity *>(mo));
                         }
                }
        }
}
#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 (0 && ((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>
bool PlatFormBoundingBoxConverter<T>::IdentifyObjects(
        const GtpVisibilityPreprocessor::IndexedBoundingBoxContainer &iboxes,
        GtpVisibilityPreprocessor::ObjectContainer &objects) const
{
        GtpVisibilityPreprocessor::IndexedBoundingBoxContainer::
                const_iterator iit, iit_end = iboxes.end();
  
        for (iit = iboxes.begin(); iit != iit_end; ++ iit)
        {
                const GtpVisibilityPreprocessor::AxisAlignedBox3 box = (*iit).second;
                const AxisAlignedBox currentBox = OgreTypeConverter::ConvertToOgre(box);
   
                Entity *ent = FindBestFittingObject(currentBox);

                if (ent)
                {
                        // create new mesh instance
                        OgreMeshInstance *omi = new OgreMeshInstance(ent);
                        omi->SetId((*iit).first);
                        objects.push_back(omi);
                }
        }

        return true;
}
#endif

typedef PlatFormBoundingBoxConverter<OctreeSceneManager> OctreeBoundingBoxConverter;
typedef PlatFormBoundingBoxConverter<BvHierarchySceneManager> BvhBoundingBoxConverter;
typedef PlatFormBoundingBoxConverter<KdTreeSceneManager> KdTreeBoundingBoxConverter;

} // namespace Ogre

#endif // PlatFormBoundingBoxConverter