|
|
/*
|
|
|
Quirky Quad Trees Part #1 - Static Quad Tree Implementation
|
|
|
"War... huh... What is it good for? Absolutely nothin..." - javidx9
|
|
|
|
|
|
License (OLC-3)
|
|
|
~~~~~~~~~~~~~~~
|
|
|
Copyright 2018 - 2022 OneLoneCoder.com
|
|
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
|
modification, are permitted provided that the following conditions
|
|
|
are met:
|
|
|
|
|
|
1. Redistributions or derivations of source code must retain the above
|
|
|
copyright notice, this list of conditions and the following disclaimer.
|
|
|
|
|
|
2. Redistributions or derivative works in binary form must reproduce
|
|
|
the above copyright notice. This list of conditions and the following
|
|
|
disclaimer must be reproduced in the documentation and/or other
|
|
|
materials provided with the distribution.
|
|
|
|
|
|
3. Neither the name of the copyright holder nor the names of its
|
|
|
contributors may be used to endorse or promote products derived
|
|
|
from this software without specific prior written permission.
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
Video:
|
|
|
~~~~~~
|
|
|
https://youtu.be/ASAowY6yJII
|
|
|
|
|
|
Pan & Zoom with middle mouse, TAB to switch between methods
|
|
|
|
|
|
Links
|
|
|
~~~~~
|
|
|
YouTube: https://www.youtube.com/javidx9
|
|
|
https://www.youtube.com/javidx9extra
|
|
|
Discord: https://discord.gg/WhwHUMV
|
|
|
Twitter: https://www.twitter.com/javidx9
|
|
|
Twitch: https://www.twitch.tv/javidx9
|
|
|
GitHub: https://www.github.com/onelonecoder
|
|
|
Homepage: https://www.onelonecoder.com
|
|
|
|
|
|
Author
|
|
|
~~~~~~
|
|
|
David Barr, aka javidx9, <EFBFBD>OneLoneCoder 2019, 2020, 2021, 2022
|
|
|
*/
|
|
|
|
|
|
|
|
|
#define OLC_PGE_APPLICATION
|
|
|
#include "olcPixelGameEngine.h"
|
|
|
|
|
|
#define OLC_PGEX_TRANSFORMEDVIEW
|
|
|
#include "olcPGEX_TransformedView.h"
|
|
|
|
|
|
namespace olc
|
|
|
{
|
|
|
struct rect
|
|
|
{
|
|
|
olc::vf2d pos;
|
|
|
olc::vf2d size;
|
|
|
|
|
|
rect(const olc::vf2d& p = { 0.0f, 0.0f }, const olc::vf2d& s = { 1.0f, 1.0f }) : pos(p), size(s)
|
|
|
{
|
|
|
|
|
|
}
|
|
|
|
|
|
constexpr bool contains(const olc::vf2d& p) const
|
|
|
{
|
|
|
return !(p.x < pos.x || p.y < pos.y || p.x >= (pos.x + size.x) || p.y >= (pos.y + size.y));
|
|
|
}
|
|
|
|
|
|
constexpr bool contains(const olc::rect& r) const
|
|
|
{
|
|
|
return (r.pos.x >= pos.x) && (r.pos.x + r.size.x < pos.x + size.x) &&
|
|
|
(r.pos.y >= pos.y) && (r.pos.y + r.size.y < pos.y + size.y);
|
|
|
}
|
|
|
|
|
|
constexpr bool overlaps(const olc::rect& r) const
|
|
|
{
|
|
|
return (pos.x < r.pos.x + r.size.x && pos.x + size.x >= r.pos.x && pos.y < r.pos.y + r.size.y && pos.y + size.y >= r.pos.y);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
// Constrain depth of Quad Tree. Since its floating point, it could in principle sub-divide for
|
|
|
// a very long time, consuming far more time and memory than is sensible
|
|
|
constexpr size_t MAX_DEPTH = 8;
|
|
|
|
|
|
|
|
|
template <typename OBJECT_TYPE>
|
|
|
class StaticQuadTree
|
|
|
{
|
|
|
public:
|
|
|
StaticQuadTree(const olc::rect& size = { {0.0f, 0.0f}, {100.0f, 100.0f} }, const size_t nDepth = 0)
|
|
|
{
|
|
|
m_depth = nDepth;
|
|
|
resize(size);
|
|
|
}
|
|
|
|
|
|
// Force area change on Tree, invalidates this and all child layers
|
|
|
void resize(const olc::rect& rArea)
|
|
|
{
|
|
|
// Erase this layer
|
|
|
clear();
|
|
|
|
|
|
// Recalculate area of children
|
|
|
m_rect = rArea;
|
|
|
olc::vf2d vChildSize = m_rect.size / 2.0f;
|
|
|
|
|
|
// Cache child areas local to this layer
|
|
|
m_rChild =
|
|
|
{
|
|
|
// Top Left
|
|
|
olc::rect(m_rect.pos, vChildSize),
|
|
|
// Top Right
|
|
|
olc::rect({m_rect.pos.x + vChildSize.x, m_rect.pos.y}, vChildSize),
|
|
|
// Bottom Left
|
|
|
olc::rect({m_rect.pos.x, m_rect.pos.y + vChildSize.y}, vChildSize),
|
|
|
// Bottom Right
|
|
|
olc::rect(m_rect.pos + vChildSize, vChildSize)
|
|
|
};
|
|
|
|
|
|
}
|
|
|
|
|
|
// Clears the contents of this layer, and all child layers
|
|
|
void clear()
|
|
|
{
|
|
|
// Erase any items stored in this layer
|
|
|
m_pItems.clear();
|
|
|
|
|
|
// Iterate through children, erase them too
|
|
|
for (int i = 0; i < 4; i++)
|
|
|
{
|
|
|
if (m_pChild[i])
|
|
|
m_pChild[i]->clear();
|
|
|
m_pChild[i].reset();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Returns a count of how many items are stored in this layer, and all children of this layer
|
|
|
size_t size() const
|
|
|
{
|
|
|
size_t nCount = m_pItems.size();
|
|
|
for (int i = 0; i < 4; i++)
|
|
|
if (m_pChild[i]) nCount += m_pChild[i]->size();
|
|
|
return nCount;
|
|
|
}
|
|
|
|
|
|
// Inserts an object into this layer (or appropriate child layer), given the area the item occupies
|
|
|
void insert(const OBJECT_TYPE& item, const olc::rect& itemsize)
|
|
|
{
|
|
|
// Check each child
|
|
|
for (int i = 0; i < 4; i++)
|
|
|
{
|
|
|
// If the child can wholly contain the item being inserted
|
|
|
if (m_rChild[i].contains(itemsize))
|
|
|
{
|
|
|
// Have we reached depth limit?
|
|
|
if (m_depth + 1 < MAX_DEPTH)
|
|
|
{
|
|
|
// No, so does child exist?
|
|
|
if (!m_pChild[i])
|
|
|
{
|
|
|
// No, so create it
|
|
|
m_pChild[i] = std::make_shared<StaticQuadTree<OBJECT_TYPE>>(m_rChild[i], m_depth + 1);
|
|
|
}
|
|
|
|
|
|
// Yes, so add item to it
|
|
|
m_pChild[i]->insert(item, itemsize);
|
|
|
return;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// It didnt fit, so item must belong to this quad
|
|
|
m_pItems.push_back({ itemsize, item });
|
|
|
}
|
|
|
|
|
|
// Returns a list of objects in the given search area
|
|
|
std::list<OBJECT_TYPE> search(const olc::rect& rArea) const
|
|
|
{
|
|
|
std::list<OBJECT_TYPE> listItems;
|
|
|
search(rArea, listItems);
|
|
|
return listItems;
|
|
|
}
|
|
|
|
|
|
// Returns the objects in the given search area, by adding to supplied list
|
|
|
void search(const olc::rect& rArea, std::list<OBJECT_TYPE>& listItems) const
|
|
|
{
|
|
|
// First, check for items belonging to this area, add them to the list
|
|
|
// if there is overlap
|
|
|
for (const auto& p : m_pItems)
|
|
|
{
|
|
|
if (rArea.overlaps(p.first))
|
|
|
listItems.push_back(p.second);
|
|
|
}
|
|
|
|
|
|
// Second, recurse through children and see if they can
|
|
|
// add to the list
|
|
|
for (int i = 0; i < 4; i++)
|
|
|
{
|
|
|
if (m_pChild[i])
|
|
|
{
|
|
|
// If child is entirely contained within area, recursively
|
|
|
// add all of its children, no need to check boundaries
|
|
|
if (rArea.contains(m_rChild[i]))
|
|
|
m_pChild[i]->items(listItems);
|
|
|
|
|
|
// If child overlaps with search area then checks need
|
|
|
// to be made
|
|
|
else if (m_rChild[i].overlaps(rArea))
|
|
|
m_pChild[i]->search(rArea, listItems);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void items(std::list<OBJECT_TYPE>& listItems) const
|
|
|
{
|
|
|
// No questions asked, just return child items
|
|
|
for (const auto& p : m_pItems)
|
|
|
listItems.push_back(p.second);
|
|
|
|
|
|
// Now add children of this layer's items
|
|
|
for (int i = 0; i < 4; i++)
|
|
|
if (m_pChild[i]) m_pChild[i]->items(listItems);
|
|
|
}
|
|
|
|
|
|
|
|
|
std::list<OBJECT_TYPE> items() const
|
|
|
{
|
|
|
// No questions asked, just return child items
|
|
|
std::list<OBJECT_TYPE> listItems;
|
|
|
items(listItems);
|
|
|
return listItems;
|
|
|
}
|
|
|
|
|
|
// Returns area of this layer
|
|
|
const olc::rect& area()
|
|
|
{
|
|
|
return m_rect;
|
|
|
}
|
|
|
|
|
|
|
|
|
protected:
|
|
|
// Depth of this StaticQuadTree layer
|
|
|
size_t m_depth = 0;
|
|
|
|
|
|
// Area of this StaticQuadTree
|
|
|
olc::rect m_rect;
|
|
|
|
|
|
// 4 child areas of this StaticQuadTree
|
|
|
std::array<olc::rect, 4> m_rChild{};
|
|
|
|
|
|
// 4 potential children of this StaticQuadTree
|
|
|
std::array<std::shared_ptr<StaticQuadTree<OBJECT_TYPE>>, 4> m_pChild{};
|
|
|
|
|
|
// Items which belong to this StaticQuadTree
|
|
|
std::vector<std::pair<olc::rect, OBJECT_TYPE>> m_pItems;
|
|
|
};
|
|
|
|
|
|
|
|
|
template <typename OBJECT_TYPE>
|
|
|
class StaticQuadTreeContainer
|
|
|
{
|
|
|
// Using a std::list as we dont want pointers to be invalidated to objects stored in the
|
|
|
// tree should the contents of the tree change
|
|
|
using QuadTreeContainer = std::list<OBJECT_TYPE>;
|
|
|
|
|
|
protected:
|
|
|
// The actual container
|
|
|
QuadTreeContainer m_allItems;
|
|
|
|
|
|
// Use our StaticQuadTree to store "pointers" instead of objects - this reduces
|
|
|
// overheads when moving or copying objects
|
|
|
StaticQuadTree<typename QuadTreeContainer::iterator> root;
|
|
|
|
|
|
public:
|
|
|
StaticQuadTreeContainer(const olc::rect& size = { {0.0f, 0.0f}, { 100.0f, 100.0f } }, const size_t nDepth = 0) : root(size, nDepth)
|
|
|
{
|
|
|
|
|
|
}
|
|
|
|
|
|
// Sets the spatial coverage area of the quadtree
|
|
|
// Invalidates tree
|
|
|
void resize(const olc::rect& rArea)
|
|
|
{
|
|
|
root.resize(rArea);
|
|
|
}
|
|
|
|
|
|
// Returns number of items within tree
|
|
|
size_t size() const
|
|
|
{
|
|
|
return m_allItems.size();
|
|
|
}
|
|
|
|
|
|
// Returns true if tree is empty
|
|
|
bool empty() const
|
|
|
{
|
|
|
return m_allItems.empty();
|
|
|
}
|
|
|
|
|
|
// Removes all items from tree
|
|
|
void clear()
|
|
|
{
|
|
|
root.clear();
|
|
|
m_allItems.clear();
|
|
|
}
|
|
|
|
|
|
|
|
|
// Convenience functions for ranged for loop
|
|
|
typename QuadTreeContainer::iterator begin()
|
|
|
{
|
|
|
return m_allItems.begin();
|
|
|
}
|
|
|
|
|
|
typename QuadTreeContainer::iterator end()
|
|
|
{
|
|
|
return m_allItems.end();
|
|
|
}
|
|
|
|
|
|
typename QuadTreeContainer::const_iterator cbegin()
|
|
|
{
|
|
|
return m_allItems.cbegin();
|
|
|
}
|
|
|
|
|
|
typename QuadTreeContainer::const_iterator cend()
|
|
|
{
|
|
|
return m_allItems.cend();
|
|
|
}
|
|
|
|
|
|
|
|
|
// Insert item into tree in specified area
|
|
|
void insert(const OBJECT_TYPE& item, const olc::rect& itemsize)
|
|
|
{
|
|
|
// Item is stored in container
|
|
|
m_allItems.push_back(item);
|
|
|
|
|
|
// Pointer/Area of item is stored in quad tree
|
|
|
root.insert(std::prev(m_allItems.end()), itemsize);
|
|
|
}
|
|
|
|
|
|
// Returns a std::list of pointers to items within the search area
|
|
|
std::list<typename QuadTreeContainer::iterator> search(const olc::rect& rArea) const
|
|
|
{
|
|
|
std::list<typename QuadTreeContainer::iterator> listItemPointers;
|
|
|
root.search(rArea, listItemPointers);
|
|
|
return listItemPointers;
|
|
|
}
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// The Example!
|
|
|
class Example_StaticQuadTree : public olc::PixelGameEngine
|
|
|
{
|
|
|
public:
|
|
|
Example_StaticQuadTree()
|
|
|
{
|
|
|
sAppName = "Static QuadTree";
|
|
|
}
|
|
|
|
|
|
protected:
|
|
|
olc::TransformedView tv;
|
|
|
|
|
|
// An example object of something in 2D space
|
|
|
struct SomeObjectWithArea
|
|
|
{
|
|
|
olc::vf2d vPos;
|
|
|
olc::vf2d vVel;
|
|
|
olc::vf2d vSize;
|
|
|
olc::Pixel colour;
|
|
|
};
|
|
|
|
|
|
// A regular list of the objects
|
|
|
std::list<SomeObjectWithArea> vecObjects;
|
|
|
|
|
|
// An equivalent quad tree of the objects
|
|
|
StaticQuadTreeContainer<SomeObjectWithArea> treeObjects;
|
|
|
|
|
|
// The "length" of one side of the "world" the objects reside in
|
|
|
float fArea = 100000.0f;
|
|
|
|
|
|
bool bUseQuadTree = true;
|
|
|
|
|
|
public:
|
|
|
bool OnUserCreate() override
|
|
|
{
|
|
|
// Transform View - enables Pan & Zoom
|
|
|
tv.Initialise({ ScreenWidth(), ScreenHeight() });
|
|
|
|
|
|
// Create the tree, and size it to the world
|
|
|
treeObjects.resize(olc::rect({ 0.0f, 0.0f }, { fArea, fArea }));
|
|
|
|
|
|
|
|
|
// Dirty random float generator
|
|
|
auto rand_float = [](const float a, const float b)
|
|
|
{
|
|
|
return float(rand()) / float(RAND_MAX) * (b - a) + a;
|
|
|
};
|
|
|
|
|
|
|
|
|
// Create 1,000,000 objects, push into both containers (so 2,000,000 I suppose :P )
|
|
|
for (int i = 0; i < 1000000; i++)
|
|
|
{
|
|
|
SomeObjectWithArea ob;
|
|
|
ob.vPos = { rand_float(0.0f, fArea), rand_float(0.0f, fArea) };
|
|
|
ob.vSize = { rand_float(0.1f, 100.0f), rand_float(0.1f, 100.0f) };
|
|
|
ob.colour = olc::Pixel(rand() % 256, rand() % 256, rand() % 256);
|
|
|
|
|
|
treeObjects.insert(ob, olc::rect(ob.vPos, ob.vSize));
|
|
|
vecObjects.push_back(ob);
|
|
|
}
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool OnUserUpdate(float fElapsedTime) override
|
|
|
{
|
|
|
// Tab switches between modes
|
|
|
if (GetKey(olc::Key::TAB).bPressed)
|
|
|
bUseQuadTree = !bUseQuadTree;
|
|
|
|
|
|
tv.HandlePanAndZoom();
|
|
|
|
|
|
// Get rectangle that equates to screen in world space
|
|
|
olc::rect rScreen = { tv.GetWorldTL(), tv.GetWorldBR() - tv.GetWorldTL() };
|
|
|
size_t nObjectCount = 0;
|
|
|
|
|
|
if (bUseQuadTree)
|
|
|
{
|
|
|
// QUAD TREE MODE
|
|
|
auto tpStart = std::chrono::system_clock::now();
|
|
|
|
|
|
// Use search function to return list of pointers to objects in that area
|
|
|
for (const auto& object : treeObjects.search(rScreen))
|
|
|
{
|
|
|
tv.FillRectDecal(object->vPos, object->vSize, object->colour);
|
|
|
nObjectCount++;
|
|
|
}
|
|
|
std::chrono::duration<float> duration = std::chrono::system_clock::now() - tpStart;
|
|
|
|
|
|
|
|
|
std::string sOutput = "Quadtree " + std::to_string(nObjectCount) + "/" + std::to_string(vecObjects.size()) + " in " + std::to_string(duration.count());
|
|
|
DrawStringDecal({ 4, 4 }, sOutput, olc::BLACK, { 4.0f, 8.0f });
|
|
|
DrawStringDecal({ 2, 2 }, sOutput, olc::WHITE, { 4.0f, 8.0f });
|
|
|
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
// LINEAR SEARCH MODE
|
|
|
auto tpStart = std::chrono::system_clock::now();
|
|
|
|
|
|
// Blindly check all objects to see if they overlap with screen
|
|
|
for (const auto& object : vecObjects)
|
|
|
{
|
|
|
if (rScreen.overlaps({ object.vPos, object.vSize }))
|
|
|
{
|
|
|
tv.FillRectDecal(object.vPos, object.vSize, object.colour);
|
|
|
nObjectCount++;
|
|
|
}
|
|
|
}
|
|
|
std::chrono::duration<float> duration = std::chrono::system_clock::now() - tpStart;
|
|
|
|
|
|
std::string sOutput = "Linear " + std::to_string(nObjectCount) + "/" + std::to_string(vecObjects.size()) + " in " + std::to_string(duration.count());
|
|
|
DrawStringDecal({ 4, 4 }, sOutput, olc::BLACK, { 4.0f, 8.0f });
|
|
|
DrawStringDecal({ 2, 2 }, sOutput, olc::WHITE, { 4.0f, 8.0f });
|
|
|
}
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
};
|
|
|
|
|
|
|
|
|
int main()
|
|
|
{
|
|
|
Example_StaticQuadTree demo;
|
|
|
if (demo.Construct(1280, 960, 1, 1, false, false))
|
|
|
demo.Start();
|
|
|
return 0;
|
|
|
} |
