< Summary

Information
Class: GridForge.Grids.GridScanManager
Assembly: GridForge
File(s): /home/runner/work/GridForge/GridForge/src/GridForge/Grids/Managers/GridScanManager.cs
Line coverage
79%
Covered lines: 115
Uncovered lines: 29
Coverable lines: 144
Total lines: 480
Line coverage: 79.8%
Branch coverage
77%
Covered branches: 81
Total branches: 104
Branch coverage: 77.8%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
ScanRadius(...)50%5466.66%
ScanRadius(...)100%11100%
ScanRadiusInto(...)50%7671.42%
ScanRadiusInto(...)50%10866.66%
ScanRadiusInto(...)0%4260%
ScanRadiusInto(...)50%10866.66%
GetVoxelOccupantsByType(...)100%44100%
GetVoxelOccupantsByType(...)100%22100%
GetVoxelOccupantsByType(...)100%22100%
GetVoxelOccupantsByType(...)100%22100%
TryGetVoxelOccupant(...)100%44100%
TryGetVoxelOccupant(...)100%22100%
TryGetVoxelOccupant(...)100%22100%
TryGetVoxelOccupant(...)100%66100%
GetOccupants(...)100%44100%
GetOccupants(...)100%22100%
GetOccupants(...)100%22100%
GetOccupants(...)100%66100%
GetConditionalOccupants(...)100%44100%
GetConditionalOccupants(...)100%22100%
GetConditionalOccupants(...)100%22100%
GetConditionalOccupants(...)100%88100%
ScanRadiusIterator()100%22100%
<>m__Finally1()100%11100%
AddRadiusOccupantsTo(...)100%44100%
AddRadiusOccupantsTo(...)100%44100%
AddRadiusOccupantsTo(...)0%2040%
AddRadiusOccupantsTo(...)100%44100%

File(s)

/home/runner/work/GridForge/GridForge/src/GridForge/Grids/Managers/GridScanManager.cs

#LineLine coverage
 1using FixedMathSharp;
 2using GridForge.Spatial;
 3using GridForge.Utility;
 4using SwiftCollections;
 5using SwiftCollections.Pool;
 6using System;
 7using System.Collections.Generic;
 8using System.Linq;
 9
 10namespace GridForge.Grids;
 11
 12/// <summary>
 13/// Provides efficient querying methods for retrieving occupants within a grid.
 14/// Handles spatial lookups for voxels, filtering by occupant type, and fetching occupants using unique tickets.
 15/// </summary>
 16public static class GridScanManager
 17{
 18    #region Scan Methods
 19
 20    /// <summary>
 21    /// Scans for occupants within a given radius from a specified position in the supplied world.
 22    /// </summary>
 23    public static IEnumerable<IVoxelOccupant> ScanRadius(
 24        GridWorld world,
 25        Vector3d position,
 26        Fixed64 radius,
 27        Func<IVoxelOccupant, bool>? occupantCondition = null,
 28        Func<byte, bool>? groupCondition = null)
 29    {
 630        if (world == null || !world.IsActive)
 031            return Enumerable.Empty<IVoxelOccupant>();
 32
 633        return ScanRadiusIterator(world, position, radius, occupantCondition, groupCondition);
 34    }
 35
 36    /// <summary>
 37    /// Scans for occupants of a specific type within a given radius in the supplied world.
 38    /// </summary>
 39    public static IEnumerable<T> ScanRadius<T>(
 40        GridWorld world,
 41        Vector3d position,
 42        Fixed64 radius,
 43        Func<IVoxelOccupant, bool>? occupantCondition = null,
 44        Func<byte, bool>? groupCondition = null) where T : IVoxelOccupant
 45    {
 146        return ScanRadius(world, position, radius, occupantCondition, groupCondition).OfType<T>();
 47    }
 48
 49    /// <summary>
 50    /// Clears and fills caller-owned storage with occupants within the supplied radius.
 51    /// </summary>
 52    public static void ScanRadiusInto(
 53        GridWorld world,
 54        Vector3d position,
 55        Fixed64 radius,
 56        SwiftList<IVoxelOccupant> results,
 57        Func<IVoxelOccupant, bool>? occupantCondition = null,
 58        Func<byte, bool>? groupCondition = null)
 59    {
 760        if (results == null)
 061            throw new ArgumentNullException(nameof(results));
 62
 763        results.Clear();
 764        if (world == null || !world.IsActive)
 065            return;
 66
 767        AddRadiusOccupantsTo(world, position, radius, results, occupantCondition, groupCondition);
 768    }
 69
 70    /// <summary>
 71    /// Clears and fills caller-owned storage using caller-owned scratch collections.
 72    /// </summary>
 73    public static void ScanRadiusInto(
 74        GridWorld world,
 75        Vector3d position,
 76        Fixed64 radius,
 77        SwiftList<IVoxelOccupant> results,
 78        GridScanScratch scratch,
 79        Func<IVoxelOccupant, bool>? occupantCondition = null,
 80        Func<byte, bool>? groupCondition = null)
 81    {
 25782        if (results == null)
 083            throw new ArgumentNullException(nameof(results));
 84
 25785        if (scratch == null)
 086            throw new ArgumentNullException(nameof(scratch));
 87
 25788        results.Clear();
 25789        if (world == null || !world.IsActive)
 090            return;
 91
 25792        AddRadiusOccupantsTo(world, position, radius, results, scratch, occupantCondition, groupCondition);
 25793    }
 94
 95    /// <summary>
 96    /// Clears and fills caller-owned storage with typed occupants within the supplied radius.
 97    /// </summary>
 98    public static void ScanRadiusInto<T>(
 99        GridWorld world,
 100        Vector3d position,
 101        Fixed64 radius,
 102        SwiftList<T> results,
 103        Func<IVoxelOccupant, bool>? occupantCondition = null,
 104        Func<byte, bool>? groupCondition = null) where T : IVoxelOccupant
 105    {
 0106        if (results == null)
 0107            throw new ArgumentNullException(nameof(results));
 108
 0109        results.Clear();
 0110        if (world == null || !world.IsActive)
 0111            return;
 112
 0113        AddRadiusOccupantsTo(world, position, radius, results, occupantCondition, groupCondition);
 0114    }
 115
 116    /// <summary>
 117    /// Clears and fills caller-owned typed storage using caller-owned scratch collections.
 118    /// </summary>
 119    public static void ScanRadiusInto<T>(
 120        GridWorld world,
 121        Vector3d position,
 122        Fixed64 radius,
 123        SwiftList<T> results,
 124        GridScanScratch scratch,
 125        Func<IVoxelOccupant, bool>? occupantCondition = null,
 126        Func<byte, bool>? groupCondition = null) where T : IVoxelOccupant
 127    {
 1128        if (results == null)
 0129            throw new ArgumentNullException(nameof(results));
 130
 1131        if (scratch == null)
 0132            throw new ArgumentNullException(nameof(scratch));
 133
 1134        results.Clear();
 1135        if (world == null || !world.IsActive)
 0136            return;
 137
 1138        AddRadiusOccupantsTo(world, position, radius, results, scratch, occupantCondition, groupCondition);
 1139    }
 140
 141    #endregion
 142
 143    #region Occupant Registration & Retrieval
 144
 145    /// <summary>
 146    /// Retrieves all occupants of a specific type at a given world-scoped voxel identity in the supplied world.
 147    /// </summary>
 148    public static IEnumerable<T> GetVoxelOccupantsByType<T>(GridWorld world, WorldVoxelIndex index) where T : IVoxelOccu
 149    {
 2150        return world != null && world.TryGetGridAndVoxel(index, out VoxelGrid? grid, out Voxel? voxel)
 2151            ? grid!.GetVoxelOccupantsByType<T>(voxel!)
 2152            : Enumerable.Empty<T>();
 153    }
 154
 155    /// <summary>
 156    /// Retrieves all occupants of a specific type at a given world position.
 157    /// </summary>
 158    public static IEnumerable<T> GetVoxelOccupantsByType<T>(this VoxelGrid grid, Vector3d position) where T : IVoxelOccu
 159    {
 2160        return grid.TryGetVoxel(position, out Voxel? voxel)
 2161            ? grid.GetVoxelOccupantsByType<T>(voxel!)
 2162            : Enumerable.Empty<T>();
 163    }
 164
 165    /// <summary>
 166    /// Retrieves all occupants of a specific type at a given voxel coordinate.
 167    /// </summary>
 168    public static IEnumerable<T> GetVoxelOccupantsByType<T>(this VoxelGrid grid, VoxelIndex index) where T : IVoxelOccup
 169    {
 2170        return grid.TryGetVoxel(index, out Voxel? voxel)
 2171            ? grid.GetVoxelOccupantsByType<T>(voxel!)
 2172            : Enumerable.Empty<T>();
 173    }
 174
 175    /// <summary>
 176    /// Retrieves all occupants of a specific type at a given voxel.
 177    /// </summary>
 178    public static IEnumerable<T> GetVoxelOccupantsByType<T>(this VoxelGrid grid, Voxel voxel) where T : IVoxelOccupant
 179    {
 4180        return voxel == null
 4181            ? Enumerable.Empty<T>()
 4182            : grid.GetOccupants(voxel).OfType<T>();
 183    }
 184
 185    /// <summary>
 186    /// Retrieves a specific occupant at a given world-scoped voxel identity using an occupant ticket in the supplied wo
 187    /// </summary>
 188    public static bool TryGetVoxelOccupant(
 189        GridWorld world,
 190        WorldVoxelIndex index,
 191        int ticket,
 192        out IVoxelOccupant? occupant)
 193    {
 4194        occupant = null;
 4195        return world != null
 4196            && world.TryGetGridAndVoxel(index, out VoxelGrid? grid, out Voxel? voxel)
 4197            && grid!.TryGetVoxelOccupant(voxel!, ticket, out occupant);
 198    }
 199
 200    /// <summary>
 201    /// Retrieves a specific occupant at a given world position using an occupant ticket.
 202    /// </summary>
 203    public static bool TryGetVoxelOccupant(
 204        this VoxelGrid grid,
 205        Vector3d position,
 206        int ticket,
 207        out IVoxelOccupant? occupant)
 208    {
 3209        occupant = null;
 3210        return grid.TryGetVoxel(position, out Voxel? voxel)
 3211            && grid.TryGetVoxelOccupant(voxel!, ticket, out occupant);
 212    }
 213
 214    /// <summary>
 215    /// Retrieves a specific occupant at a given voxel coordinate using an occupant ticket.
 216    /// </summary>
 217    public static bool TryGetVoxelOccupant(
 218        this VoxelGrid grid,
 219        VoxelIndex index,
 220        int ticket,
 221        out IVoxelOccupant? occupant)
 222    {
 2223        occupant = null;
 2224        return grid.TryGetVoxel(index, out Voxel? voxel)
 2225            && grid.TryGetVoxelOccupant(voxel!, ticket, out occupant);
 226    }
 227
 228    /// <summary>
 229    /// Retrieves a specific occupant from a given voxel using an occupant ticket.
 230    /// </summary>
 231    public static bool TryGetVoxelOccupant(
 232        this VoxelGrid grid,
 233        Voxel voxel,
 234        int ticket,
 235        out IVoxelOccupant? occupant)
 236    {
 12237        occupant = null;
 12238        return voxel.IsOccupied
 12239            && grid.TryGetScanCell(voxel.ScanCellKey, out ScanCell? scanCell)
 12240            && scanCell!.IsOccupied
 12241            && scanCell.TryGetOccupantAt(voxel.WorldIndex, ticket, out occupant);
 242    }
 243
 244    /// <summary>
 245    /// Retrieves all occupants at a given world-scoped voxel identity in the supplied world.
 246    /// </summary>
 247    public static IEnumerable<IVoxelOccupant> GetOccupants(GridWorld world, WorldVoxelIndex index)
 248    {
 2249        return world != null && world.TryGetGridAndVoxel(index, out VoxelGrid? grid, out Voxel? voxel)
 2250            ? grid!.GetOccupants(voxel!)
 2251            : Enumerable.Empty<IVoxelOccupant>();
 252    }
 253
 254    /// <summary>
 255    /// Retrieves all occupants at a given world position within the grid.
 256    /// </summary>
 257    public static IEnumerable<IVoxelOccupant> GetOccupants(this VoxelGrid grid, Vector3d position)
 258    {
 5259        return grid.TryGetVoxel(position, out Voxel? targetVoxel)
 5260            ? grid.GetOccupants(targetVoxel!)
 5261            : Enumerable.Empty<IVoxelOccupant>();
 262    }
 263
 264    /// <summary>
 265    /// Retrieves all occupants at a given voxel coordinate within the grid.
 266    /// </summary>
 267    public static IEnumerable<IVoxelOccupant> GetOccupants(this VoxelGrid grid, VoxelIndex index)
 268    {
 2269        return grid.TryGetVoxel(index, out Voxel? targetVoxel)
 2270            ? grid.GetOccupants(targetVoxel!)
 2271            : Enumerable.Empty<IVoxelOccupant>();
 272    }
 273
 274    /// <summary>
 275    /// Retrieves all occupants at a given voxel.
 276    /// </summary>
 277    public static IEnumerable<IVoxelOccupant> GetOccupants(this VoxelGrid grid, Voxel voxel)
 278    {
 9279        return voxel.IsOccupied
 9280            && grid.TryGetScanCell(voxel.ScanCellKey, out ScanCell? scanCell)
 9281            && scanCell!.IsOccupied
 9282            ? scanCell.GetOccupants()
 9283            : Enumerable.Empty<IVoxelOccupant>();
 284    }
 285
 286    /// <summary>
 287    /// Retrieves occupants whose group Ids match a given condition at a world-scoped voxel identity in the supplied wor
 288    /// </summary>
 289    public static IEnumerable<IVoxelOccupant> GetConditionalOccupants(
 290        GridWorld world,
 291        WorldVoxelIndex index,
 292        Func<IVoxelOccupant, bool>? occupantCondition = null,
 293        Func<byte, bool>? groupCondition = null)
 294    {
 3295        return world != null && world.TryGetGridAndVoxel(index, out VoxelGrid? grid, out Voxel? voxel)
 3296            ? grid!.GetConditionalOccupants(voxel!, occupantCondition, groupCondition)
 3297            : Enumerable.Empty<IVoxelOccupant>();
 298    }
 299
 300    /// <summary>
 301    /// Retrieves occupants whose group Ids match a given condition.
 302    /// </summary>
 303    public static IEnumerable<IVoxelOccupant> GetConditionalOccupants(
 304        this VoxelGrid grid,
 305        Vector3d position,
 306        Func<IVoxelOccupant, bool>? occupantCondition = null,
 307        Func<byte, bool>? groupCondition = null)
 308    {
 3309        return grid.TryGetVoxel(position, out Voxel? voxel)
 3310            ? grid.GetConditionalOccupants(voxel!, occupantCondition, groupCondition)
 3311            : Enumerable.Empty<IVoxelOccupant>();
 312    }
 313
 314    /// <summary>
 315    /// Retrieves occupants whose group Ids match a given condition.
 316    /// </summary>
 317    public static IEnumerable<IVoxelOccupant> GetConditionalOccupants(
 318        this VoxelGrid grid,
 319        VoxelIndex index,
 320        Func<IVoxelOccupant, bool>? occupantCondition = null,
 321        Func<byte, bool>? groupCondition = null)
 322    {
 4323        return grid.TryGetVoxel(index, out Voxel? voxel)
 4324            ? grid.GetConditionalOccupants(voxel!, occupantCondition, groupCondition)
 4325            : Enumerable.Empty<IVoxelOccupant>();
 326    }
 327
 328    /// <summary>
 329    /// Retrieves occupants at a given voxel that match a specified group condition.
 330    /// </summary>
 331    public static IEnumerable<IVoxelOccupant> GetConditionalOccupants(
 332        this VoxelGrid grid,
 333        Voxel targetVoxel,
 334        Func<IVoxelOccupant, bool>? occupantCondition = null,
 335        Func<byte, bool>? groupCondition = null)
 336    {
 9337        return targetVoxel != null
 9338            && targetVoxel.IsOccupied
 9339            && grid.TryGetScanCell(targetVoxel.ScanCellKey, out ScanCell? scanCell)
 9340            && scanCell!.IsOccupied
 9341            ? scanCell.GetConditionalOccupants(occupantCondition, groupCondition)
 9342            : Enumerable.Empty<IVoxelOccupant>();
 343    }
 344
 345    #endregion
 346
 347    #region Private Methods
 348
 349    private static IEnumerable<IVoxelOccupant> ScanRadiusIterator(
 350        GridWorld world,
 351        Vector3d position,
 352        Fixed64 radius,
 353        Func<IVoxelOccupant, bool>? occupantCondition,
 354        Func<byte, bool>? groupCondition)
 355    {
 6356        SwiftList<IVoxelOccupant> results = SwiftListPool<IVoxelOccupant>.Shared.Rent();
 357
 358        try
 359        {
 6360            ScanRadiusInto(world, position, radius, results, occupantCondition, groupCondition);
 361
 26362            foreach (IVoxelOccupant result in results)
 363            {
 7364                yield return result;
 365            }
 6366        }
 367        finally
 368        {
 6369            SwiftListPool<IVoxelOccupant>.Shared.Release(results);
 6370        }
 6371    }
 372
 373    private static void AddRadiusOccupantsTo(
 374        GridWorld world,
 375        Vector3d position,
 376        Fixed64 radius,
 377        SwiftList<IVoxelOccupant> results,
 378        Func<IVoxelOccupant, bool>? occupantCondition,
 379        Func<byte, bool>? groupCondition)
 380    {
 7381        Fixed64 squaredRadius = radius * radius;
 7382        Vector3d boundsMin = position - radius;
 7383        Vector3d boundsMax = position + radius;
 7384        SwiftList<ScanCell> scanCells = SwiftListPool<ScanCell>.Shared.Rent();
 385
 386        try
 387        {
 7388            GridTracer.AddCoveredScanCellsTo(world, boundsMin, boundsMax, scanCells);
 389
 80390            for (int i = 0; i < scanCells.Count; i++)
 391            {
 33392                ScanCell scanCell = scanCells[i];
 33393                if (scanCell.IsOccupied)
 9394                    scanCell.AddOccupantsWithinRadiusTo(results, position, squaredRadius, occupantCondition, groupCondit
 395            }
 7396        }
 397        finally
 398        {
 7399            SwiftListPool<ScanCell>.Shared.Release(scanCells);
 7400        }
 7401    }
 402
 403    private static void AddRadiusOccupantsTo(
 404        GridWorld world,
 405        Vector3d position,
 406        Fixed64 radius,
 407        SwiftList<IVoxelOccupant> results,
 408        GridScanScratch scratch,
 409        Func<IVoxelOccupant, bool>? occupantCondition,
 410        Func<byte, bool>? groupCondition)
 411    {
 257412        Fixed64 squaredRadius = radius * radius;
 257413        Vector3d boundsMin = position - radius;
 257414        Vector3d boundsMax = position + radius;
 415
 257416        GridTracer.AddCoveredScanCellsTo(world, boundsMin, boundsMax, scratch.ScanCells, scratch);
 417
 2570418        for (int i = 0; i < scratch.ScanCells.Count; i++)
 419        {
 1028420            ScanCell scanCell = scratch.ScanCells[i];
 1028421            if (scanCell.IsOccupied)
 257422                scanCell.AddOccupantsWithinRadiusTo(results, position, squaredRadius, occupantCondition, groupCondition)
 423        }
 257424    }
 425
 426    private static void AddRadiusOccupantsTo<T>(
 427        GridWorld world,
 428        Vector3d position,
 429        Fixed64 radius,
 430        SwiftList<T> results,
 431        Func<IVoxelOccupant, bool>? occupantCondition,
 432        Func<byte, bool>? groupCondition) where T : IVoxelOccupant
 433    {
 0434        Fixed64 squaredRadius = radius * radius;
 0435        Vector3d boundsMin = position - radius;
 0436        Vector3d boundsMax = position + radius;
 0437        SwiftList<ScanCell> scanCells = SwiftListPool<ScanCell>.Shared.Rent();
 438
 439        try
 440        {
 0441            GridTracer.AddCoveredScanCellsTo(world, boundsMin, boundsMax, scanCells);
 442
 0443            for (int i = 0; i < scanCells.Count; i++)
 444            {
 0445                ScanCell scanCell = scanCells[i];
 0446                if (scanCell.IsOccupied)
 0447                    scanCell.AddOccupantsWithinRadiusTo(results, position, squaredRadius, occupantCondition, groupCondit
 448            }
 0449        }
 450        finally
 451        {
 0452            SwiftListPool<ScanCell>.Shared.Release(scanCells);
 0453        }
 0454    }
 455
 456    private static void AddRadiusOccupantsTo<T>(
 457        GridWorld world,
 458        Vector3d position,
 459        Fixed64 radius,
 460        SwiftList<T> results,
 461        GridScanScratch scratch,
 462        Func<IVoxelOccupant, bool>? occupantCondition,
 463        Func<byte, bool>? groupCondition) where T : IVoxelOccupant
 464    {
 1465        Fixed64 squaredRadius = radius * radius;
 1466        Vector3d boundsMin = position - radius;
 1467        Vector3d boundsMax = position + radius;
 468
 1469        GridTracer.AddCoveredScanCellsTo(world, boundsMin, boundsMax, scratch.ScanCells, scratch);
 470
 10471        for (int i = 0; i < scratch.ScanCells.Count; i++)
 472        {
 4473            ScanCell scanCell = scratch.ScanCells[i];
 4474            if (scanCell.IsOccupied)
 1475                scanCell.AddOccupantsWithinRadiusTo(results, position, squaredRadius, occupantCondition, groupCondition)
 476        }
 1477    }
 478
 479    #endregion
 480}
Generated by: ReportGenerator 5.5.9.0
05/07/2026 - 15:39:52
GitHub | reportgenerator.io

Methods/Properties

ScanRadius(GridForge.Grids.GridWorld,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,System.Func`2<GridForge.Spatial.IVoxelOccupant,System.Boolean>,System.Func`2<System.Byte,System.Boolean>)
ScanRadius(GridForge.Grids.GridWorld,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,System.Func`2<GridForge.Spatial.IVoxelOccupant,System.Boolean>,System.Func`2<System.Byte,System.Boolean>)
ScanRadiusInto(GridForge.Grids.GridWorld,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,SwiftCollections.SwiftList`1<GridForge.Spatial.IVoxelOccupant>,System.Func`2<GridForge.Spatial.IVoxelOccupant,System.Boolean>,System.Func`2<System.Byte,System.Boolean>)
ScanRadiusInto(GridForge.Grids.GridWorld,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,SwiftCollections.SwiftList`1<GridForge.Spatial.IVoxelOccupant>,GridForge.Grids.GridScanScratch,System.Func`2<GridForge.Spatial.IVoxelOccupant,System.Boolean>,System.Func`2<System.Byte,System.Boolean>)
ScanRadiusInto(GridForge.Grids.GridWorld,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,SwiftCollections.SwiftList`1<T>,System.Func`2<GridForge.Spatial.IVoxelOccupant,System.Boolean>,System.Func`2<System.Byte,System.Boolean>)
ScanRadiusInto(GridForge.Grids.GridWorld,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,SwiftCollections.SwiftList`1<T>,GridForge.Grids.GridScanScratch,System.Func`2<GridForge.Spatial.IVoxelOccupant,System.Boolean>,System.Func`2<System.Byte,System.Boolean>)
GetVoxelOccupantsByType(GridForge.Grids.GridWorld,GridForge.Spatial.WorldVoxelIndex)
GetVoxelOccupantsByType(GridForge.Grids.VoxelGrid,FixedMathSharp.Vector3d)
GetVoxelOccupantsByType(GridForge.Grids.VoxelGrid,GridForge.Spatial.VoxelIndex)
GetVoxelOccupantsByType(GridForge.Grids.VoxelGrid,GridForge.Grids.Voxel)
TryGetVoxelOccupant(GridForge.Grids.GridWorld,GridForge.Spatial.WorldVoxelIndex,System.Int32,GridForge.Spatial.IVoxelOccupant&)
TryGetVoxelOccupant(GridForge.Grids.VoxelGrid,FixedMathSharp.Vector3d,System.Int32,GridForge.Spatial.IVoxelOccupant&)
TryGetVoxelOccupant(GridForge.Grids.VoxelGrid,GridForge.Spatial.VoxelIndex,System.Int32,GridForge.Spatial.IVoxelOccupant&)
TryGetVoxelOccupant(GridForge.Grids.VoxelGrid,GridForge.Grids.Voxel,System.Int32,GridForge.Spatial.IVoxelOccupant&)
GetOccupants(GridForge.Grids.GridWorld,GridForge.Spatial.WorldVoxelIndex)
GetOccupants(GridForge.Grids.VoxelGrid,FixedMathSharp.Vector3d)
GetOccupants(GridForge.Grids.VoxelGrid,GridForge.Spatial.VoxelIndex)
GetOccupants(GridForge.Grids.VoxelGrid,GridForge.Grids.Voxel)
GetConditionalOccupants(GridForge.Grids.GridWorld,GridForge.Spatial.WorldVoxelIndex,System.Func`2<GridForge.Spatial.IVoxelOccupant,System.Boolean>,System.Func`2<System.Byte,System.Boolean>)
GetConditionalOccupants(GridForge.Grids.VoxelGrid,FixedMathSharp.Vector3d,System.Func`2<GridForge.Spatial.IVoxelOccupant,System.Boolean>,System.Func`2<System.Byte,System.Boolean>)
GetConditionalOccupants(GridForge.Grids.VoxelGrid,GridForge.Spatial.VoxelIndex,System.Func`2<GridForge.Spatial.IVoxelOccupant,System.Boolean>,System.Func`2<System.Byte,System.Boolean>)
GetConditionalOccupants(GridForge.Grids.VoxelGrid,GridForge.Grids.Voxel,System.Func`2<GridForge.Spatial.IVoxelOccupant,System.Boolean>,System.Func`2<System.Byte,System.Boolean>)
ScanRadiusIterator()
<>m__Finally1()
AddRadiusOccupantsTo(GridForge.Grids.GridWorld,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,SwiftCollections.SwiftList`1<GridForge.Spatial.IVoxelOccupant>,System.Func`2<GridForge.Spatial.IVoxelOccupant,System.Boolean>,System.Func`2<System.Byte,System.Boolean>)
AddRadiusOccupantsTo(GridForge.Grids.GridWorld,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,SwiftCollections.SwiftList`1<GridForge.Spatial.IVoxelOccupant>,GridForge.Grids.GridScanScratch,System.Func`2<GridForge.Spatial.IVoxelOccupant,System.Boolean>,System.Func`2<System.Byte,System.Boolean>)
AddRadiusOccupantsTo(GridForge.Grids.GridWorld,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,SwiftCollections.SwiftList`1<T>,System.Func`2<GridForge.Spatial.IVoxelOccupant,System.Boolean>,System.Func`2<System.Byte,System.Boolean>)
AddRadiusOccupantsTo(GridForge.Grids.GridWorld,FixedMathSharp.Vector3d,FixedMathSharp.Fixed64,SwiftCollections.SwiftList`1<T>,GridForge.Grids.GridScanScratch,System.Func`2<GridForge.Spatial.IVoxelOccupant,System.Boolean>,System.Func`2<System.Byte,System.Boolean>)