BVHSceneTree.hpp

#pragma once
#ifndef __H__OCULAR_CORE_SCENE_BVH_SCENE_TREE__H__
#define __H__OCULAR_CORE_SCENE_BVH_SCENE_TREE__H__

#include "ISceneTree.hpp"
#include "SceneObject.hpp"
#include "BVHSceneNode.hpp"

#include <vector>
#include <utility>

//------------------------------------------------------------------------------------------

namespace Ocular
{
    namespace Core
    {
        class BVHSceneTree : public ISceneTree
        {
            typedef std::pair<uint64_t, SceneObject*> MortonPair;  

        public:

            BVHSceneTree();
            virtual ~BVHSceneTree();

            //------------------------------------------------------------
            // Inherited Methods
            //------------------------------------------------------------

            virtual void restructure() override;
            virtual void destroy() override;
            virtual void addObject(SceneObject* object) override;
            virtual void addObjects(std::vector<SceneObject*> const& objects) override;
            virtual bool removeObject(SceneObject* object) override;
            virtual void removeObjects(std::vector<SceneObject*> const& objects) override;
            virtual void getAllObjects(std::vector<SceneObject*>& objects) const override;
            virtual void getAllVisibleObjects(Math::Frustum const& frustum, std::vector<SceneObject*>& objects) const override;
            virtual void getIntersections(Math::Ray const& ray, std::vector<SceneObject*>& objects) const override;
            virtual void getIntersections(Math::BoundsSphere const& bounds, std::vector<SceneObject*>& objects) const override;
            virtual void getIntersections(Math::BoundsAABB const& bounds, std::vector<SceneObject*>& objects) const override;
            virtual void getIntersections(Math::BoundsOBB const& bounds, std::vector<SceneObject*>& objects) const override;
            virtual void setDirty(UUID const& uuid) override;

            virtual SceneTreeType getType() const override;

        protected:

            void rebuild();

            void insertNewObjects();

            void updateDirtyNodes();

            bool rebuildNeeded() const;

            void destroyNode(BVHSceneNode* node) const;

            void insertObject(SceneObject* object);

            //------------------------------------------------------------
            // Traversal Methods
            //------------------------------------------------------------

            BVHSceneNode* findParent(BVHSceneNode* node, SceneObject* object) const;

            BVHSceneNode* findNearest(BVHSceneNode* node, uint64_t const& morton) const;

            void findVisible(BVHSceneNode* node, Math::Frustum const& frustum, std::vector<SceneObject*>& objects) const;

            void findIntersections(BVHSceneNode* node, Math::Ray const& ray, std::vector<std::pair<SceneObject*, float>>& objects) const;

            void findIntersections(BVHSceneNode* node, Math::BoundsSphere const& bounds, std::vector<SceneObject*>& objects) const;

            void findIntersections(BVHSceneNode* node, Math::BoundsAABB const& bounds, std::vector<SceneObject*>& objects) const;

            void findIntersections(BVHSceneNode* node, Math::BoundsOBB const& bounds, std::vector<SceneObject*>& objects) const;

            //------------------------------------------------------------
            // Build Methods
            //------------------------------------------------------------
            
            void build();

            void createMortonPairs(std::vector<MortonPair>& pairs) const;

            BVHSceneNode* generateTree(BVHSceneNode* parent, std::vector<MortonPair> const& pairs, uint32_t first, uint32_t last) const;

            uint32_t findSplit(std::vector<MortonPair> const& pairs, uint32_t first, uint32_t last) const;

            void fitNodeBounds(BVHSceneNode* node) const;

        private:

            bool m_IsDirty;                            
                              
            BVHSceneNode* m_Root;                      
            
            std::vector<BVHSceneNode*> m_DirtyNodes;   
            std::vector<SceneObject*>  m_AllObjects;   
        };
    }
}
//------------------------------------------------------------------------------------------

#endif