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

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

namespace Ogre {

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


/**     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);
        }
        
        Entity *FindBestFittingObject(const AxisAlignedBox &box) 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;
        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;
                        }
                         
                        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>
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);

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

        return true;
}


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

} // namespace Ogre

#endif // PlatFormBoundingBoxConverter