From 0aad311a3229972bcafb8d52aac0c93d161b97bf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stefan=20M=C3=BCller?= Date: Wed, 27 Aug 2025 17:28:17 +0200 Subject: [PATCH] Fix inconsistent private member naming style --- Quadtree.cs | 174 ++++++++++++++++++++++++++-------------------------- 1 file changed, 87 insertions(+), 87 deletions(-) diff --git a/Quadtree.cs b/Quadtree.cs index db1036a..2acaac9 100644 --- a/Quadtree.cs +++ b/Quadtree.cs @@ -21,31 +21,31 @@ namespace Quadtree /// Maximum number of items in a leaf vertex before it is split, unless the depth of the leaf is greater or /// equal to the maximum tree depth. /// - private readonly int m_maxLeafSize; + private readonly int _maxLeafSize; /// /// Maximum depth of the quadtree, that is the maximum allowed length of the path from the root to a new leaf /// when determining whether a leaf vertex may be split. /// - private readonly int m_maxTreeDepth; + private readonly int _maxTreeDepth; /// /// The list of quadtree vertices. The root vertex is always the first item. The four child vertices of a branch /// are always created together and stored contiguously. /// - private readonly List m_vertices; + private readonly List _vertices; /// /// The list of all items stored in the quadtree. /// - private readonly List> m_items; + private readonly List> _items; - private BoundingBox2 m_rootBoundingBox; + private BoundingBox2 _rootBoundingBox; /// /// The maximum bounding radius of all stored objects, used to inflate the bounding box for queries. /// - private float m_maxObjectRadius; + private float _maxObjectRadius; /// /// Stack of vertex indices with their bounding boxes. It is reused for each query. @@ -59,26 +59,26 @@ namespace Quadtree public Quadtree(int maxLeafSize, int maxTreeDepth) { - m_maxLeafSize = maxLeafSize; - m_maxTreeDepth = maxTreeDepth; - m_vertices = new List() { new QuadtreeVertex(-1, 0) }; - m_items = new List>(); - m_rootBoundingBox = new BoundingBox2(Vector2.Zero, Vector2.Zero); - m_maxObjectRadius = 0f; + _maxLeafSize = maxLeafSize; + _maxTreeDepth = maxTreeDepth; + _vertices = new List() { new QuadtreeVertex(-1, 0) }; + _items = new List>(); + _rootBoundingBox = new BoundingBox2(Vector2.Zero, Vector2.Zero); + _maxObjectRadius = 0f; _queryStack = new Stack(); _vertexStack = new Stack(); } public void Add(IWorldObject obj) { - var itemIndex = m_items.Count; - m_items.Add(new QuadtreeItem(obj)); - if (m_maxObjectRadius < obj.BoundingRadius) + var itemIndex = _items.Count; + _items.Add(new QuadtreeItem(obj)); + if (_maxObjectRadius < obj.BoundingRadius) { - m_maxObjectRadius = obj.BoundingRadius; + _maxObjectRadius = obj.BoundingRadius; } - if (m_vertices.Count == 1 && m_vertices[0].ChildCount < m_maxLeafSize) + if (_vertices.Count == 1 && _vertices[0].ChildCount < _maxLeafSize) { // Before doing any splitting, the initial quadtree root vertex is filled up in order to get a // reasonable guess for what the world space is. This space can be expanded later if that assumption @@ -88,13 +88,13 @@ namespace Quadtree else { // Expands the root until the new world object fits. - while (!m_rootBoundingBox.Contains(obj.Position)) + while (!_rootBoundingBox.Contains(obj.Position)) { ExpandRoot(obj.Position); } - (int leafIndex, int depth, BoundingBox2 bounds) = FindLeaf(0, m_rootBoundingBox, 0, obj.Position); - while (m_vertices[leafIndex].ChildCount >= m_maxLeafSize && depth < m_maxTreeDepth) + (int leafIndex, int depth, BoundingBox2 bounds) = FindLeaf(0, _rootBoundingBox, 0, obj.Position); + while (_vertices[leafIndex].ChildCount >= _maxLeafSize && depth < _maxTreeDepth) { // Splits the vertex and decends into one of the new leaves. SplitLeaf(leafIndex, bounds); @@ -107,28 +107,28 @@ namespace Quadtree public bool Remove(IWorldObject obj) { // Finds the leaf that should contain the world object. - (int leafIndex, _, _) = FindLeaf(0, m_rootBoundingBox, 0, obj.Position); + (int leafIndex, _, _) = FindLeaf(0, _rootBoundingBox, 0, obj.Position); // Tries to find the item of the world object. int previous = -1; - int current = m_vertices[leafIndex].FirstChildIndex; + int current = _vertices[leafIndex].FirstChildIndex; while (current != -1) { - QuadtreeItem item = m_items[current]; + QuadtreeItem item = _items[current]; if (item.WorldObject == obj) { // Removes the found item from the leaf vertex. - QuadtreeVertex leaf = m_vertices[leafIndex]; + QuadtreeVertex leaf = _vertices[leafIndex]; leaf.ChildCount--; if (previous != -1) { - m_items[previous] = new QuadtreeItem(m_items[previous].WorldObject, item.Next); + _items[previous] = new QuadtreeItem(_items[previous].WorldObject, item.Next); } else { leaf.FirstChildIndex = item.Next; } - m_vertices[leafIndex] = leaf; + _vertices[leafIndex] = leaf; // Removes the found item from the item list. RemoveFromItems(current); @@ -146,15 +146,15 @@ namespace Quadtree public void Query(BoundingBox2 box, List resultList) { BoundingBox2 inflatedBox = box; - inflatedBox.Expand(m_maxObjectRadius); + inflatedBox.Expand(_maxObjectRadius); - QueryProcessChildVertex(inflatedBox, box, 0, m_rootBoundingBox, resultList, _queryStack); + QueryProcessChildVertex(inflatedBox, box, 0, _rootBoundingBox, resultList, _queryStack); while (_queryStack.Count > 0) { QuadtreeQuery query = _queryStack.Pop(); - int childIndex = m_vertices[query.VertexIndex].FirstChildIndex; + int childIndex = _vertices[query.VertexIndex].FirstChildIndex; BoundingBox2 halfBounds = new BoundingBox2(query.VertexBounds.Center, query.VertexBounds.Max); Vector2 halfSize = halfBounds.Size; QueryProcessChildVertex(inflatedBox, box, childIndex++, halfBounds, resultList, _queryStack); @@ -172,11 +172,11 @@ namespace Quadtree public void Clear() { - m_vertices.Clear(); - m_vertices.Add(new QuadtreeVertex(-1, 0)); - m_items.Clear(); - m_rootBoundingBox = new BoundingBox2(Vector2.Zero, Vector2.Zero); - m_maxObjectRadius = 0f; + _vertices.Clear(); + _vertices.Add(new QuadtreeVertex(-1, 0)); + _items.Clear(); + _rootBoundingBox = new BoundingBox2(Vector2.Zero, Vector2.Zero); + _maxObjectRadius = 0f; } /// @@ -186,92 +186,92 @@ namespace Quadtree private void ExpandRoot(Vector2 position) { // Finds the new index for the old root vertex and expands the bounds. - QuadtreeVertex newRoot = new QuadtreeVertex(m_vertices.Count, -1); - int oldRootIndex = m_vertices.Count; - if (position.X > m_rootBoundingBox.Max.X) + QuadtreeVertex newRoot = new QuadtreeVertex(_vertices.Count, -1); + int oldRootIndex = _vertices.Count; + if (position.X > _rootBoundingBox.Max.X) { oldRootIndex++; - m_rootBoundingBox.Max.X += m_rootBoundingBox.Max.X - m_rootBoundingBox.Min.X; + _rootBoundingBox.Max.X += _rootBoundingBox.Max.X - _rootBoundingBox.Min.X; } else { - m_rootBoundingBox.Min.X += m_rootBoundingBox.Min.X - m_rootBoundingBox.Max.X; + _rootBoundingBox.Min.X += _rootBoundingBox.Min.X - _rootBoundingBox.Max.X; } - if (position.Y > m_rootBoundingBox.Max.Y) + if (position.Y > _rootBoundingBox.Max.Y) { oldRootIndex += 2; - m_rootBoundingBox.Max.Y += m_rootBoundingBox.Max.Y - m_rootBoundingBox.Min.Y; + _rootBoundingBox.Max.Y += _rootBoundingBox.Max.Y - _rootBoundingBox.Min.Y; } else { - m_rootBoundingBox.Min.Y += m_rootBoundingBox.Min.Y - m_rootBoundingBox.Max.Y; + _rootBoundingBox.Min.Y += _rootBoundingBox.Min.Y - _rootBoundingBox.Max.Y; } // Adds the new leaves and updates the old and new root. for (int i = 0; i < 4; i++) { - if (oldRootIndex == m_vertices.Count) + if (oldRootIndex == _vertices.Count) { - m_vertices.Add(m_vertices[0]); + _vertices.Add(_vertices[0]); } else { - m_vertices.Add(new QuadtreeVertex(-1, 0)); + _vertices.Add(new QuadtreeVertex(-1, 0)); } } - m_vertices[0] = newRoot; + _vertices[0] = newRoot; } private void AddToRootLeaf(int itemIndex) { - Vector2 position = m_items[itemIndex].WorldObject.Position; - if (m_vertices[0].ChildCount == 0) + Vector2 position = _items[itemIndex].WorldObject.Position; + if (_vertices[0].ChildCount == 0) { - m_vertices[0] = new QuadtreeVertex(itemIndex, 1); - m_rootBoundingBox.Min = (m_rootBoundingBox.Max = position); + _vertices[0] = new QuadtreeVertex(itemIndex, 1); + _rootBoundingBox.Min = (_rootBoundingBox.Max = position); } else { - var item = m_items[itemIndex]; - item.Next = m_vertices[0].FirstChildIndex; - m_items[itemIndex] = item; - m_vertices[0] = new QuadtreeVertex(itemIndex, m_vertices[0].ChildCount + 1); - IncludeInBoundingBox(ref m_rootBoundingBox, position); + var item = _items[itemIndex]; + item.Next = _vertices[0].FirstChildIndex; + _items[itemIndex] = item; + _vertices[0] = new QuadtreeVertex(itemIndex, _vertices[0].ChildCount + 1); + IncludeInBoundingBox(ref _rootBoundingBox, position); } } private void AddToLeaf(int leafIndex, int itemIndex) { int next; - if (m_vertices[leafIndex].ChildCount == 0) + if (_vertices[leafIndex].ChildCount == 0) { next = -1; - m_vertices[leafIndex] = new QuadtreeVertex(itemIndex, 1); + _vertices[leafIndex] = new QuadtreeVertex(itemIndex, 1); } else { - next = m_vertices[leafIndex].FirstChildIndex; - m_vertices[leafIndex] = new QuadtreeVertex(itemIndex, m_vertices[leafIndex].ChildCount + 1); + next = _vertices[leafIndex].FirstChildIndex; + _vertices[leafIndex] = new QuadtreeVertex(itemIndex, _vertices[leafIndex].ChildCount + 1); } - m_items[itemIndex] = new QuadtreeItem(m_items[itemIndex].WorldObject, next); + _items[itemIndex] = new QuadtreeItem(_items[itemIndex].WorldObject, next); } private void SplitLeaf(int leafIndex, BoundingBox2 leafBounds) { // Splits the leaf vertex by turning it into a branch and adding four new leaves. - var oldLeaf = m_vertices[leafIndex]; - m_vertices[leafIndex] = new QuadtreeVertex(m_vertices.Count, -1); - m_vertices.Add(new QuadtreeVertex(-1, 0)); - m_vertices.Add(new QuadtreeVertex(-1, 0)); - m_vertices.Add(new QuadtreeVertex(-1, 0)); - m_vertices.Add(new QuadtreeVertex(-1, 0)); + var oldLeaf = _vertices[leafIndex]; + _vertices[leafIndex] = new QuadtreeVertex(_vertices.Count, -1); + _vertices.Add(new QuadtreeVertex(-1, 0)); + _vertices.Add(new QuadtreeVertex(-1, 0)); + _vertices.Add(new QuadtreeVertex(-1, 0)); + _vertices.Add(new QuadtreeVertex(-1, 0)); // Distributes the existing items over the new leaves. var center = leafBounds.Center; int next = oldLeaf.FirstChildIndex; while (next != -1) { - var item = m_items[next]; + var item = _items[next]; int newLeafIndex = FindNextVertex(leafIndex, center, item.WorldObject.Position); AddToLeaf(newLeafIndex, next); next = item.Next; @@ -280,7 +280,7 @@ namespace Quadtree private int FindNextVertex(int vertexIndex, Vector2 boundsCenter, Vector2 position) { - vertexIndex = m_vertices[vertexIndex].FirstChildIndex; + vertexIndex = _vertices[vertexIndex].FirstChildIndex; if (position.X < boundsCenter.X) { vertexIndex++; @@ -295,11 +295,11 @@ namespace Quadtree private (int leafIndex, int depth, BoundingBox2 bounds) FindLeaf(int vertexIndex, BoundingBox2 bounds, int depth, Vector2 position) { - while (m_vertices[vertexIndex].ChildCount == -1) + while (_vertices[vertexIndex].ChildCount == -1) { depth++; var center = bounds.Center; - vertexIndex = m_vertices[vertexIndex].FirstChildIndex; + vertexIndex = _vertices[vertexIndex].FirstChildIndex; if (position.X < center.X) { vertexIndex++; @@ -328,7 +328,7 @@ namespace Quadtree switch (inflatedBox.Intersects(vertexBounds)) { case IntersectionType.Contains: - if (m_vertices[vertexIndex].ChildCount == -1) + if (_vertices[vertexIndex].ChildCount == -1) { // Found contained vertex, appends items of all child vertices. QueryAppendContainedItems(vertexIndex, box, resultList); @@ -340,7 +340,7 @@ namespace Quadtree } break; case IntersectionType.Intersects: - if (m_vertices[vertexIndex].ChildCount == -1) + if (_vertices[vertexIndex].ChildCount == -1) { // Branches the query. stack.Push(new QuadtreeQuery(vertexIndex, vertexBounds)); @@ -361,10 +361,10 @@ namespace Quadtree while (_vertexStack.Count > 0) { int current = _vertexStack.Pop(); - if (m_vertices[current].ChildCount == -1) + if (_vertices[current].ChildCount == -1) { // Branches into all vertices until leaves are found. - int childIndex = m_vertices[current].FirstChildIndex; + int childIndex = _vertices[current].FirstChildIndex; _vertexStack.Push(childIndex++); _vertexStack.Push(childIndex++); _vertexStack.Push(childIndex++); @@ -380,41 +380,41 @@ namespace Quadtree private void QueryAppendContainedLeafItems(int vertexIndex, BoundingBox2 box, List resultList) { - int index = m_vertices[vertexIndex].FirstChildIndex; + int index = _vertices[vertexIndex].FirstChildIndex; while (index != -1) { - IWorldObject obj = m_items[index].WorldObject; + IWorldObject obj = _items[index].WorldObject; if (box.Intersects(obj.BoundingBox) != IntersectionType.Disjoint) { resultList.Add(obj); } - index = m_items[index].Next; + index = _items[index].Next; } } /// /// Removes the found item from the item list. Since the list is being reordered for fast removal, the reference - /// to the relocated item has to be updated because its list index changes from "m_items.Count - 1" to "index". + /// to the relocated item has to be updated because its list index changes from "_items.Count - 1" to "index". /// /// Index of the item to be removed. private void RemoveFromItems(int index) { - m_items.RemoveUnorderedAt(index); - if (index != m_items.Count) + _items.RemoveUnorderedAt(index); + if (index != _items.Count) { - (int leafIndex, _, _) = FindLeaf(0, m_rootBoundingBox, 0, m_items[index].WorldObject.Position); - int current = m_vertices[leafIndex].FirstChildIndex; - if (current == m_items.Count) + (int leafIndex, _, _) = FindLeaf(0, _rootBoundingBox, 0, _items[index].WorldObject.Position); + int current = _vertices[leafIndex].FirstChildIndex; + if (current == _items.Count) { - m_vertices[leafIndex] = new QuadtreeVertex(index, m_vertices[leafIndex].ChildCount); + _vertices[leafIndex] = new QuadtreeVertex(index, _vertices[leafIndex].ChildCount); } else { - while (m_items[current].Next != m_items.Count) + while (_items[current].Next != _items.Count) { - current = m_items[current].Next; + current = _items[current].Next; } - m_items[current] = new QuadtreeItem(m_items[current].WorldObject, index); + _items[current] = new QuadtreeItem(_items[current].WorldObject, index); } } }