Increase max query filter types count

This reverts commit acd3f8d879.

src/DotRecast.Core/Collections/CollectionExtensions.cs

@@ -45,5 +45,11 @@ namespace DotRecast.Core.Collections
                 (list[k], list[n]) = (list[n], list[k]);
             }
         }
+
+        public static void AddRange<T>(this IList<T> list, Span<T> span)
+        {
+            foreach (var i in span) 
+                list.Add(i);
+        }
     }
 }

src/DotRecast.Core/Collections/RcSortedQueue.cs

@@ -25,29 +25,14 @@ namespace DotRecast.Core.Collections
 {
     public class RcSortedQueue<T>
     {
-        private sealed class ReverseComparer : IComparer<T>
-        {
-            private readonly Comparison<T> _comparison;
-
-            public ReverseComparer(Comparison<T> comparison)
-            {
-                _comparison = comparison;
-            }
-            
-            public int Compare(T x, T y)
-            {
-                return _comparison(x, y) * -1;
-            }
-        }
-        
         private bool _dirty;
         private readonly List<T> _items;
-        private readonly IComparer<T> _comparer;
+        private readonly Comparison<T> _comparison;
 
         public RcSortedQueue(Comparison<T> comp)
         {
             _items = new List<T>();
-            _comparer = new ReverseComparer(comp);
+            _comparison = (x, y) => comp(x, y) * -1;
         }
 
         public int Count()
@@ -70,7 +55,7 @@ namespace DotRecast.Core.Collections
         {
             if (_dirty)
             {
-                _items.Sort(_comparer); // reverse
+                _items.Sort(_comparison); // reverse
                 _dirty = false;
             }
         }
@@ -103,7 +88,7 @@ namespace DotRecast.Core.Collections
                 return false;
 
             //int idx = _items.BinarySearch(item, _comparer); // don't use this! Because reference types can be reused externally.
-            int idx = _items.FindLastIndex(x => item.Equals(x));
+            int idx = _items.LastIndexOf(item);
             if (0 > idx)
                 return false;
 

src/DotRecast.Core/Numerics/RcVec.cs

@@ -205,7 +205,7 @@ namespace DotRecast.Core.Numerics
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float Dist2DSqr(RcVec3f p, float[] verts, int i)
+        public static float Dist2DSqr(RcVec3f p, Span<float> verts, int i)
         {
             float dx = verts[i] - p.X;
             float dz = verts[i + 2] - p.Z;

src/DotRecast.Detour.Crowd/DtCrowd.cs

@@ -130,7 +130,7 @@ namespace DotRecast.Detour.Crowd
         private readonly DtObstacleAvoidanceParams[] _obstacleQueryParams;
         private readonly DtObstacleAvoidanceQuery _obstacleQuery;
 
-        private DtProximityGrid _grid;
+        private readonly DtProximityGrid _grid;
 
         private int _maxPathResult;
         private readonly RcVec3f _agentPlacementHalfExtents;
@@ -175,6 +175,7 @@ namespace DotRecast.Detour.Crowd
             _agentIdx = new RcAtomicInteger(0);
             _agents = new Dictionary<int, DtCrowdAgent>();
             _activeAgents = new List<DtCrowdAgent>();
+            _grid = new DtProximityGrid(_config.maxAgentRadius * 3);
 
             // The navQuery is mostly used for local searches, no need for large node pool.
             SetNavMesh(nav);
@@ -424,11 +425,13 @@ namespace DotRecast.Detour.Crowd
             // Optimize path topology.
             UpdateTopologyOptimization(agents, dt);
 
+            #region Disabled for performance issues
             // Register agents to proximity grid.
-            BuildProximityGrid(agents);
+            // BuildProximityGrid(agents);
 
             // Get nearby navmesh segments and agents to collide with.
-            BuildNeighbours(agents);
+            // BuildNeighbours(agents);
+            #endregion
 
             // Find next corner to steer to.
             FindCorners(agents, debug);
@@ -565,14 +568,18 @@ namespace DotRecast.Detour.Crowd
             }
         }
 
+        private readonly RcSortedQueue<DtCrowdAgent> UpdateMoveRequest_queue = new RcSortedQueue<DtCrowdAgent>((a1, a2) => a2.targetReplanTime.CompareTo(a1.targetReplanTime));
+        private readonly List<long> UpdateMoveRequest_reqPath = new List<long>();
         private void UpdateMoveRequest(IList<DtCrowdAgent> agents, float dt)
         {
             using var timer = _telemetry.ScopedTimer(DtCrowdTimerLabel.UpdateMoveRequest);
 
-            RcSortedQueue<DtCrowdAgent> queue = new RcSortedQueue<DtCrowdAgent>((a1, a2) => a2.targetReplanTime.CompareTo(a1.targetReplanTime));
+            RcSortedQueue<DtCrowdAgent> queue = UpdateMoveRequest_queue;
+            queue.Clear();
 
             // Fire off new requests.
-            List<long> reqPath = new List<long>();
+            List<long> reqPath = UpdateMoveRequest_reqPath;
+            reqPath.Clear();
             for (var i = 0; i < agents.Count; i++)
             {
                 var ag = agents[i];
@@ -865,7 +872,7 @@ namespace DotRecast.Detour.Crowd
         {
             using var timer = _telemetry.ScopedTimer(DtCrowdTimerLabel.BuildProximityGrid);
 
-            _grid = new DtProximityGrid(_config.maxAgentRadius * 3);
+            _grid.Clear();
 
             for (var i = 0; i < agents.Count; i++)
             {

src/DotRecast.Detour.Crowd/DtCrowdConfig.cs

@@ -25,7 +25,7 @@ namespace DotRecast.Detour.Crowd
 
         public int pathQueueSize = 32; // Max number of path requests in the queue
         public int maxFindPathIterations = 100; // Max number of sliced path finding iterations executed per update (used to handle longer paths and replans)
-        public int maxTargetFindPathIterations = 20; // Max number of sliced path finding iterations executed per agent to find the initial path to target
+        public int maxTargetFindPathIterations = 100; // Max number of sliced path finding iterations executed per agent to find the initial path to target
         public float topologyOptimizationTimeThreshold = 0.5f; // Min time between topology optimizations (in seconds)
         public int checkLookAhead = 10; // The number of polygons from the beginning of the corridor to check to ensure path validity
         public float targetReplanDelay = 1.0f; // Min time between target re-planning (in seconds)

src/DotRecast.Detour.Crowd/DtCrowdConst.cs

@@ -25,7 +25,7 @@ namespace DotRecast.Detour.Crowd
         /// @ingroup crowd
         /// @see dtQueryFilter, dtCrowd::GetFilter() dtCrowd::GetEditableFilter(),
         /// dtCrowdAgentParams::queryFilterType
-        public const int DT_CROWD_MAX_QUERY_FILTER_TYPE = 16;
+        public const int DT_CROWD_MAX_QUERY_FILTER_TYPE = 32;
         
         public const int MAX_ITERS_PER_UPDATE = 100;
         public const int MAX_PATHQUEUE_NODES = 4096;

src/DotRecast.Detour.Crowd/DtPathCorridor.cs

@@ -33,7 +33,7 @@ namespace DotRecast.Detour.Crowd
         private RcVec3f m_pos;
         private RcVec3f m_target;
 
-        private List<long> m_path;
+        private List<long> m_path = new List<long>();
         private int m_npath;
         private int m_maxPath;
 
@@ -89,7 +89,8 @@ namespace DotRecast.Detour.Crowd
         /// @return True if the initialization succeeded.
         public bool Init(int maxPath)
         {
-            m_path = new List<long>(maxPath);
+            if (m_path.Capacity < maxPath)
+                m_path.Capacity = maxPath;
             m_npath = 0;
             m_maxPath = maxPath;
             return true;
@@ -218,7 +219,7 @@ namespace DotRecast.Detour.Crowd
             {
                 if (res.Count > 1 && t > 0.99f)
                 {
-                    m_npath = DtPathUtils.MergeCorridorStartShortcut(ref m_path, m_npath, m_maxPath, res, res.Count);
+                    m_npath = DtPathUtils.MergeCorridorStartShortcut(m_path, m_npath, m_maxPath, res, res.Count);
                 }
             }
         }
@@ -250,7 +251,7 @@ namespace DotRecast.Detour.Crowd
 
             if (status.Succeeded() && res.Count > 0)
             {
-                m_npath = DtPathUtils.MergeCorridorStartShortcut(ref m_path, m_npath, m_maxPath, res, res.Count);
+                m_npath = DtPathUtils.MergeCorridorStartShortcut(m_path, m_npath, m_maxPath, res, res.Count);
                 return true;
             }
 
@@ -276,7 +277,7 @@ namespace DotRecast.Detour.Crowd
             }
 
             // Prune path
-            m_path = m_path.GetRange(npos, m_npath - npos);
+            m_path.RemoveRange(0, npos);
             m_npath -= npos;
 
             refs[0] = prevRef;
@@ -322,7 +323,7 @@ namespace DotRecast.Detour.Crowd
             var status = navquery.MoveAlongSurface(m_path[0], m_pos, npos, filter, out var result, visited, out var nvisited, MAX_VISITED);
             if (status.Succeeded())
             {
-                m_npath = DtPathUtils.MergeCorridorStartMoved(ref m_path, m_npath, m_maxPath, visited, nvisited);
+                m_npath = DtPathUtils.MergeCorridorStartMoved(m_path, m_npath, m_maxPath, visited, nvisited);
 
                 // Adjust the position to stay on top of the navmesh.
                 m_pos = result;
@@ -366,7 +367,7 @@ namespace DotRecast.Detour.Crowd
             var status = navquery.MoveAlongSurface(m_path[^1], m_target, npos, filter, out var result, visited, out nvisited, MAX_VISITED);
             if (status.Succeeded())
             {
-                m_npath = DtPathUtils.MergeCorridorEndMoved(ref m_path, m_npath, m_maxPath, visited, nvisited);
+                m_npath = DtPathUtils.MergeCorridorEndMoved(m_path, m_npath, m_maxPath, visited, nvisited);
 
                 // TODO: should we do that?
                 // Adjust the position to stay on top of the navmesh.
@@ -394,7 +395,11 @@ namespace DotRecast.Detour.Crowd
         public void SetCorridor(RcVec3f target, List<long> path)
         {
             m_target = target;
-            m_path = new List<long>(path);
+            if(path != m_path)
+            {
+                m_path.Clear();
+                m_path.AddRange(path);
+            }
             m_npath = path.Count;
         }
 
@@ -444,7 +449,7 @@ namespace DotRecast.Detour.Crowd
             else if (n < m_npath)
             {
                 // The path is partially usable.
-                m_path = m_path.GetRange(0, n);
+                m_path.RemoveRange(n, m_path.Count - n);
                 m_npath = n;
             }
 

src/DotRecast.Detour.Crowd/DtProximityGrid.cs

@@ -22,6 +22,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using DotRecast.Core.Buffers;
 
 namespace DotRecast.Detour.Crowd
 {
@@ -30,12 +31,14 @@ namespace DotRecast.Detour.Crowd
         private readonly float _cellSize;
         private readonly float _invCellSize;
         private readonly Dictionary<long, List<DtCrowdAgent>> _items;
+        private readonly RcObjectPool<List<DtCrowdAgent>> _listPool;
 
         public DtProximityGrid(float cellSize)
         {
             _cellSize = cellSize;
             _invCellSize = 1.0f / cellSize;
             _items = new Dictionary<long, List<DtCrowdAgent>>();
+            _listPool = new RcObjectPool<List<DtCrowdAgent>>(() => new List<DtCrowdAgent>());
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -57,6 +60,8 @@ namespace DotRecast.Detour.Crowd
 
         public void Clear()
         {
+            foreach (var pair in _items)
+                _listPool.Return(pair.Value);
             _items.Clear();
         }
 
@@ -74,7 +79,8 @@ namespace DotRecast.Detour.Crowd
                     long key = CombineKey(x, y);
                     if (!_items.TryGetValue(key, out var ids))
                     {
-                        ids = new List<DtCrowdAgent>();
+                        ids = _listPool.Get();
+                        ids.Clear();
                         _items.Add(key, ids);
                     }
 

src/DotRecast.Detour/DtConvexConvexIntersections.cs

@@ -27,7 +27,7 @@ namespace DotRecast.Detour
     {
         private const float EPSILON = 0.0001f;
 
-        public static float[] Intersect(Span<float> p, Span<float> q)
+        public static Span<float> Intersect(Span<float> p, Span<float> q, Span<float> buffer)
         {
             int n = p.Length / 3;
             int m = q.Length / 3;
@@ -95,7 +95,7 @@ namespace DotRecast.Detour
                 /* Special case: A & B parallel and separated. */
                 if (parallel && aHB < 0f && bHA < 0f)
                 {
-                    return null;
+                    return Span<float>.Empty;
                 }
                 /* Special case: A & B collinear. */
                 else if (parallel && MathF.Abs(aHB) < EPSILON && MathF.Abs(bHA) < EPSILON)
@@ -168,8 +168,9 @@ namespace DotRecast.Detour
                 return null;
             }
 
-            float[] copied = inters.Slice(0, ii).ToArray();
-            return copied;
+            Span<float> result = buffer.Slice(0, ii);
+            inters.Slice(0, ii).CopyTo(result);
+            return result;
         }
 
         private static int AddVertex(Span<float> inters, int ii, RcVec3f p)

src/DotRecast.Detour/DtNavMeshQuery.cs

@@ -23,6 +23,7 @@ using System.Collections.Generic;
 using DotRecast.Core;
 using DotRecast.Core.Buffers;
 using DotRecast.Core.Numerics;
+using CollectionExtensions = DotRecast.Core.Collections.CollectionExtensions;
 
 namespace DotRecast.Detour
 {
@@ -33,6 +34,8 @@ namespace DotRecast.Detour
     /// @ingroup detour
     public class DtNavMeshQuery
     {
+        public const int MAX_PATH_LENGTH = 256;
+        
         protected readonly DtNavMesh m_nav; //< Pointer to navmesh data.
         protected DtQueryData m_query; //< Sliced query state.
 
@@ -230,6 +233,7 @@ namespace DotRecast.Detour
             IDtQueryFilter filter, IRcRand frand, IDtPolygonByCircleConstraint constraint,
             out long randomRef, out RcVec3f randomPt)
         {
+            const int MAX_VERT_BUFFER_SIZE = 128;
             randomRef = startRef;
             randomPt = centerPos;
 
@@ -262,10 +266,14 @@ namespace DotRecast.Detour
 
             float radiusSqr = maxRadius * maxRadius;
             float areaSum = 0.0f;
-
+            
+            using RcRentedArray<float> polyVertsBuffer = RcRentedArray.Rent<float>(MAX_VERT_BUFFER_SIZE);
+            using RcRentedArray<float> randomPolyVertsBuffer = RcRentedArray.Rent<float>(MAX_VERT_BUFFER_SIZE);
+            using RcRentedArray<float> constrainedVertsBuffer = RcRentedArray.Rent<float>(MAX_VERT_BUFFER_SIZE);
+            
             DtPoly randomPoly = null;
             long randomPolyRef = 0;
-            float[] randomPolyVerts = null;
+            Span<float> randomPolyVerts = Span<float>.Empty;
 
             while (!m_openList.IsEmpty())
             {
@@ -283,14 +291,14 @@ namespace DotRecast.Detour
                 {
                     // Calc area of the polygon.
                     float polyArea = 0.0f;
-                    float[] polyVerts = new float[bestPoly.vertCount * 3];
+                    Span<float> polyVerts = polyVertsBuffer.AsSpan().Slice(0, bestPoly.vertCount * 3);
                     for (int j = 0; j < bestPoly.vertCount; ++j)
                     {
-                        RcArrays.Copy(bestTile.data.verts, bestPoly.verts[j] * 3, polyVerts, j * 3, 3);
+                        RcSpans.Copy(bestTile.data.verts, bestPoly.verts[j] * 3, polyVerts, j * 3, 3);
                     }
 
-                    float[] constrainedVerts = constraint.Apply(polyVerts, centerPos, maxRadius);
-                    if (constrainedVerts != null)
+                    Span<float> constrainedVerts = constraint.Apply(polyVerts, centerPos, maxRadius, constrainedVertsBuffer.AsSpan());
+                    if (!constrainedVerts.IsEmpty)
                     {
                         int vertCount = constrainedVerts.Length / 3;
                         for (int j = 2; j < vertCount; ++j)
@@ -308,7 +316,8 @@ namespace DotRecast.Detour
                         {
                             randomPoly = bestPoly;
                             randomPolyRef = bestRef;
-                            randomPolyVerts = constrainedVerts;
+                            randomPolyVerts = randomPolyVertsBuffer.AsSpan().Slice(0, constrainedVerts.Length);
+                            constrainedVerts.CopyTo(randomPolyVerts);
                         }
                     }
                 }
@@ -882,7 +891,8 @@ namespace DotRecast.Detour
             float lastBestNodeCost = startNode.total;
 
             DtRaycastHit rayHit = new DtRaycastHit();
-            rayHit.path = new List<long>();
+            using var pathRent = RcRentedArray.Rent<long>(MAX_PATH_LENGTH);
+            rayHit.path = pathRent.AsArray();
             while (!m_openList.IsEmpty())
             {
                 // Remove node from open list and put it in closed list.
@@ -1171,7 +1181,8 @@ namespace DotRecast.Detour
             }
 
             var rayHit = new DtRaycastHit();
-            rayHit.path = new List<long>();
+            using var pathRent = RcRentedArray.Rent<long>(MAX_PATH_LENGTH);
+            rayHit.path = pathRent.AsArray();
 
             int iter = 0;
             while (iter < maxIter && !m_openList.IsEmpty())
@@ -1626,20 +1637,20 @@ namespace DotRecast.Detour
             DtStatus stat = DtStatus.DT_STATUS_NOTHING;
 
             // TODO: Should this be callers responsibility?
-            var closestStartPosRes = ClosestPointOnPolyBoundary(path[0], startPos, out var closestStartPos);
-            if (closestStartPosRes.Failed())
-            {
-                return DtStatus.DT_FAILURE | DtStatus.DT_INVALID_PARAM;
-            }
-
-            var closestEndPosRes = ClosestPointOnPolyBoundary(path[pathSize - 1], endPos, out var closestEndPos);
-            if (closestEndPosRes.Failed())
-            {
-                return DtStatus.DT_FAILURE | DtStatus.DT_INVALID_PARAM;
-            }
+            // var closestStartPosRes = ClosestPointOnPolyBoundary(path[0], startPos, out var closestStartPos);
+            // if (closestStartPosRes.Failed())
+            // {
+            //     return DtStatus.DT_FAILURE | DtStatus.DT_INVALID_PARAM;
+            // }
+            //
+            // var closestEndPosRes = ClosestPointOnPolyBoundary(path[pathSize - 1], endPos, out var closestEndPos);
+            // if (closestEndPosRes.Failed())
+            // {
+            //     return DtStatus.DT_FAILURE | DtStatus.DT_INVALID_PARAM;
+            // }
 
             // Add start point.
-            stat = AppendVertex(closestStartPos, DtStraightPathFlags.DT_STRAIGHTPATH_START, path[0], straightPath, ref straightPathCount, maxStraightPath);
+            stat = AppendVertex(startPos, DtStraightPathFlags.DT_STRAIGHTPATH_START, path[0], straightPath, ref straightPathCount, maxStraightPath);
             if (!stat.InProgress())
             {
                 return stat;
@@ -1647,7 +1658,7 @@ namespace DotRecast.Detour
 
             if (pathSize > 1)
             {
-                RcVec3f portalApex = closestStartPos;
+                RcVec3f portalApex = startPos;
                 RcVec3f portalLeft = portalApex;
                 RcVec3f portalRight = portalApex;
                 int apexIndex = 0;
@@ -1676,21 +1687,21 @@ namespace DotRecast.Detour
                         {
                             // Failed to get portal points, in practice this means that path[i+1] is invalid polygon.
                             // Clamp the end point to path[i], and return the path so far.
-                            var cpStatus = ClosestPointOnPolyBoundary(path[i], endPos, out closestEndPos);
-                            if (cpStatus.Failed())
-                            {
-                                return DtStatus.DT_FAILURE | DtStatus.DT_INVALID_PARAM;
-                            }
+                            // var cpStatus = ClosestPointOnPolyBoundary(path[i], endPos, out closestEndPos);
+                            // if (cpStatus.Failed())
+                            // {
+                            //     return DtStatus.DT_FAILURE | DtStatus.DT_INVALID_PARAM;
+                            // }
 
                             // Append portals along the current straight path segment.
                             if ((options & (DtStraightPathOptions.DT_STRAIGHTPATH_AREA_CROSSINGS | DtStraightPathOptions.DT_STRAIGHTPATH_ALL_CROSSINGS)) != 0)
                             {
                                 // Ignore status return value as we're just about to return anyway.
-                                AppendPortals(apexIndex, i, closestEndPos, path, straightPath, ref straightPathCount, maxStraightPath, options);
+                                AppendPortals(apexIndex, i, endPos, path, straightPath, ref straightPathCount, maxStraightPath, options);
                             }
 
                             // Ignore status return value as we're just about to return anyway.
-                            AppendVertex(closestEndPos, 0, path[i], straightPath, ref straightPathCount, maxStraightPath);
+                            AppendVertex(endPos, 0, path[i], straightPath, ref straightPathCount, maxStraightPath);
 
                             return DtStatus.DT_FAILURE | DtStatus.DT_INVALID_PARAM | (straightPathCount >= maxStraightPath ? DtStatus.DT_BUFFER_TOO_SMALL : DtStatus.DT_STATUS_NOTHING);
                         }
@@ -1708,8 +1719,8 @@ namespace DotRecast.Detour
                     else
                     {
                         // End of the path.
-                        left = closestEndPos;
-                        right = closestEndPos;
+                        left = endPos;
+                        right = endPos;
                         toType = DtPolyTypes.DT_POLYTYPE_GROUND;
                     }
 
@@ -1829,7 +1840,7 @@ namespace DotRecast.Detour
                 // Append portals along the current straight path segment.
                 if ((options & (DtStraightPathOptions.DT_STRAIGHTPATH_AREA_CROSSINGS | DtStraightPathOptions.DT_STRAIGHTPATH_ALL_CROSSINGS)) != 0)
                 {
-                    stat = AppendPortals(apexIndex, pathSize - 1, closestEndPos, path, straightPath, ref straightPathCount, maxStraightPath, options);
+                    stat = AppendPortals(apexIndex, pathSize - 1, endPos, path, straightPath, ref straightPathCount, maxStraightPath, options);
                     if (!stat.InProgress())
                     {
                         return stat;
@@ -1838,10 +1849,11 @@ namespace DotRecast.Detour
             }
 
             // Ignore status return value as we're just about to return anyway.
-            AppendVertex(closestEndPos, DtStraightPathFlags.DT_STRAIGHTPATH_END, 0, straightPath, ref straightPathCount, maxStraightPath);
+            AppendVertex(endPos, DtStraightPathFlags.DT_STRAIGHTPATH_END, 0, straightPath, ref straightPathCount, maxStraightPath);
             return DtStatus.DT_SUCCESS | (straightPathCount >= maxStraightPath ? DtStatus.DT_BUFFER_TOO_SMALL : DtStatus.DT_STATUS_NOTHING);
         }
 
+        private readonly Queue<DtNode> MoveAlongSurface_queue = new Queue<DtNode>();
         /// @par
         ///
         /// This method is optimized for small delta movement and a small number of 
@@ -1897,8 +1909,8 @@ namespace DotRecast.Detour
             startNode.total = 0;
             startNode.id = startRef;
             startNode.flags = DtNodeFlags.DT_NODE_CLOSED;
-            LinkedList<DtNode> stack = new LinkedList<DtNode>();
-            stack.AddLast(startNode);
+            MoveAlongSurface_queue.Clear();
+            MoveAlongSurface_queue.Enqueue(startNode);
 
             RcVec3f bestPos = new RcVec3f();
             float bestDist = float.MaxValue;
@@ -1914,11 +1926,10 @@ namespace DotRecast.Detour
             const int MAX_NEIS = 8;
             Span<long> neis = stackalloc long[MAX_NEIS];
 
-            while (0 < stack.Count)
+            while (0 < MoveAlongSurface_queue.Count)
             {
                 // Pop front.
-                DtNode curNode = stack.First?.Value;
-                stack.RemoveFirst();
+                DtNode curNode = MoveAlongSurface_queue.Dequeue();
 
                 // Get poly and tile.
                 // The API input has been checked already, skip checking internal data.
@@ -2017,7 +2028,7 @@ namespace DotRecast.Detour
                             // Mark as the node as visited and push to queue.
                             neighbourNode.pidx = m_tinyNodePool.GetNodeIdx(curNode);
                             neighbourNode.flags |= DtNodeFlags.DT_NODE_CLOSED;
-                            stack.AddLast(neighbourNode);
+                            MoveAlongSurface_queue.Enqueue(neighbourNode);
                         }
                     }
                 }
@@ -2066,19 +2077,11 @@ namespace DotRecast.Detour
             fromType = 0;
             toType = 0;
 
-            var status = m_nav.GetTileAndPolyByRef(from, out var fromTile, out var fromPoly);
-            if (status.Failed())
-            {
-                return DtStatus.DT_FAILURE | DtStatus.DT_INVALID_PARAM;
-            }
+            m_nav.GetTileAndPolyByRefUnsafe(from, out var fromTile, out var fromPoly);
 
             fromType = fromPoly.GetPolyType();
 
-            status = m_nav.GetTileAndPolyByRef(to, out var toTile, out var toPoly);
-            if (status.Failed())
-            {
-                return DtStatus.DT_FAILURE | DtStatus.DT_INVALID_PARAM;
-            }
+            m_nav.GetTileAndPolyByRefUnsafe(to, out var toTile, out var toPoly);
 
             toType = toPoly.GetPolyType();
 
@@ -2263,13 +2266,15 @@ namespace DotRecast.Detour
             out float t, out RcVec3f hitNormal, ref List<long> path)
         {
             DtRaycastHit hit = new DtRaycastHit();
-            hit.path = path;
+            using var pathRent = RcRentedArray.Rent<long>(MAX_PATH_LENGTH);
+            hit.path = pathRent.AsArray();
 
             DtStatus status = Raycast(startRef, startPos, endPos, filter, 0, ref hit, 0);
 
             t = hit.t;
             hitNormal = hit.hitNormal;
-            path = hit.path;
+            path.Clear();
+            CollectionExtensions.AddRange(path, new Span<long>(hit.path, 0, hit.pathCount));
 
             return status;
         }
@@ -2335,7 +2340,7 @@ namespace DotRecast.Detour
             }
 
             hit.t = 0;
-            hit.path.Clear();
+            hit.pathCount = 0;
             hit.pathCost = 0;
 
             Span<RcVec3f> verts = stackalloc RcVec3f[m_nav.GetMaxVertsPerPoly() + 1];
@@ -2388,7 +2393,7 @@ namespace DotRecast.Detour
                 }
 
                 // Store visited polygons.
-                hit.path.Add(curRef);
+                hit.AddPathNode(curRef);
 
                 // Ray end is completely inside the polygon.
                 if (segMax == -1)
@@ -2908,6 +2913,7 @@ namespace DotRecast.Detour
             return DtStatus.DT_SUCCESS;
         }
 
+        private readonly Queue<DtNode> FindLocalNeighbourhood_queue = new Queue<DtNode>();
         /// @par
         ///
         /// This method is optimized for a small search radius and small number of result 
@@ -2959,8 +2965,8 @@ namespace DotRecast.Detour
             startNode.pidx = 0;
             startNode.id = startRef;
             startNode.flags = DtNodeFlags.DT_NODE_CLOSED;
-            LinkedList<DtNode> stack = new LinkedList<DtNode>();
-            stack.AddLast(startNode);
+            FindLocalNeighbourhood_queue.Clear();
+            FindLocalNeighbourhood_queue.Enqueue(startNode);
 
             resultRef.Add(startNode.id);
             resultParent.Add(0L);
@@ -2970,11 +2976,11 @@ namespace DotRecast.Detour
             Span<float> pa = stackalloc float[m_nav.GetMaxVertsPerPoly() * 3];
             Span<float> pb = stackalloc float[m_nav.GetMaxVertsPerPoly() * 3];
 
-            while (0 < stack.Count)
+            while (0 < FindLocalNeighbourhood_queue.Count)
             {
                 // Pop front.
-                DtNode curNode = stack.First?.Value;
-                stack.RemoveFirst();
+                
+                DtNode curNode = FindLocalNeighbourhood_queue.Dequeue();
 
                 // Get poly and tile.
                 // The API input has been checked already, skip checking internal data.
@@ -3087,7 +3093,7 @@ namespace DotRecast.Detour
 
                     resultRef.Add(neighbourRef);
                     resultParent.Add(curRef);
-                    stack.AddLast(neighbourNode);
+                    FindLocalNeighbourhood_queue.Enqueue(neighbourNode);
                 }
             }
 

src/DotRecast.Detour/DtNoOpDtPolygonByCircleConstraint.cs

@@ -1,3 +1,4 @@
+using System;
 using DotRecast.Core.Numerics;
 
 namespace DotRecast.Detour
@@ -10,9 +11,11 @@ namespace DotRecast.Detour
         {
         }
 
-        public float[] Apply(float[] polyVerts, RcVec3f circleCenter, float radius)
+        public Span<float> Apply(Span<float> polyVerts, RcVec3f circleCenter, float radius, Span<float> resultBuffer)
         {
-            return polyVerts;
+            var result = resultBuffer.Slice(0, polyVerts.Length);
+            polyVerts.CopyTo(result);
+            return result;
         }
     }
 }

src/DotRecast.Detour/DtPathUtils.cs

@@ -20,7 +20,10 @@ freely, subject to the following restrictions:
 
 using System;
 using System.Collections.Generic;
+using DotRecast.Core.Buffers;
+using DotRecast.Core.Collections;
 using DotRecast.Core.Numerics;
+using CollectionExtensions = DotRecast.Core.Collections.CollectionExtensions;
 
 namespace DotRecast.Detour
 {
@@ -148,7 +151,7 @@ namespace DotRecast.Detour
             return npath;
         }
 
-        public static int MergeCorridorStartMoved(ref List<long> path, int npath, int maxPath, Span<long> visited, int nvisited)
+        public static int MergeCorridorStartMoved(List<long> path, int npath, int maxPath, Span<long> visited, int nvisited)
         {
             int furthestPath = -1;
             int furthestVisited = -1;
@@ -180,22 +183,23 @@ namespace DotRecast.Detour
             }
 
             // Concatenate paths.
-
+            var endIndex = nvisited - 1;
+            var length1 = endIndex - furthestVisited;
+            var length2 = npath - furthestPath;
+            using var result = RcRentedArray.Rent<long>(length1 + length2);
             // Adjust beginning of the buffer to include the visited.
-            List<long> result = new List<long>();
             // Store visited
-            for (int i = nvisited - 1; i > furthestVisited; --i)
-            {
-                result.Add(visited[i]);
-            }
+            for (int i = 0; i < length1; ++i) 
+                result[i] = visited[endIndex - i];
+            
+            path.CopyTo(furthestPath, result.AsArray(), length1, length2);
 
-            result.AddRange(path.GetRange(furthestPath, npath - furthestPath));
-
-            path = result;
-            return result.Count;
+            path.Clear();
+            CollectionExtensions.AddRange(path, result.AsSpan());
+            return result.Length;
         }
 
-        public static int MergeCorridorEndMoved(ref List<long> path, int npath, int maxPath, Span<long> visited, int nvisited)
+        public static int MergeCorridorEndMoved(List<long> path, int npath, int maxPath, Span<long> visited, int nvisited)
         {
             int furthestPath = -1;
             int furthestVisited = -1;
@@ -227,17 +231,18 @@ namespace DotRecast.Detour
             }
 
             // Concatenate paths.
-            List<long> result = path.GetRange(0, furthestPath);
-            foreach (var v in visited.Slice(furthestVisited, nvisited - furthestVisited))
-            {
-                result.Add(v);
-            }
+            var length1 = furthestPath;
+            var length2 = nvisited - furthestVisited;
+            using var result = RcRentedArray.Rent<long>(length1 + length2);
+            path.CopyTo(0, result.AsArray(), 0, length1);
+            visited.Slice(furthestVisited, nvisited - furthestVisited).CopyTo(result.AsSpan().Slice(length1, length2));
 
-            path = result;
-            return result.Count;
+            path.Clear();
+            CollectionExtensions.AddRange(path, result.AsSpan());
+            return path.Count;
         }
 
-        public static int MergeCorridorStartShortcut(ref List<long> path, int npath, int maxPath, List<long> visited, int nvisited)
+        public static int MergeCorridorStartShortcut(List<long> path, int npath, int maxPath, List<long> visited, int nvisited)
         {
             int furthestPath = -1;
             int furthestVisited = -1;
@@ -271,11 +276,15 @@ namespace DotRecast.Detour
             // Concatenate paths.
 
             // Adjust beginning of the buffer to include the visited.
-            List<long> result = visited.GetRange(0, furthestVisited);
-            result.AddRange(path.GetRange(furthestPath, npath - furthestPath));
+            var length1 = furthestVisited;
+            var length2 = npath - furthestPath;
+            using var result = RcRentedArray.Rent<long>(length1 + length2);
+            visited.CopyTo(0, result.AsArray(), 0, length1);
+            path.CopyTo(furthestPath, result.AsArray(), length1, length2);
 
-            path = result;
-            return result.Count;
+            path.Clear();
+            CollectionExtensions.AddRange(path, result.AsSpan());
+            return path.Count;
         }
     }
 }

src/DotRecast.Detour/DtRaycastHit.cs

@@ -38,9 +38,16 @@ namespace DotRecast.Detour
         public int hitEdgeIndex;
 
         /// Pointer to an array of reference ids of the visited polygons. [opt]
-        public List<long> path;
+        public long[] path;
+
+        public int pathCount;
 
         ///  The cost of the path until hit.
         public float pathCost;
+
+        public void AddPathNode(long nodeRef)
+        {
+            path[pathCount++] = nodeRef;
+        }
     }
 }

src/DotRecast.Detour/DtStrictDtPolygonByCircleConstraint.cs

@@ -39,8 +39,7 @@ namespace DotRecast.Detour
             }
         }
 
-
-        public float[] Apply(float[] verts, RcVec3f center, float radius)
+        public Span<float> Apply(Span<float> verts, RcVec3f center, float radius, Span<float> resultBuffer)
         {
             float radiusSqr = radius * radius;
             int outsideVertex = -1;
@@ -56,19 +55,30 @@ namespace DotRecast.Detour
             if (outsideVertex == -1)
             {
                 // polygon inside circle
-                return verts;
+                var result = resultBuffer.Slice(0, verts.Length);
+                verts.CopyTo(result);
+                return result;
             }
 
             Span<float> qCircle = stackalloc float[UnitCircle.Length];
             ScaleCircle(UnitCircle, center, radius, qCircle);
-            float[] intersection = DtConvexConvexIntersections.Intersect(verts, qCircle);
-            if (intersection == null && DtUtils.PointInPolygon(center, verts, verts.Length / 3))
+            Span<float> intersection = DtConvexConvexIntersections.Intersect(verts, qCircle, resultBuffer);
+            if (intersection.IsEmpty && DtUtils.PointInPolygon(center, verts, verts.Length / 3))
             {
                 // circle inside polygon
-                return qCircle.ToArray();
+                var result = resultBuffer.Slice(0, qCircle.Length);
+                qCircle.CopyTo(result);
+                return result;
             }
 
-            return intersection;
+            if(!intersection.IsEmpty)
+            {
+                var result = resultBuffer.Slice(0, intersection.Length);
+                // No need to copy, data is already in buffer
+                return result;
+            }
+            
+            return Span<float>.Empty;
         }
     }
 }

src/DotRecast.Detour/IDtPolygonByCircleConstraint.cs

@@ -24,6 +24,6 @@ namespace DotRecast.Detour
 {
     public interface IDtPolygonByCircleConstraint
     {
-        float[] Apply(float[] polyVerts, RcVec3f circleCenter, float radius);
+        Span<float> Apply(Span<float> polyVerts, RcVec3f circleCenter, float radius, Span<float> resultBuffer);
     }
 }

src/DotRecast.Recast.Toolset/Tools/RcTestNavMeshTool.cs

@@ -98,7 +98,7 @@ namespace DotRecast.Recast.Toolset.Tools
 
                 iterPos = result;
 
-                pathIterPolyCount = DtPathUtils.MergeCorridorStartMoved(ref pathIterPolys, pathIterPolyCount, MAX_POLYS, visited, nvisited);
+                pathIterPolyCount = DtPathUtils.MergeCorridorStartMoved(pathIterPolys, pathIterPolyCount, MAX_POLYS, visited, nvisited);
                 pathIterPolyCount = DtPathUtils.FixupShortcuts(ref pathIterPolys, pathIterPolyCount, navQuery);
 
                 var status = navQuery.GetPolyHeight(pathIterPolys[0], result, out var h);

test/DotRecast.Detour.Test/ConvexConvexIntersectionTest.cs

@@ -17,6 +17,7 @@ freely, subject to the following restrictions:
 3. This notice may not be removed or altered from any source distribution.
 */
 
+using System;
 using NUnit.Framework;
 
 namespace DotRecast.Detour.Test;
@@ -29,9 +30,10 @@ public class ConvexConvexIntersectionTest
     {
         float[] p = { -4, 0, 0, -3, 0, 3, 2, 0, 3, 3, 0, -3, -2, 0, -4 };
         float[] q = { -4, 0, 0, -3, 0, 3, 2, 0, 3, 3, 0, -3, -2, 0, -4 };
-        float[] intersection = DtConvexConvexIntersections.Intersect(p, q);
+        float[] buffer = new float[128];
+        Span<float> intersection = DtConvexConvexIntersections.Intersect(p, q, buffer);
         Assert.That(intersection.Length, Is.EqualTo(5 * 3));
-        Assert.That(intersection, Is.EqualTo(p));
+        Assert.That(intersection.ToArray(), Is.EquivalentTo(p));
     }
 
     [Test]
@@ -39,8 +41,9 @@ public class ConvexConvexIntersectionTest
     {
         float[] p = { -5, 0, -5, -5, 0, 4, 1, 0, 4, 1, 0, -5 };
         float[] q = { -4, 0, 0, -3, 0, 3, 2, 0, 3, 3, 0, -3, -2, 0, -4 };
-        float[] intersection = DtConvexConvexIntersections.Intersect(p, q);
+        float[] buffer = new float[128];
+        Span<float> intersection = DtConvexConvexIntersections.Intersect(p, q, buffer);
         Assert.That(intersection.Length, Is.EqualTo(5 * 3));
-        Assert.That(intersection, Is.EqualTo(new[] { 1, 0, 3, 1, 0, -3.4f, -2, 0, -4, -4, 0, 0, -3, 0, 3 }));
+        Assert.That(intersection.ToArray(), Is.EquivalentTo(new[] { 1, 0, 3, 1, 0, -3.4f, -2, 0, -4, -4, 0, 0, -3, 0, 3 }));
     }
 }

test/DotRecast.Detour.Test/PolygonByCircleConstraintTest.cs

@@ -17,6 +17,7 @@ freely, subject to the following restrictions:
 3. This notice may not be removed or altered from any source distribution.
 */
 
+using System;
 using DotRecast.Core.Numerics;
 using NUnit.Framework;
 
@@ -32,9 +33,12 @@ public class PolygonByCircleConstraintTest
     {
         float[] polygon = { -2, 0, 2, 2, 0, 2, 2, 0, -2, -2, 0, -2 };
         RcVec3f center = new RcVec3f(1, 0, 1);
-        float[] constrained = _constraint.Apply(polygon, center, 6);
+        var radius = 6;
+        
+        float[] buffer = new float[128];
+        Span<float> constrained = _constraint.Apply(polygon, center, radius, buffer);
 
-        Assert.That(constrained, Is.EqualTo(polygon));
+        Assert.That(constrained.ToArray(), Is.EquivalentTo(polygon));
     }
 
     [Test]
@@ -43,10 +47,13 @@ public class PolygonByCircleConstraintTest
         int expectedSize = 21;
         float[] polygon = { -2, 0, 2, 2, 0, 2, 2, 0, -2, -2, 0, -2 };
         RcVec3f center = new RcVec3f(2, 0, 0);
+        var radius = 3;
+
+        float[] buffer = new float[128];
+        Span<float> constrained = _constraint.Apply(polygon, center, radius, buffer);
 
-        float[] constrained = _constraint.Apply(polygon, center, 3);
         Assert.That(constrained.Length, Is.EqualTo(expectedSize));
-        Assert.That(constrained, Is.SupersetOf(new[] { 2f, 0f, 2f, 2f, 0f, -2f }));
+        Assert.That(constrained.ToArray(), Is.SupersetOf(new[] { 2f, 0f, 2f, 2f, 0f, -2f }));
     }
 
     [Test]
@@ -55,7 +62,10 @@ public class PolygonByCircleConstraintTest
         int expectedSize = 12 * 3;
         float[] polygon = { -4, 0, 0, -3, 0, 3, 2, 0, 3, 3, 0, -3, -2, 0, -4 };
         RcVec3f center = new RcVec3f(-1, 0, -1);
-        float[] constrained = _constraint.Apply(polygon, center, 2);
+        var radius = 2;
+        
+        float[] buffer = new float[128];
+        Span<float> constrained = _constraint.Apply(polygon, center, radius, buffer);
 
         Assert.That(constrained.Length, Is.EqualTo(expectedSize));
 
@@ -73,10 +83,13 @@ public class PolygonByCircleConstraintTest
         int expectedSize = 9 * 3;
         float[] polygon = { -4, 0, 0, -3, 0, 3, 2, 0, 3, 3, 0, -3, -2, 0, -4 };
         RcVec3f center = new RcVec3f(-2, 0, -1);
-        float[] constrained = _constraint.Apply(polygon, center, 3);
+        var radius = 3;
+        
+        float[] buffer = new float[128];
+        Span<float> constrained = _constraint.Apply(polygon, center, radius, buffer);
 
         Assert.That(constrained.Length, Is.EqualTo(expectedSize));
-        Assert.That(constrained, Is.SupersetOf(new[] { -2f, 0f, -4f, -4f, 0f, 0f, -3.4641016f, 0.0f, 1.60769534f, -2.0f, 0.0f, 2.0f }));
+        Assert.That(constrained.ToArray(), Is.SupersetOf(new[] { -2f, 0f, -4f, -4f, 0f, 0f, -3.4641016f, 0.0f, 1.60769534f, -2.0f, 0.0f, 2.0f }));
     }
 
     [Test]
@@ -85,9 +98,12 @@ public class PolygonByCircleConstraintTest
         int expectedSize = 7 * 3;
         float[] polygon = { -4, 0, 0, -3, 0, 3, 2, 0, 3, 3, 0, -3, -2, 0, -4 };
         RcVec3f center = new RcVec3f(4, 0, 0);
-        float[] constrained = _constraint.Apply(polygon, center, 4);
+        var radius = 4;
+        
+        float[] buffer = new float[128];
+        Span<float> constrained = _constraint.Apply(polygon, center, radius, buffer);
 
         Assert.That(constrained.Length, Is.EqualTo(expectedSize));
-        Assert.That(constrained, Is.SupersetOf(new[] { 1.53589869f, 0f, 3f, 2f, 0f, 3f, 3f, 0f, -3f }));
+        Assert.That(constrained.ToArray(), Is.SupersetOf(new[] { 1.53589869f, 0f, 3f, 2f, 0f, 3f, 3f, 0f, -3f }));
     }
 }