/cygdrive/d/src/svn/vrut/trunk/core/src/bvh.h

Go to the documentation of this file.

/*
 * $Id: bvh.h 707 2009-02-19 11:54:49Z bittner $
 *
 * Description  : One line description of file.
 * Author       : Vaclav Kyba <mail/Jabber: vaseo1@gmail.com>  <ICQ: 98576293>
 * 
 * Purpose      :
 *     Long description of what the file is for.
 */


#ifndef __BVH__H__
#define __BVH__H__
#include <wx/app.h>
#include <map>
#include <deque>
#include <vector>
#include "bvhnode.h"
#include "moddefs.h"


namespace VRUT
{
       class Scene;
       class Camera;
struct RayIntersectionInfo;

       class BVH
       {
       public:
              struct IntersectionInfo
              {
                     NODE_ID nodeID;
                     VECTOR3 intersection;
                     float dist;
              };

              typedef std::vector<NODE_ID> ItemsList;
              typedef std::multimap<float, NODE_ID> BlendedList;

       private:
              WX_DECLARE_HASH_MAP( NODE_ID, BVHNode *, wxIntegerHash, wxIntegerEqual, SceneToBVHMap );
              struct QNode
              {
                     BVHNode ** currentNode;
                     std::deque<BVHNode *> * itemsPending;
                     BVHNode * parent;

                     QNode(BVHNode ** n,
                            std::deque<BVHNode *> * m,
                            BVHNode * p) : currentNode(n), itemsPending(m), parent(p)      {}
              };
              enum AXIS { X_AXIS, Y_AXIS, Z_AXIS };

              BVHNode * root;
              Scene * scene;
              SceneToBVHMap bvhNodes;

              void splitGeometry(const std::deque<BVHNode *> * geometry,
                                   std::deque<BVHNode *> * geometryL,
                                   std::deque<BVHNode *> * geometryR) const;

              void queueUpForRender(BVHNode * node, const Camera * camera, ItemsList * itemsList, BlendedList * blendItemsList, bool inclChildren = false);

              static void getGeometryNodes(std::deque<const BVHNode *> * items, const BVHNode * startNode);

              static void getGeometryNodes(std::deque<BVHNode *> * items, BVHNode * startNode);

       public:
         int numberOfNodes;

         
              BVH(Scene * _scene);
              ~BVH();

              BVHNode * GetRoot() const
              {
                     return root;
              }

              BVHNode * GetBVHNodeAssignedTo(NODE_ID sceneNodeID) const
              {
                     SceneToBVHMap::const_iterator mapIt = bvhNodes.find(sceneNodeID);
                     return ( mapIt == bvhNodes.end() ? (BVHNode *)NULL : mapIt->second );
              }

         void AssignNodeIds();
         
              bool IsBuilt() const        { return root != (BVHNode *)NULL; }

              static unsigned GetNumGeometryNodes(const BVHNode * startNode);

              void GetGeometryNodeIDs(std::deque<NODE_ID> * items, const BVHNode * startNode) const;

              void Destroy()                     { SAFE_DELETE(root); }

              void Rebuild();

              BVHNode * Remove(BVHNode * node);

              void Insert(BVHNode * node);

              void Build(std::deque<NODE_ID> * items);

              void Cull(Camera * camera, ItemsList * itemsList, BlendedList * blendItemsList);

              bool BoundProbe(const Ray & ray, IntersectionInfo * info);

         bool CastRay(const Ray & ray, RayIntersectionInfo &info);

              void UpdateBV(BVHNode * node = (BVHNode *)NULL);

              static void SetInvalid(BVHNode * node);

#ifdef GRAPHVIZ_SUPPORT
              void CreateGraphVizFile() const;
#endif

#ifdef __WXDEBUG__
              void Dump() const;
#endif

              friend class Scene;
       };
};

#endif

---