Changeset 1173

Timestamp:

07/31/06 17:34:56 (18 years ago)

Author:

szydlowski

Message:

Finished kdtree hierarchy interface, started modifications to kdtree scene manager

Location:

GTP/trunk/Lib/Vis/OnlineCullingCHC/OGRE

Files:

• include/OgreKdRenderable.h (modified) (2 diffs)
• include/OgreKdTree.h (modified) (6 diffs)
• include/OgreKdTreeSceneManager.h (modified) (2 diffs)
• include/OgreKdTreeSceneNode.h (modified) (1 diff)
• src/OgreKdTree.cpp (modified) (1 diff)
• src/OgreKdTreeHierarchyInterface.cpp (modified) (5 diffs)
• src/OgreKdTreeSceneManager.cpp (modified) (1 diff)
• src/OgreKdTreeSceneNode.cpp (modified) (1 diff)

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

@@ -12 +12 @@
 
 #include "OgreKdTree.h"
+#include "HierarchyInterface.h"
 
 namespace Ogre
@@ -33 +34 @@
                 // put all objects this element holds in the renedering queue
                 virtual void queueObjects(Camera* cam, RenderQueue* queue, bool onlyShadowCasters) = 0;
+
+                // place all entities in geometry queue (for CHC)
+                virtual void getGeometryList(GtpVisibility::GeometryVector *geometryList) = 0;
 
                 // return a bounding box enclosing all objects

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

@@ -27 +27 @@
 #include <stack>
 
-//#include "OgreKdTreeHierarchyInterface.h"
 
 
@@ -264 +263 @@
                         */
                         bool isNodeVisible(void) { return mVisible; };
-                        /** Gets this node's parent (NULL if this is the root).
-                        */      
-                        KdTree::Node *getParent(void) { return mParent; };
                         /** Frame id when this octree was last rendered. 
                         @return last rendered frame id
@@ -275 +271 @@
                         */
                         void setLastRendered(unsigned int frameid) { mLastRendered = frameid; };
-
-                        /* do we need this? */
-                        /** Returns real extent of the octree, i.e., the merged extent of the bounding boxes. 
+                        /** Gets this node's parent (NULL if this is the root).
+                        */      
+                        KdTree::Branch *getParent(void) { return mParent; };
+                        /** Returns real extent of the kdtree, i.e., the merged extent of the bounding boxes. 
                         */
-                        //AxisAlignedBox _getWorldAABB(void) const = 0;
+                        AxisAlignedBox _getWorldAABB(void) const { return mWorldAABB; };
+                        /** Updates bound of the real aabb of kdtree
+                        */
+                        virtual void _updateBounds() = 0;
 
 
@@ -290 +290 @@
                         // for the CHC hierarchy interface
                         /** the real extent of the node. */
-                        //AxisAlignedBox mWorldAABB;
-
+                        AxisAlignedBox mWorldAABB;
+                        
                         unsigned int mLastRendered;
                         unsigned int mLastVisited;
@@ -323 +323 @@
                         // a branch never has geometry
                         virtual bool hasGeometry() const { return false; };
+
+                        // branches do not posses geometry => just merge child aabbs
+                        virtual void _updateBounds()
+                        {
+                                // reset box
+                                mWorldAABB.setNull();
+
+                                if (mLeft)
+                                        mWorldAABB.merge(mLeft->_getWorldAABB());
+                                if (mRight)
+                                        mWorldAABB.merge(mRight->_getWorldAABB());
+
+                                // update parent recursively
+                                if (mParent)
+                                        mParent->_updateBounds();
+                        }
                         
                         Node * mLeft;
@@ -347 +363 @@
                         // a leaf has geometry when it has renderables
                         virtual bool hasGeometry() const { return !mKdRenderables.empty(); };
+
+                        // update the world aabb based on the contained geometry
+                        virtual void _updateBounds();
 
                         virtual void remove(KdRenderable * rend)

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

@@ -28 +28 @@
         public:
                 KdTreeSceneManager(const String& name, GtpVisibility::VisibilityManager *vm);
-                //KdTreeSceneManager(const String& name, int maxdepth);
                 ~KdTreeSceneManager(void);
 
@@ -34 +33 @@
                 virtual SceneNode* createSceneNode(void);
                 virtual SceneNode* createSceneNode(const String& name);
-                void init( int maxdepth );
-                void walkTree(KdTree * node, Camera *cam);
 
                 virtual void _findVisibleObjects(Camera *cam, bool onlyShadowCasters);
+
+                virtual void _renderNodes(const KdRenderableList& nodelist, Camera * cam,
+                        bool onlyShadowCasters, int leavePassesInQueue);
 
                 virtual void setShowBoxes(bool showboxes);

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

@@ -37 +37 @@
                 virtual void queueObjects(Camera* cam, RenderQueue* queue, bool onlyShadowCasters);
 
+                // place all entities in geometry queue (for CHC)
+                virtual void getGeometryList(GtpVisibility::GeometryVector *geometryList);
+
                 // return a bounding box enclosing all objects
                 virtual AxisAlignedBox getBoundingBox() const;

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

@@ -1496 +1496 @@
                 mKdRenderables.clear();
         }
-}
+
+        // update the world aabb based on the contained geometry
+        void KdTree::Leaf::_updateBounds()
+        {
+                // reset box
+                mWorldAABB.setNull();
+
+                // merge boxes from attached geometry
+                KdRenderableList::iterator it = mKdRenderables.begin();
+                KdRenderableList::iterator end = mKdRenderables.end();
+                while (it != end)
+                {
+                        mWorldAABB.merge((*it)->getBoundingBox());
+                        it++;
+                }
+
+                // update parent recursively
+                if (mParent)
+                        mParent->_updateBounds();
+        }
+} // namespace Ogre

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

@@ -8 +8 @@
 */
 
+#include "OgreKdRenderable.h"
 #include "OgreKdTreeSceneManager.h"
 #include "OgreKdTreeHierarchyInterface.h"
@@ -51 +52 @@
 void KdTreeHierarchyInterface::RenderNode(GtpVisibility::HierarchyNode *node)
 {
-        /*** TODO ***/
+        KdTree::Node * kdnode = KDNODEPTR_CAST(node);
+        if (kdnode->lastRendered() != mFrameId)
+        {
+                kdnode->setLastRendered(mFrameId);
+                KdTreeSceneManager * ksm = static_cast<KdTreeSceneManager *>(mSceneManager);
+
+                // render only if the node is a leaf
+                if (kdnode->isLeaf())
+                {
+                        ksm->_renderNodes(KDLEAFPTR_CAST(node)->mKdRenderables, mCamera, 
+                                mOnlyShadowCasters, mLeavePassesInQueue);
+                }       
+
+                mVisibleNodes.push_back(node);
+        }
 }
 
 void KdTreeHierarchyInterface::PullUpVisibility(GtpVisibility::HierarchyNode *node) const
 {
-        /*** TODO ***/
+        KdTree::Node * kdnode = KDNODEPTR_CAST(node);
+
+        while (kdnode && !kdnode->isNodeVisible())
+        {
+                kdnode->setNodeVisible(true);
+                kdnode = kdnode->getParent();
+        }
 }
 
 float KdTreeHierarchyInterface::GetSquaredDistance(GtpVisibility::HierarchyNode *node) const
 {
-        /*** TODO ***/
-        return 0.0;
+        const Vector3 pos = KDNODEPTR_CAST(node)->mAABB.getCenter();
+        return (mCameraPosition - pos).squaredLength();
 }
 
 AxisAlignedBox * KdTreeHierarchyInterface::GetBoundingBox(GtpVisibility::HierarchyNode *node)
 {
-        /*** TODO ***/
-        return new AxisAlignedBox();
+        // reuse box if node is the same
+        // only create renderable bounding box for new node
+        if (node != mSavedNode)
+        {
+                mSavedNode = node;
+                mBox = KDNODEPTR_CAST(node)->_getWorldAABB();
+        }
+
+        return &mBox;
 }
 
@@ -78 +106 @@
 void KdTreeHierarchyInterface::SetNodeVisible(GtpVisibility::HierarchyNode *node, const bool visible) const
 {
-        /*** TODO ***/
+        KDNODEPTR_CAST(node)->setNodeVisible(visible);
 }
 
 bool KdTreeHierarchyInterface::IsNodeVisible(GtpVisibility::HierarchyNode *node) const
 {
-        /*** TODO ***/
-        return true;
+        return KDNODEPTR_CAST(node)->isNodeVisible();
 }
 
 void KdTreeHierarchyInterface::SetLastVisited(GtpVisibility::HierarchyNode *node, const unsigned int frameId) const
 {
-        /*** TODO ***/
+        KDNODEPTR_CAST(node)->setLastVisited(frameId);
 }
 
 unsigned int KdTreeHierarchyInterface::LastVisited(GtpVisibility::HierarchyNode *node) const
 {
-        /*** TODO ***/
-        return 0;
+        return KDNODEPTR_CAST(node)->lastVisited();
 }
 
@@ -101 +127 @@
                                                                                                    GtpVisibility::CullingType type) const
 {
-        /*** TODO ***/
+        WireBoundingBox *box = KDNODEPTR_CAST(node)->getWireBoundingBox();
+
+        if (type == GtpVisibility::FRUSTUM_CULLED)
+        {
+                box->setMaterial("FrustumCulledNodesMaterial");
+        }
+        else // type == GtpVisibility::QUERY_CULLED
+        {
+                box->setMaterial("QueryCulledNodesMaterial");
+        }
+
+        // TODO: maybe boxlist?
+        dynamic_cast<KdTreeSceneManager *>(mSceneManager)->getRenderQueue()->addRenderable(box);
 }
 
@@ -108 +146 @@
                                                                                                    bool includeChildren) 
 {
-        /*** TODO ***/
+        KdTree::Node * kdnode = KDNODEPTR_CAST(node);
+        if (kdnode->isLeaf())
+        {
+                KdTree::Leaf * kdleaf = KDLEAFPTR_CAST(node);
+                KdRenderableList::iterator it = kdleaf->mKdRenderables.begin();
+                KdRenderableList::iterator end = kdleaf->mKdRenderables.end();
+                while (it != end)
+                {
+                        (*it)->getGeometryList(geometryList);
+                        it++;
+                }
+        }
 }
 

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

@@ -347 +347 @@
         }
 
+        // TODO: looks too easy, verify if it works 
+        void KdTreeSceneManager::_renderNodes(const KdRenderableList& nodelist, Camera * cam, 
+                bool onlyShadowCasters, int leavePassesInQueue)
+        {
+#ifdef GTP_VISIBILITY_MODIFIED_OGRE
+                _deleteRenderedQueueGroups(leavePassesInQueue); //try avoiding modified ogre code
+#else
+                getRenderQueue()->clear();
+#endif
+                KdRenderableList::const_iterator it = nodelist.begin();
+                KdRenderableList::const_iterator end = nodelist.end();
+                while (it != end)
+                {
+                        (*it)->queueObjects(cam, getRenderQueue(), onlyShadowCasters);
+                        it++;
+                }
+
+                SceneManager::_renderVisibleObjects();
+
+        }
+
         //-----------------------------------------------------------------------
         //-----------------------------------------------------------------------

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

@@ -140 +140 @@
         }
 
+        void KdTreeSceneNode::getGeometryList(GtpVisibility::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);
+                                //std::stringstream d; d << "ent " << ent->getName(); 
+                                //LogManager::getSingleton().logMessage(d.str());
+                                geometryList->push_back(ent);
+                        }
+                }
+        }
+
         AxisAlignedBox KdTreeSceneNode::getBoundingBox() const
         {