source: GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE/src/OgreKdTreeSceneNode.cpp @ 2280

/*
-----------------------------------------------------------------------------
This source file is part of the GameTools Project
http://www.gametools.org

Author: Martin Szydlowski
-----------------------------------------------------------------------------
*/

#include "OgreKdTreeSceneNode.h"
#include "OgreKdTreeSceneManager.h"

#include <OgreStringConverter.h>
#include <OgreLogManager.h>

namespace Ogre
{
        // TRIVIA: this function is _not_ called for nodes which did not change since the last frame
        // only exception: the root node ... it's aabb should be null however, so we don't care
        void KdTreeSceneNode::_updateBounds(void)
        {
                // Reset bounds first
                mWorldAABB.setNull();

                // Update bounds from own attached objects
                ObjectMap::iterator i;
                for (i = mObjectsByName.begin(); i != mObjectsByName.end(); ++i)
                {
                        // Merge world bounds of each object
                        mWorldAABB.merge(i->second->getWorldBoundingBox(true));
                }

                if (!mWorldAABB.isNull())
                {
                        static_cast<KdTreeSceneManager *>(mCreator)->_updateNode(this);
                }
        }

        void KdTreeSceneNode::computeScene(PlaneEventList& events, AxisAlignedBox& aabb, int& nObjects, bool includeChildren)
        {
                /**************************************************************************************/
                /* HACK: do not include camera node, FUCKS UP world AABB really BAD, dunno why        */
                /* TODO: find a generic solution where MOVABLE nodes are NOT INSERTED into the KDTREE */
                /**************************************************************************************/
                //if (mName == "PlayerCamNode")
                //      return;

                // first compute nodes AABB
                mWorldAABB.setNull();
                // Update bounds from own attached objects
                ObjectMap::iterator i;
                for (i = mObjectsByName.begin(); i != mObjectsByName.end(); ++i)
                {
                        // ignore objects with no actual geometry like frustums & lights
                        if (getExcludedMovables().find(i->second->getMovableType()) == getExcludedMovables().end())
                        {
                                //LogManager::getSingleton().getLog(KDTREE_LOGNAME)->logMessage("Adding movable type " + i->second->getMovableType() + " to KdTree");
                                // Merge world bounds of each object
                                mWorldAABB.merge(i->second->getWorldBoundingBox(true));
                        }
                }

                // create information for KdTree/SAH
                if (!mWorldAABB.isNull())
                {
                        // merge aabb with global AABB
                        aabb.merge(mWorldAABB);

                        // increase object count
                        nObjects++;

                        // generate events
                        PlaneEvent::Dimension axes[] = 
                                {PlaneEvent::PED_X, PlaneEvent::PED_Y, PlaneEvent::PED_Z};
                        Vector3 min = mWorldAABB.getMinimum();
                        Vector3 max = mWorldAABB.getMaximum();
                        for (int i = 0; i < 3; i++)
                        {
                                // 1-D and 2-D objects
                                if (min[i] == max[i])
                                {       
                                        //e = new PlaneEvent(this, min, axes[i], PlaneEvent::PET_ON);
                                        //sceneinfo.events.push_back(*e);
                                        events.push_back(PlaneEvent(this, min, axes[i], PlaneEvent::PET_ON));
                                }
                                else
                                {
                                        //e = new PlaneEvent(this, min, axes[i], PlaneEvent::PET_START);
                                        //sceneinfo.events.push_back(*e);
                                        //e = new PlaneEvent(this, max, axes[i], PlaneEvent::PET_END);
                                        //sceneinfo.events.push_back(*e);
                                        events.push_back(PlaneEvent(this, min, axes[i], PlaneEvent::PET_START));
                                        events.push_back(PlaneEvent(this, max, axes[i], PlaneEvent::PET_END));
                                }
                        }
                }

                // Merge with children
                if (includeChildren)
                {
                        ChildNodeMap::iterator child;
                        for (child = mChildren.begin(); child != mChildren.end(); ++child)
                        {
                                KdTreeSceneNode* sceneChild = static_cast<KdTreeSceneNode*>(child->second);
                                sceneChild->computeScene(events, aabb, nObjects);
                        }
                }
        }

        //void KdTreeSceneNode::_findVisibleObjects(Camera* cam, RenderQueue* queue, 
        //      bool includeChildren, bool displayNodes, bool onlyShadowCasters)
        void KdTreeSceneNode::queueObjects(Camera* cam, RenderQueue* queue, bool onlyShadowCasters)
        {
                //SceneNode::_findVisibleObjects(cam, queue, includeChildren, displayNodes, onlyShadowCasters);

                // Add all entities
                ObjectMap::iterator iobj;
                ObjectMap::iterator iobjend = mObjectsByName.end();
                for (iobj = mObjectsByName.begin(); iobj != iobjend; ++iobj)
                {
                        // Tell attached objects about camera position (incase any extra processing they want to do)
                        iobj->second->_notifyCurrentCamera(cam);
                        if (iobj->second->isVisible() &&
                                (!onlyShadowCasters || iobj->second->getCastShadows()))
                        {
                                iobj->second->_updateRenderQueue(queue);
                        }
                }

                // Check if the bounding box should be shown.
                // See if our flag is set or if the scene manager flag is set.
                if (mShowBoundingBox || (mCreator && mCreator->getShowBoundingBoxes())) 
                { 
                        _addBoundingBoxToQueue(queue);
                }
        }

        void KdTreeSceneNode::getGeometryList(GeometryVector *geometryList)
        {
                SceneNode::ObjectIterator objIt = getAttachedObjectIterator();

                while (objIt.hasMoreElements())
                {
                        MovableObject *movable = objIt.getNext();

                        // we are interested only in the entities, i.e., instances of geometry
                        if (movable->getMovableType() == "Entity")
                        {
                                Entity *ent = static_cast<Entity *>(movable);
                                geometryList->push_back(ent);
                        }
                }
        }

        // recalculate the world aabb
        AxisAlignedBox KdTreeSceneNode::getBoundingBox(void) const
        {
                return mWorldAABB;
        }

        KdTreeSceneNode::StringSet& KdTreeSceneNode::getExcludedMovables(void)
        {
                static StringSet sExluded;

                // initialise once
                if (sExluded.empty())
                {
                        sExluded.insert("Camera");
                        sExluded.insert("Frustum");
                        sExluded.insert("Light");
                }

                return sExluded;
        }

        // DEBUG
        String KdTreeSceneNode::dumpToString(void)
        {
                String objects;
                // Add all entities
                ObjectMap::iterator iobj = mObjectsByName.begin();
                ObjectMap::iterator iobjend = mObjectsByName.end();
                while (iobj != iobjend)
                {
                        objects += " " + iobj->second->getName();
                        iobj++;
                }
                objects += " Attached to " + StringConverter::toString(mLeaves.size()) + " KdLeaves.";
                return objects;
        }
}