493 lines
13 KiB
C++
493 lines
13 KiB
C++
/*
|
||
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, <20>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;
|
||
} |