Merge branch 'OctTree' of github.com:teamfisk/TacticalZ into OctTree

# Conflicts:
#	src/Tests/OctTreeTest.cpp

include/Engine/Core/Collision.h

@@ -1,17 +1,43 @@
 #ifndef Collision_h__
 #define Collision_h__
 
+#include <vector>
+
 #include "Core/Ray.h"
 #include "Core/AABB.h"
+#include "Engine/Rendering/RawModel.h"
 
 namespace Collision
 {
-
+//Return true if the ray hits the box.
 bool RayAABBIntr(const Ray& ray, const AABB& box);
 bool RayVsAABB(const Ray& ray, const AABB& box);
+//Return true if the ray hits the box, also outputs distance from ray origin to intersection point in [outDistance].
 bool RayVsAABB(const Ray& ray, const AABB& box, float& outDistance);
 
+//Return true if the ray hits any of the triangles in the model. Stops checking when a hit is detected.
+bool RayVsModel(const Ray& ray, 
+    const std::vector<RawModel::Vertex>& modelVertices,
+    const std::vector<unsigned int>& modelIndices);
+//Return true if the ray hits any of the triangles in the model.
+//Also returns the position of the intersection point. Will loop through all the whole model indices.
+bool RayVsModel(const Ray& ray,
+    const std::vector<RawModel::Vertex>& modelVertices,
+    const std::vector<unsigned int>& modelIndices,
+    glm::vec3& outHitPosition);
+//Return true if the ray hits any of the triangles in the model.
+//Also returns the distance from the ray origin to the closest 
+//intersection point, and the barycentric u,v-coordinates. Will loop through all the whole model indices.
+bool RayVsModel(const Ray& ray,
+    const std::vector<RawModel::Vertex>& modelVertices,
+    const std::vector<unsigned int>& modelIndices,
+    float& outDistance,
+    float& outUCoord,
+    float& outVCoord);
+
+//Return true if the boxes are intersecting.
 bool AABBVsAABB(const AABB& a, const AABB& b);
+
 }
 
 #endif

src/Engine/Core/Collision.cpp

@@ -1,6 +1,7 @@
+#include <algorithm>
+
 #include "Core/Collision.h"
 #include "Engine/GLM.h"
-#include <algorithm>
 
 namespace Collision
 {
@@ -74,4 +75,76 @@ bool AABBVsAABB(const AABB& a, const AABB& b)
     return (abs(aCenter[1] - bCenter[1]) <= (aHSize[1] + bHSize[1]));
 }
 
+bool RayVsModel(const Ray& ray, 
+    const std::vector<RawModel::Vertex>& modelVertices, 
+    const std::vector<unsigned int>& modelIndices)
+{
+    for (int i = 0; i < modelIndices.size(); ++i) {
+        glm::vec3 v0 = modelVertices[modelIndices[i]].Position;
+        glm::vec3 e1 = modelVertices[modelIndices[++i]].Position - v0;		//v1 - v0
+        glm::vec3 e2 = modelVertices[modelIndices[++i]].Position - v0;		//v2 - v0
+        glm::vec3 m = ray.Origin - v0;
+        glm::vec3 MxE1 = glm::cross(m, e1);
+        glm::vec3 DxE2 = glm::cross(ray.Direction, e2);
+        float DetInv = 1.0f / glm::dot(e1, DxE2);
+        float u = glm::dot(m, DxE2) * DetInv;
+        float v = glm::dot(ray.Direction, MxE1) * DetInv;
+        if (u < 0 && v < 0 && 1 < u + v) {
+            continue;
+        }
+        //Here, u and v are positive, u+v <= 1, and if distance is positive - triangle is hit.
+        if (0 <= glm::dot(e2, MxE1) * DetInv) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool RayVsModel(const Ray& ray,
+    const std::vector<RawModel::Vertex>& modelVertices,
+    const std::vector<unsigned int>& modelIndices,
+    float& outDistance,
+    float& outUCoord,
+    float& outVCoord)
+{
+    outDistance = INFINITY;
+    bool hit = false;
+    for (int i = 0; i < modelIndices.size(); ++i) {
+        glm::vec3 v0 = modelVertices[modelIndices[i]].Position;
+        glm::vec3 e1 = modelVertices[modelIndices[++i]].Position - v0;		//v1 - v0
+        glm::vec3 e2 = modelVertices[modelIndices[++i]].Position - v0;		//v2 - v0
+        glm::vec3 m = ray.Origin - v0;
+        glm::vec3 MxE1 = glm::cross(m, e1);
+        glm::vec3 DxE2 = glm::cross(ray.Direction, e2);
+        float DetInv = 1.0f / glm::dot(e1, DxE2);
+        float dist = glm::dot(e2, MxE1) * DetInv;
+        if (dist >= outDistance) {
+            continue;
+        }
+        float u = glm::dot(m, DxE2) * DetInv;
+        float v = glm::dot(ray.Direction, MxE1) * DetInv;
+        //If u and v are positive, u+v <= 1, dist is positive, and less than closest.
+        if (0 <= u && 0 <= v && u + v <= 1 && 0 <= dist) {
+            outDistance = dist;
+            outUCoord = u;
+            outVCoord = v;
+            hit = true;
+        }
+    }
+    return hit;
+}
+
+bool RayVsModel(const Ray& ray,
+    const std::vector<RawModel::Vertex>& modelVertices,
+    const std::vector<unsigned int>& modelIndices,
+    glm::vec3& outHitPosition)
+{
+    float u;
+    float v;
+    float dist;
+    bool hit = RayVsModel(ray, modelVertices, modelIndices, dist, u, v);
+    outHitPosition = ray.Origin + dist * ray.Direction;
+    return hit;
+}
+
 }

src/Engine/Core/OctTree.cpp

@@ -300,7 +300,7 @@ void OctTree::OctChild::AddDynamicObject(const AABB& box)
         }
     } else {
         //Since it hasn't been added yet to the real object list, the index is after the last =size.
-        m_DynamicObjIndices.push_back(m_DynamicObjectsRef.size());
+        m_DynamicObjIndices.push_back((int)m_DynamicObjectsRef.size());
     }
 }
 
@@ -312,7 +312,7 @@ void OctTree::OctChild::AddStaticObject(const AABB& box)
         }
     } else {
         //Since it hasn't been added yet to the real object list, the index is after the last =size.
-        m_StaticObjIndices.push_back(m_StaticObjectsRef.size());
+        m_StaticObjIndices.push_back((int)m_StaticObjectsRef.size());
     }
 }
 
@@ -323,7 +323,7 @@ void OctTree::OctChild::BoxesInSameRegion(const AABB& box, std::vector<AABB>& ou
             m_Children[i]->BoxesInSameRegion(box, outBoxes);
         }
     } else {
-        int startIndex = outBoxes.size();
+        size_t startIndex = outBoxes.size();
         int numDuplicates = 0;
         outBoxes.resize(outBoxes.size() + m_StaticObjIndices.size() + m_DynamicObjIndices.size());
         for (size_t i = 0; i < m_StaticObjIndices.size(); ++i){

src/Tests/OctTreeTest.cpp

@@ -5,6 +5,9 @@ using boost::unit_test_framework::test_case;
 #include "OctTreeTestGameClass.h"
 //HACK! Needed for white box testing
 //else we would have to "open up" the octTree class more with get/sets, public methods, etc. which is not good encapsulation-wise
+//#include "Engine/Core/OctTree.h"
+#include "Engine/Core/Ray.h"
+#include "OldOctTree.h"
 //friend class and refactoringIntoNewClass is some extra work and needs to be updated when the original class is updated, and can contain bugs that
 //isnt in the original class
 //Reflection-inspection seems to be only available for C#
@@ -65,4 +68,132 @@ BOOST_AUTO_TEST_CASE(octSameRegionTest)
     BOOST_CHECK_CLOSE_FRACTION(box.HalfSize().z, firstQuadrant.HalfSize().z, 0.00001f);
 }
 
+const int LEVEL_BOUNDS = 500;
+const int MAXSIZE = 50;
+const int BOXES = 400;
+const int NUM_DYNAMICS = 0;
+const int NUM_STATICS = BOXES - NUM_DYNAMICS;
+const int SEED = 6548;
+const int TEST_FRAMES = 300;
+const int NUM_FUNCTION_LOOPS = 25;
+const int TESTS = 0;                //10
+
+template<typename Tree>
+void RegionTest(Tree& tree)
+{
+    AABB aabb;
+    aabb.CreateFromCenter(glm::vec3(rand() % LEVEL_BOUNDS, rand() % LEVEL_BOUNDS, rand() % LEVEL_BOUNDS),
+        glm::vec3(rand() % MAXSIZE, rand() % MAXSIZE, rand() % MAXSIZE));
+    std::vector<AABB> outVec;
+    tree.BoxesInSameRegion(aabb, outVec);
+}
+
+template<typename Tree>
+void RayTest(Tree& tree)
+{
+    Tree::Output data;
+    glm::vec3 rayStart = glm::vec3(rand() % LEVEL_BOUNDS, rand() % LEVEL_BOUNDS, rand() % LEVEL_BOUNDS);
+    glm::vec3 rayEnd = glm::vec3(rand() % LEVEL_BOUNDS, rand() % LEVEL_BOUNDS, rand() % LEVEL_BOUNDS);
+    tree.RayCollides({ rayStart , glm::normalize(rayEnd - rayStart) }, data);
+}
+
+template<typename Tree>
+void BoxTest(Tree& tree)
+{
+    AABB outBox;
+    AABB aabb;
+    aabb.CreateFromCenter(glm::vec3(rand() % LEVEL_BOUNDS, rand() % LEVEL_BOUNDS, rand() % LEVEL_BOUNDS),
+        glm::vec3(rand() % MAXSIZE, rand() % MAXSIZE, rand() % MAXSIZE));
+    tree.BoxCollides(aabb, outBox);
+}
+
+template<typename Tree>
+void NopTest(Tree& tree)
+{
+
+}
+
+template<typename Tree, typename TestFunction>
+void TestLoop(TestFunction xTest)
+{
+    srand(SEED);
+    glm::vec3 mini = glm::vec3(0, 0, 0);
+    glm::vec3 maxi = glm::vec3(LEVEL_BOUNDS, LEVEL_BOUNDS, LEVEL_BOUNDS);
+    Tree tree(AABB(mini, maxi), 3);
+    AABB aabb;
+    glm::vec3 center;
+    glm::vec3 size;
+    for (int t = 0; t < TESTS; ++t) {
+        for (int i = 0; i < NUM_STATICS; ++i) {
+            center = glm::vec3(rand() % LEVEL_BOUNDS, rand() % LEVEL_BOUNDS, rand() % LEVEL_BOUNDS);
+            size = glm::vec3(rand() % MAXSIZE, rand() % MAXSIZE, rand() % MAXSIZE);
+            aabb.CreateFromCenter(center, size);
+            tree.AddStaticObject(aabb);
+        }
+        for (int fr = 0; fr < TEST_FRAMES; ++fr) {
+            for (int i = 0; i < NUM_DYNAMICS; ++i) {
+                center = glm::vec3(rand() % LEVEL_BOUNDS, rand() % LEVEL_BOUNDS, rand() % LEVEL_BOUNDS);
+                size = glm::vec3(rand() % MAXSIZE, rand() % MAXSIZE, rand() % MAXSIZE);
+                aabb.CreateFromCenter(center, size);
+                tree.AddDynamicObject(aabb);
+            }
+
+            for (int fl = 0; fl < NUM_FUNCTION_LOOPS; ++fl) {
+                xTest(tree);
+            }
+
+            tree.ClearDynamicObjects();
+        }
+        tree.ClearObjects();
+    }
+}
+
+BOOST_AUTO_TEST_CASE(octRegionPerfTestWithDuplicates)
+{
+    TestLoop<Old::OctTree>(RegionTest<Old::OctTree>);
+    BOOST_CHECK(true);
+}
+
+BOOST_AUTO_TEST_CASE(octRegionPerfTestNoDuplicates)
+{
+    TestLoop<OctTree>(RegionTest<OctTree>);
+    BOOST_CHECK(true);
+}
+
+BOOST_AUTO_TEST_CASE(octBoxPerfTestWithDuplicates)
+{
+    TestLoop<Old::OctTree>(BoxTest<Old::OctTree>);
+    BOOST_CHECK(true);
+}
+
+BOOST_AUTO_TEST_CASE(octBoxPerfTestNoDuplicates)
+{
+    TestLoop<OctTree>(BoxTest<OctTree>);
+    BOOST_CHECK(true);
+}
+
+BOOST_AUTO_TEST_CASE(octRayPerfTestWithDuplicates)
+{
+    TestLoop<Old::OctTree>(RayTest<Old::OctTree>);
+    BOOST_CHECK(true);
+}
+
+BOOST_AUTO_TEST_CASE(octRayPerfTestNoDuplicates)
+{
+    TestLoop<OctTree>(RayTest<OctTree>);
+    BOOST_CHECK(true);
+}
+
+BOOST_AUTO_TEST_CASE(octNopPerfTestWithDuplicates)
+{
+    TestLoop<Old::OctTree>(NopTest<Old::OctTree>);
+    BOOST_CHECK(true);
+}
+
+BOOST_AUTO_TEST_CASE(octNopPerfTestNoDuplicates)
+{
+    TestLoop<OctTree>(NopTest<OctTree>);
+    BOOST_CHECK(true);
+}
+
 BOOST_AUTO_TEST_SUITE_END()

src/Tests/OldOctTree.cpp

@@ -0,0 +1,328 @@
+#include <vector>
+#include <algorithm>
+#include <bitset>
+
+#include "OldOctTree.h"
+#include "Core/Collision.h"
+#include "Core/World.h"
+#include "Rendering/Camera.h"
+
+namespace Old
+{
+
+namespace
+{
+//To be able to sort nodes based on distance to ray origin.
+struct ChildInfo
+{
+    int Index;
+    float Distance;
+};
+
+bool isFirstLower(const ChildInfo& first, const ChildInfo& second)
+{
+    return first.Distance < second.Distance;
+}
+
+bool isSameBoxProbably(const AABB& first, const AABB& second)
+{
+    const float EPS = 0.0001f;
+    const auto& ma = first.MaxCorner();
+    const auto& mi = first.MinCorner();
+    return (std::abs(ma.x - mi.x) < EPS) &&
+        (std::abs(ma.z - mi.z) < EPS) &&
+        (std::abs(ma.y - mi.y) < EPS);
+}
+
+}
+
+OctTree::OctTree()
+    : OctTree(AABB(), 0)
+{}
+
+OctTree::OctTree(const AABB& octTreeBounds, int subDivisions)
+    : m_Box(octTreeBounds)
+    , m_UpdatedOnce(false)
+{
+    if (subDivisions == 0) {
+        for (OctTree*& c : m_Children) {
+            c = nullptr;
+        }
+    } else {
+        --subDivisions;
+        for (int i = 0; i < 8; ++i) {
+            glm::vec3 minPos, maxPos;
+            const glm::vec3& parentMin = m_Box.MinCorner();
+            const glm::vec3& parentMax = m_Box.MaxCorner();
+            const glm::vec3& parentCenter = m_Box.Center();
+            std::bitset<3> bits(i);
+            //If child is 4,5,6,7.
+            if (bits.test(2)) {
+                minPos.x = parentCenter.x;
+                maxPos.x = parentMax.x;
+            } else {
+                minPos.x = parentMin.x;
+                maxPos.x = parentCenter.x;
+            }
+
+            //If child is 2,3,6,7
+            if (bits.test(1)) {
+                minPos.y = parentCenter.y;
+                maxPos.y = parentMax.y;
+            } else {
+                minPos.y = parentMin.y;
+                maxPos.y = parentCenter.y;
+            }
+            //If child is 1,3,5,7
+            if (bits.test(0)) {
+                minPos.z = parentCenter.z;
+                maxPos.z = parentMax.z;
+            } else {
+                minPos.z = parentMin.z;
+                maxPos.z = parentCenter.z;
+            }
+            m_Children[i] = new OctTree(AABB(minPos, maxPos), subDivisions);
+        }
+    }
+}
+
+OctTree::~OctTree()
+{
+    for (OctTree*& c : m_Children) {
+        if (c != nullptr) {
+            delete c;
+            c = nullptr;
+        }
+    }
+}
+
+void OctTree::Update(float dt, World* world, Camera* cam)
+{
+    AABB aabb;
+    for (ComponentWrapper& c : *world->GetComponents("Collision")) {
+        aabb.CreateFromCenter(c["BoxCenter"], c["BoxSize"]);
+        AddStaticObject(aabb);
+    }
+    const glm::vec4 redCol = glm::vec4(1, 0.2f, 0, 1);
+    const glm::vec4 greenCol = glm::vec4(0.1f, 1.0f, 0.25f, 1);
+    const glm::vec3 boxSize = 0.1f*glm::vec3(1.0f, 1.0f, 1.0f);
+
+    if (!m_UpdatedOnce) {
+        m_BoxID = world->CreateEntity();
+        ComponentWrapper transform = world->AttachComponent(m_BoxID, "Transform");
+        transform["Scale"] = boxSize;
+        ComponentWrapper model = world->AttachComponent(m_BoxID, "Model");
+        model["Resource"] = "Models/Core/UnitBox.obj";
+        m_UpdatedOnce = true;
+    }
+
+    AABB box;
+    auto boxPos = cam->Position() + 1.2f*cam->Forward();
+    box.CreateFromCenter(boxPos, boxSize);
+    ComponentWrapper transform = world->GetComponent(m_BoxID, "Transform");
+    transform["Position"] = boxPos;
+    ComponentWrapper model = world->GetComponent(m_BoxID, "Model");
+    //if (BoxCollides(box, AABB())) {
+    if (Collision::AABBVsAABB(box, aabb)) {
+        cam->SetPosition(m_PrevPos);
+        cam->SetOrientation(m_PrevOri);
+        model["Color"] = greenCol;
+    } else {
+        model["Color"] = redCol;
+    }
+
+    m_PrevPos = cam->Position();
+    m_PrevOri = cam->Orientation();
+    ClearObjects();
+}
+
+bool OctTree::BoxCollides(const AABB& boxToTest, AABB& outBoxIntersected) const
+{
+    if (hasChildren()) {
+        for (int i : childIndicesContainingBox(boxToTest)) {
+            if (m_Children[i]->BoxCollides(boxToTest, outBoxIntersected))
+                return true;
+        }
+    } else {
+        for (const auto& obj : m_StaticObjects) {
+            if (Collision::AABBVsAABB(boxToTest, obj)) {
+                outBoxIntersected = obj;
+                return true;
+            }
+        }
+        for (const auto& obj : m_DynamicObjects) {
+            //If there is a collision and it is not testing against itself.
+            if (!isSameBoxProbably(boxToTest, obj) &&
+                Collision::AABBVsAABB(boxToTest, obj)) {
+                outBoxIntersected = obj;
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+bool OctTree::RayCollides(const Ray& ray, Output& data) const
+{
+    //If the node AABB is missed, everything it contains is missed.
+    if (Collision::RayAABBIntr(ray, m_Box)) {
+        //If the ray shoots the tree, and it is a parent to 8 children :o
+        if (hasChildren()) {
+            //Sort children according to their distance from the ray origin.
+            std::vector<ChildInfo> childInfos;
+            childInfos.reserve(8);
+            for (int i = 0; i < 8; ++i) {
+                childInfos.push_back({ i, glm::distance(ray.Origin, m_Children[i]->m_Box.Center()) });
+            }
+            std::sort(childInfos.begin(), childInfos.end(), isFirstLower);
+            //Loop through the children, starting with the one closest to the ray origin. I.e the first to be hit.
+            for (const ChildInfo& info : childInfos) {
+                if (m_Children[info.Index]->RayCollides(ray, data)) {
+                    return true;
+                }
+            }
+        } else {
+            //Check against boxes in the node.
+            float minDist = INFINITY;
+            bool intersected = false;
+            for (const auto& obj : m_StaticObjects) {
+                float dist;
+                if (Collision::RayVsAABB(ray, obj, dist)) {
+                    minDist = std::min(dist, minDist);
+                    intersected = true;
+                }
+            }
+            for (const auto& obj : m_DynamicObjects) {
+                float dist;
+                if (Collision::RayVsAABB(ray, obj, dist)) {
+                    minDist = std::min(dist, minDist);
+                    intersected = true;
+                }
+            }
+
+            data.CollideDistance = minDist;
+            return intersected;
+        }
+    }
+    return false;
+}
+
+
+void OctTree::AddDynamicObject(const AABB& box)
+{
+    if (hasChildren()) {
+        for (auto i : childIndicesContainingBox(box)) {
+            m_Children[i]->AddDynamicObject(box);
+        }
+    } else {
+        m_DynamicObjects.push_back(box);
+    }
+}
+
+void OctTree::AddStaticObject(const AABB& box)
+{
+    if (hasChildren()) {
+        for (auto i : childIndicesContainingBox(box)) {
+            m_Children[i]->AddStaticObject(box);
+        }
+    } else {
+        m_StaticObjects.push_back(box);
+    }
+}
+
+void OctTree::BoxesInSameRegion(const AABB& box, std::vector<AABB>& outBoxes) const
+{
+    if (hasChildren()) {
+        for (auto i : childIndicesContainingBox(box)) {
+            m_Children[i]->BoxesInSameRegion(box, outBoxes);
+        }
+    } else {
+        outBoxes.insert(outBoxes.end(), m_StaticObjects.begin(), m_StaticObjects.end());
+        outBoxes.insert(outBoxes.end(), m_DynamicObjects.begin(), m_DynamicObjects.end());
+    }
+}
+
+void OctTree::ClearObjects()
+{
+    if (hasChildren()) {
+        for (OctTree*& c : m_Children) {
+            c->ClearObjects();
+        }
+    } else {
+        m_DynamicObjects.clear();
+        m_StaticObjects.clear();
+    }
+}
+
+void OctTree::ClearDynamicObjects()
+{
+    if (hasChildren()) {
+        for (OctTree*& c : m_Children) {
+            c->ClearObjects();
+        }
+    } else {
+        m_DynamicObjects.clear();
+    }
+}
+
+//:     3        7 
+//:
+//:        2         6 
+//:                           |
+//:     1        5          \ y
+//:                          z 
+//:        0         4        0  x-->
+//
+// child: 0 1 2 3 4 5 6 7
+//    x : - - - - + + + +
+//    y : - - + + - - + +
+//    z : - + - + - + - +
+int OctTree::childIndexContainingPoint(const glm::vec3& point) const
+{
+    const glm::vec3& c = m_Box.Center();
+    return (1 << 2) * (point.x >= c.x) | (1 << 1) * (point.y >= c.y) | (point.z >= c.z);
+}
+
+std::vector<int> OctTree::childIndicesContainingBox(const AABB& box) const
+{
+    int minInd = childIndexContainingPoint(box.MinCorner());
+    int maxInd = childIndexContainingPoint(box.MaxCorner());
+    //Because of the predictable ordering of the child indices, 
+    //the number of bits set when xor:ing the indices will determine the number of children containing the box.
+    std::bitset<3> bits(minInd ^ maxInd);
+    switch (bits.count()) {
+        //Box contained completely in one child.
+    case 0:
+        return{ minInd };
+        //Two children.
+    case 1:
+        return{ minInd, maxInd };
+        //Four children.
+    case 2:
+    {
+        std::vector<int> ret;
+        //Bit-hax to calculate the correct 4 children containing the box.
+        //This works because of the childrens index determine what part of 
+        //the dimensions they are responsible for (which octant).
+        bits.flip();
+        //At this point the bits necessarily have exactly one bit set.
+        for (int c = 0; c < 8; ++c) {
+            //If the child index have the same bit set as the bits, add box to it.
+            if (bits.to_ulong() & c) {
+                ret.push_back(c);
+            }
+        }
+        return ret;
+    }
+    case 3:                         //Eight children.
+        return{ 0,1,2,3,4,5,6,7 };
+    default:
+        return std::vector<int>();
+    }
+}
+
+inline bool OctTree::hasChildren() const
+{
+    return m_Children[0] != nullptr;
+}
+}

src/Tests/OldOctTree.h

@@ -0,0 +1,66 @@
+#ifndef OldOctTree_h__
+#define OldOctTree_h__
+
+#include "Core/AABB.h"
+
+struct Ray;
+class World;
+class Camera;
+
+namespace Old
+{
+
+class OctTree
+{
+public:
+    struct Output
+    {
+        float CollideDistance;
+    };
+    OctTree();
+    ~OctTree();
+    //For the root OctTree, [octTreeBounds] should be a box containing the entire level.
+    OctTree(const AABB& octTreeBounds, int subDivisions);
+
+    //We should only ever need one OctTree in the game, and it should not need to be copied.
+    //Define these if the OctTree suddenly needs to be copied, think of the children OctTree* ptrs. 
+    OctTree(const OctTree& other) = delete;
+    OctTree(const OctTree&& other) = delete;
+    OctTree& operator= (const OctTree& other) = delete;
+
+    void AddDynamicObject(const AABB& box);
+    void AddStaticObject(const AABB& box);
+
+    void BoxesInSameRegion(const AABB& box, std::vector<AABB>& outBoxes) const;
+
+    void ClearObjects();
+    void ClearDynamicObjects();
+
+    //Collision test function.
+    void Update(float dt, World* world, Camera* cam);
+    //Returns true if the ray collides with something in the tree. Result is written to [data].
+    bool RayCollides(const Ray& ray, Output& data) const;
+    //Returns true if the box collides with something in the tree. 
+    //On collision with a box, that box is written to [outBoxIntersected].
+    //Note: More efficient than calling BoxesInSameRegion from outside and testing there.
+    bool BoxCollides(const AABB& boxToTest, AABB& outBoxIntersected) const;
+
+private:
+    OctTree* m_Children[8];
+    std::vector<AABB> m_StaticObjects;
+    std::vector<AABB> m_DynamicObjects;
+    AABB m_Box;
+
+    bool m_UpdatedOnce;
+    unsigned int m_BoxID;
+    glm::vec3 m_PrevPos;
+    glm::quat m_PrevOri;
+
+    inline bool hasChildren() const;
+    int childIndexContainingPoint(const glm::vec3& point) const;
+    std::vector<int> childIndicesContainingBox(const AABB& box) const;
+};
+
+}
+
+#endif