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

#ifndef _PlatformBoundingBoxConverter_H__
#define _PlatformBoundingBoxConverter_H__
 
#include "OgreAxisAlignedBox.h"
#include "AxisAlignedBox3.h"
#include "Vector3.h"
#include "BoundingBoxConverter.h"
#include "Containers.h"
#include "IntersectableWrapper.h"


namespace Ogre {

#define USE_KD_PVS 1

class Entity;
class OctreeSceneManager;
class KdTreeSceneManager;
class BvHierarchySceneManager;

typedef vector<Entity *> EntityContainer;

class EngineIntersectable: public GtpVisibilityPreprocessor::IntersectableWrapper<EntityContainer *>
{
public:
        EngineIntersectable(EntityContainer *item):
        GtpVisibilityPreprocessor::IntersectableWrapper<EntityContainer *>(item) {}

        // hack
        EngineIntersectable::~EngineIntersectable() 
        {
                delete mItem;
        }

        int Type() const
        {
                return Intersectable::ENGINE_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;

        /// this can be any scene manager
        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
        // note: this function must be provided by scene manager
        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 != sit_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());
                                        
                        // 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;
}


#define ENLARGE_OBJECT_BBOX 0
#define ENLRAGE_NODE_BBOX 0

template<typename T>
void PlatFormBoundingBoxConverter<T>::FindIntersectingObjects(const AxisAlignedBox &box,
                                                                                                                          EntityContainer &objects) const
{
        list<SceneNode *> sceneNodeList;

        // find intersecting scene nodes to get candidates for intersection
    // note: this function has to be provided by scene manager

#if ENLARGE_NODE_BBOX
        // make search radius larger
        AxisAlignedBox largebox = EnlargeBox(box);
        mSceneMgr->findNodesIn(largebox, sceneNodeList, NULL);

        list<SceneNode *>::const_iterator sit, sit_end = sceneNodeList.end();

        GtpVisibilityPreprocessor::AxisAlignedBox3 nodeBox = 
                OgreTypeConverter::ConvertFromOgre(largebox);
#else

        mSceneMgr->findNodesIn(box, sceneNodeList, NULL);

        list<SceneNode *>::const_iterator sit, sit_end = sceneNodeList.end();

        GtpVisibilityPreprocessor::AxisAlignedBox3 nodeBox = 
                OgreTypeConverter::ConvertFromOgre(box);
#endif

        // loop through the intersected scene nodes
        for (sit = sceneNodeList.begin(); sit != sceneNodeList.end(); ++ sit)
        {
                SceneNode *sn = *sit;
                SceneNode::ObjectIterator oit = sn->getAttachedObjectIterator();

                // find the objects that intersect the box
        while (oit.hasMoreElements())
                {
                        MovableObject *mo = oit.getNext();

                        // we are only interested in scene entities
                        if ((mo->getMovableType() != "Entity") &&
                                (mo->getMovableType() != "ManualObject"))
                                continue;
                        
                        // get the bounding box of the objects
#if ENLARGE_OBJECT_BBOX
                        // compare with enlarged entitiy box
                        const AxisAlignedBox bbox = EnlargeBox(mo->getWorldBoundingBox());
#else
                        const AxisAlignedBox bbox = mo->getWorldBoundingBox();
#endif

                        // test for intersection (note: function provided of preprocessor)
                        if (Overlap(nodeBox, OgreTypeConverter::ConvertFromOgre(bbox)))
                        {
                                objects.push_back(static_cast<Entity *>(mo));
                        }
                }
        }
}

static void AddToObjects(EntityContainer *entites, 
                                                 GtpVisibilityPreprocessor::ObjectContainer &objects,
                                                 const int id)
{
        // TODO: can actually just put single objects into pvs with same id, 
        // this can be sorted out later!!
#if 0
        EntityContainer::const_iterator eit, eit_end = entryObjects.end();

        for (eit = entryObjects.begin(); eit != eit_end; ++ eit)
        {
                Entity *ent = *eit;

        // warning: multiple ids possible
                OgreMeshInstance *omi = new OgreMeshInstance(ent);
                omi->SetId(id);
                objects.push_back(omi);
        }

        delete entryObjects;

#else

        EngineIntersectable *entry = new EngineIntersectable(entites);

        entry->SetId(id);
        objects.push_back(entry);
#endif
}

#if USE_KD_PVS
//-------------------------------------------------------------------------
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 pbox = (*iit).second;
                const int id = (*iit).first;

                const AxisAlignedBox box = 
                        OgreTypeConverter::ConvertToOgre(pbox);
                
                EntityContainer *entryObjects = new EntityContainer();

                // find all objects that intersect the bounding box
                FindIntersectingObjects(box, *entryObjects);

                AddToObjects(entryObjects, objects, id);
        }

        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) continue;
                
                // 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