< Summary

Information
Class: GridForge.Diagnostics.GridDiagnostics
Assembly: GridForge
File(s): /home/runner/work/GridForge/GridForge/src/GridForge/Diagnostics/GridDiagnostics.cs
Line coverage
97%
Covered lines: 255
Uncovered lines: 6
Coverable lines: 261
Total lines: 608
Line coverage: 97.7%
Branch coverage
87%
Covered branches: 137
Total branches: 156
Branch coverage: 87.8%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
GetCellsInto(...)100%11100%
VisitCells(...)100%11100%
VisitCellsCore(...)87.5%242496.77%
TryResolvePhysicalCell(...)71.42%1414100%
VisitGridCells(...)50%2292.85%
VisitGridCells(...)100%22100%
VisitPhysicalCells(...)83.33%6695.65%
VisitSparseAddressCells(...)96.42%282895.23%
ShouldVisitGrid(...)87.5%9880%
RequiresMissingAddressBounds(...)87.5%8885.71%
RequiresMissingAddressBounds(...)50%44100%
RequiresMissingAddressBounds(...)100%44100%
UsesSparseAddressTraversal(...)100%22100%
UsesMissingAddressMode(...)100%22100%
TryGetQueryBounds(...)100%44100%
IsVoxelInQueryBounds(...)83.33%1212100%
IsIndexInQueryBounds(...)100%11100%
GetCellState(...)100%1212100%
GetMissingAddressCellState(...)50%22100%
MatchesStateFilters(...)100%66100%
TryGetSparseAddressRange(...)66.66%66100%
TryVisitCell(...)100%44100%
CreatePhysicalCell(...)100%11100%
CreateMissingAddressCell(...)100%11100%
.ctor(...)100%11100%
Visit(...)100%11100%
.ctor(...)100%11100%
Visit(...)100%66100%

File(s)

/home/runner/work/GridForge/GridForge/src/GridForge/Diagnostics/GridDiagnostics.cs

#LineLine coverage
 1//=======================================================================
 2// GridDiagnostics.cs
 3//=======================================================================
 4// MIT License, Copyright (c) 2024–present David Oravsky (mrdav30)
 5// See LICENSE file in the project root for full license information.
 6//=======================================================================
 7
 8using FixedMathSharp;
 9using GridForge.Grids;
 10using GridForge.Grids.Storage;
 11using GridForge.Grids.Topology;
 12using GridForge.Spatial;
 13using SwiftCollections;
 14using System.Runtime.CompilerServices;
 15
 16namespace GridForge.Diagnostics;
 17
 18/// <summary>
 19/// Engine-agnostic diagnostic query helpers for GridForge worlds and grids.
 20/// </summary>
 21public static class GridDiagnostics
 22{
 23    /// <summary>
 24    /// Clears and fills caller-owned storage with diagnostic cells.
 25    /// </summary>
 26    public static GridDiagnosticQueryResult GetCellsInto(
 27        GridWorld world,
 28        in GridDiagnosticQuery query,
 29        SwiftList<GridDiagnosticCell> results,
 30        GridDiagnosticScratch? scratch = null)
 31    {
 2932        SwiftThrowHelper.ThrowIfNull(results, nameof(results));
 33
 2834        results.Clear();
 35
 2836        ResultListVisitor visitor = new(results);
 2837        return VisitCellsCore(world, query, ref visitor, scratch);
 38    }
 39
 40    /// <summary>
 41    /// Visits diagnostic cells without requiring an intermediate result list.
 42    /// </summary>
 43    public static GridDiagnosticQueryResult VisitCells<TVisitor>(
 44        GridWorld world,
 45        in GridDiagnosticQuery query,
 46        ref TVisitor visitor,
 47        GridDiagnosticScratch? scratch = null)
 48        where TVisitor : struct, IGridDiagnosticCellVisitor
 49    {
 3550        return VisitCellsCore(world, query, ref visitor, scratch);
 51    }
 52
 53    private static GridDiagnosticQueryResult VisitCellsCore<TVisitor>(
 54        GridWorld world,
 55        in GridDiagnosticQuery query,
 56        ref TVisitor visitor,
 57        GridDiagnosticScratch? scratch)
 58        where TVisitor : struct, IGridDiagnosticCellVisitor
 59    {
 6360        scratch?.Clear();
 6361        if (world == null || !world.IsActive)
 262            return new GridDiagnosticQueryResult(GridDiagnosticQueryStatus.InactiveWorld, 0, 0);
 63
 6164        bool hasBounds = TryGetQueryBounds(query, out TopologyVoxelAabb queryBounds);
 6165        if (query.GridIndex.HasValue)
 66        {
 267            if (!world.TryGetGrid(query.GridIndex.Value, out VoxelGrid? requestedGrid)
 268                || requestedGrid == null
 269                || !requestedGrid.IsActive)
 70            {
 171                return new GridDiagnosticQueryResult(GridDiagnosticQueryStatus.InvalidGrid, 0, 0);
 72            }
 73
 174            if (RequiresMissingAddressBounds(requestedGrid, query, hasBounds))
 075                return new GridDiagnosticQueryResult(GridDiagnosticQueryStatus.MissingAddressSpaceRequiresBounds, 0, 0);
 76
 177            return VisitGridCells(world, requestedGrid, query, hasBounds, queryBounds, ref visitor);
 78        }
 79
 5980        int cellCount = 0;
 5981        int skippedCellCount = 0;
 5982        if (RequiresMissingAddressBounds(world, query, hasBounds))
 283            return new GridDiagnosticQueryResult(GridDiagnosticQueryStatus.MissingAddressSpaceRequiresBounds, 0, 0);
 84
 30085        foreach (VoxelGrid grid in world.ActiveGrids)
 86        {
 9587            if (!ShouldVisitGrid(grid, query))
 88                continue;
 89
 9290            GridDiagnosticQueryStatus status = VisitGridCells(
 9291                world,
 9292                grid,
 9293                query,
 9294                hasBounds,
 9295                queryBounds,
 9296                ref visitor,
 9297                ref cellCount,
 9298                ref skippedCellCount);
 99
 92100            if (status != GridDiagnosticQueryStatus.Completed)
 4101                return new GridDiagnosticQueryResult(status, cellCount, skippedCellCount);
 102        }
 103
 53104        return new GridDiagnosticQueryResult(GridDiagnosticQueryStatus.Completed, cellCount, skippedCellCount);
 4105    }
 106
 107    /// <summary>
 108    /// Resolves a physical diagnostic cell descriptor back to its active grid
 109    /// and voxel.
 110    /// </summary>
 111    public static bool TryResolvePhysicalCell(
 112        GridWorld world,
 113        in GridDiagnosticCell cell,
 114        out VoxelGrid? grid,
 115        out Voxel? voxel)
 116    {
 4117        grid = null;
 4118        voxel = null;
 119
 4120        if (world == null
 4121            || cell.Kind != GridDiagnosticCellKind.Physical
 4122            || cell.WorldSpawnToken != world.SpawnToken
 4123            || cell.WorldIndex.WorldSpawnToken != cell.WorldSpawnToken
 4124            || cell.WorldIndex.GridIndex != cell.GridIndex
 4125            || cell.WorldIndex.GridSpawnToken != cell.GridSpawnToken
 4126            || cell.WorldIndex.VoxelIndex != cell.Index)
 127        {
 3128            return false;
 129        }
 130
 1131        return world.TryGetGridAndVoxel(cell.WorldIndex, out grid, out voxel);
 132    }
 133
 134    private static GridDiagnosticQueryResult VisitGridCells<TVisitor>(
 135        GridWorld world,
 136        VoxelGrid grid,
 137        in GridDiagnosticQuery query,
 138        bool hasBounds,
 139        TopologyVoxelAabb queryBounds,
 140        ref TVisitor visitor)
 141        where TVisitor : struct, IGridDiagnosticCellVisitor
 142    {
 1143        int cellCount = 0;
 1144        int skippedCellCount = 0;
 145
 1146        if (!ShouldVisitGrid(grid, query))
 0147            return new GridDiagnosticQueryResult(GridDiagnosticQueryStatus.Completed, 0, 0);
 148
 1149        GridDiagnosticQueryStatus status = VisitGridCells(
 1150            world,
 1151            grid,
 1152            query,
 1153            hasBounds,
 1154            queryBounds,
 1155            ref visitor,
 1156            ref cellCount,
 1157            ref skippedCellCount);
 158
 1159        return new GridDiagnosticQueryResult(status, cellCount, skippedCellCount);
 160    }
 161
 162    private static GridDiagnosticQueryStatus VisitGridCells<TVisitor>(
 163        GridWorld world,
 164        VoxelGrid grid,
 165        in GridDiagnosticQuery query,
 166        bool hasBounds,
 167        TopologyVoxelAabb queryBounds,
 168        ref TVisitor visitor,
 169        ref int cellCount,
 170        ref int skippedCellCount)
 171        where TVisitor : struct, IGridDiagnosticCellVisitor =>
 93172        UsesSparseAddressTraversal(grid, query)
 93173            ? VisitSparseAddressCells(
 93174                world,
 93175                grid,
 93176                query,
 93177                hasBounds,
 93178                queryBounds,
 93179                ref visitor,
 93180                ref cellCount,
 93181                ref skippedCellCount)
 93182            : VisitPhysicalCells(
 93183                world,
 93184                grid,
 93185                query,
 93186                hasBounds,
 93187                queryBounds,
 93188                ref visitor,
 93189                ref cellCount,
 93190                ref skippedCellCount);
 191
 192    private static GridDiagnosticQueryStatus VisitPhysicalCells<TVisitor>(
 193        GridWorld world,
 194        VoxelGrid grid,
 195        in GridDiagnosticQuery query,
 196        bool hasBounds,
 197        TopologyVoxelAabb queryBounds,
 198        ref TVisitor visitor,
 199        ref int cellCount,
 200        ref int skippedCellCount)
 201        where TVisitor : struct, IGridDiagnosticCellVisitor
 202    {
 87203        if (query.AddressMode == GridDiagnosticAddressMode.MissingOnly)
 1204            return GridDiagnosticQueryStatus.Completed;
 205
 86206        VoxelIndex minIndex = default;
 86207        VoxelIndex maxIndex = default;
 86208        if (hasBounds
 86209            && !TopologyVoxelRangeUtility.TryGetCandidateRange(grid, queryBounds, out minIndex, out maxIndex))
 210        {
 0211            return GridDiagnosticQueryStatus.Completed;
 212        }
 213
 86214        PhysicalCellVisitor<TVisitor> physicalVisitor = new(
 86215            world,
 86216            grid,
 86217            query,
 86218            hasBounds,
 86219            queryBounds,
 86220            minIndex,
 86221            maxIndex,
 86222            visitor,
 86223            cellCount,
 86224            skippedCellCount);
 225
 86226        grid.VisitVoxels(ref physicalVisitor);
 86227        visitor = physicalVisitor.Visitor;
 86228        cellCount = physicalVisitor.CellCount;
 86229        skippedCellCount = physicalVisitor.SkippedCellCount;
 86230        return physicalVisitor.Status;
 231    }
 232
 233    private static GridDiagnosticQueryStatus VisitSparseAddressCells<TVisitor>(
 234        GridWorld world,
 235        VoxelGrid grid,
 236        in GridDiagnosticQuery query,
 237        bool hasBounds,
 238        TopologyVoxelAabb queryBounds,
 239        ref TVisitor visitor,
 240        ref int cellCount,
 241        ref int skippedCellCount)
 242        where TVisitor : struct, IGridDiagnosticCellVisitor
 243    {
 6244        if (!TryGetSparseAddressRange(grid, hasBounds, queryBounds, out VoxelIndex minIndex, out VoxelIndex maxIndex))
 0245            return GridDiagnosticQueryStatus.Completed;
 246
 30247        for (int x = minIndex.x; x <= maxIndex.x; x++)
 248        {
 40249            for (int y = minIndex.y; y <= maxIndex.y; y++)
 250            {
 68251                for (int z = minIndex.z; z <= maxIndex.z; z++)
 252                {
 25253                    VoxelIndex index = new(x, y, z);
 25254                    if (hasBounds && !IsIndexInQueryBounds(grid, index, queryBounds))
 255                        continue;
 256
 25257                    if (grid.ContainsVoxel(index))
 258                    {
 8259                        if (query.AddressMode == GridDiagnosticAddressMode.MissingOnly)
 260                            continue;
 261
 4262                        if (!grid.TryGetVoxel(index, out Voxel? voxel) || voxel == null)
 263                            continue;
 264
 4265                        GridDiagnosticCellState state = GetCellState(voxel);
 4266                        if (!MatchesStateFilters(state, query.RequiredStates, query.ExcludedStates))
 267                            continue;
 268
 4269                        GridDiagnosticCell physicalCell = CreatePhysicalCell(world, grid, voxel, state);
 4270                        if (!TryVisitCell(in physicalCell, query.MaxCells, ref visitor, ref cellCount, ref skippedCellCo
 1271                            return physicalStatus;
 272
 273                        continue;
 274                    }
 275
 17276                    GridDiagnosticCellState missingState = GetMissingAddressCellState(grid, index);
 17277                    if (!MatchesStateFilters(missingState, query.RequiredStates, query.ExcludedStates))
 278                        continue;
 279
 17280                    GridDiagnosticCell missingCell = CreateMissingAddressCell(world, grid, index, missingState);
 17281                    if (!TryVisitCell(in missingCell, query.MaxCells, ref visitor, ref cellCount, ref skippedCellCount, 
 1282                        return missingStatus;
 283                }
 284            }
 285        }
 286
 4287        return GridDiagnosticQueryStatus.Completed;
 288    }
 289
 290    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 291    private static bool ShouldVisitGrid(
 292        VoxelGrid grid,
 293        in GridDiagnosticQuery query)
 294    {
 99295        if (!grid.IsActive)
 0296            return false;
 297
 99298        if (query.TopologyKind.HasValue && grid.Configuration.TopologyKind != query.TopologyKind.Value)
 2299            return false;
 300
 97301        return !query.StorageKind.HasValue || grid.StorageKind == query.StorageKind.Value;
 302    }
 303
 304    private static bool RequiresMissingAddressBounds(
 305        GridWorld world,
 306        in GridDiagnosticQuery query,
 307        bool hasBounds)
 308    {
 59309        if (!RequiresMissingAddressBounds(query, hasBounds))
 57310            return false;
 311
 6312        foreach (VoxelGrid grid in world.ActiveGrids)
 313        {
 2314            if (ShouldVisitGrid(grid, query) && grid.StorageKind == GridStorageKind.Sparse)
 2315                return true;
 316        }
 317
 0318        return false;
 2319    }
 320
 321    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 322    private static bool RequiresMissingAddressBounds(
 323        VoxelGrid grid,
 324        in GridDiagnosticQuery query,
 325        bool hasBounds) =>
 1326        ShouldVisitGrid(grid, query)
 1327        && grid.StorageKind == GridStorageKind.Sparse
 1328        && RequiresMissingAddressBounds(query, hasBounds);
 329
 330    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 331    private static bool RequiresMissingAddressBounds(
 332        in GridDiagnosticQuery query,
 333        bool hasBounds) =>
 60334        UsesMissingAddressMode(query.AddressMode)
 60335        && !hasBounds
 60336        && !query.AllowFullAddressSpaceScan;
 337
 338    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 339    private static bool UsesSparseAddressTraversal(
 340        VoxelGrid grid,
 341        in GridDiagnosticQuery query) =>
 93342        grid.StorageKind == GridStorageKind.Sparse
 93343        && UsesMissingAddressMode(query.AddressMode);
 344
 345    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 346    private static bool UsesMissingAddressMode(GridDiagnosticAddressMode addressMode) =>
 103347        addressMode == GridDiagnosticAddressMode.PhysicalAndMissing
 103348        || addressMode == GridDiagnosticAddressMode.MissingOnly;
 349
 350    private static bool TryGetQueryBounds(
 351        in GridDiagnosticQuery query,
 352        out TopologyVoxelAabb bounds)
 353    {
 61354        bounds = default;
 61355        if (!query.BoundsMin.HasValue || !query.BoundsMax.HasValue)
 51356            return false;
 357
 10358        Vector3d min = query.BoundsMin.Value;
 10359        Vector3d max = query.BoundsMax.Value;
 10360        bounds = new TopologyVoxelAabb(
 10361            new Vector3d(
 10362                FixedMath.Min(min.X, max.X),
 10363                FixedMath.Min(min.Y, max.Y),
 10364                FixedMath.Min(min.Z, max.Z)),
 10365            new Vector3d(
 10366                FixedMath.Max(min.X, max.X),
 10367                FixedMath.Max(min.Y, max.Y),
 10368                FixedMath.Max(min.Z, max.Z)));
 10369        return true;
 370    }
 371
 372    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 373    private static bool IsVoxelInQueryBounds(
 374        VoxelGrid grid,
 375        Voxel voxel,
 376        TopologyVoxelAabb queryBounds,
 377        VoxelIndex minIndex,
 378        VoxelIndex maxIndex)
 379    {
 40380        VoxelIndex index = voxel.Index;
 40381        if (index.x < minIndex.x
 40382            || index.x > maxIndex.x
 40383            || index.y < minIndex.y
 40384            || index.y > maxIndex.y
 40385            || index.z < minIndex.z
 40386            || index.z > maxIndex.z)
 387        {
 21388            return false;
 389        }
 390
 19391        TopologyVoxelAabb voxelBounds = TopologyVoxelAabb.FromVoxel(grid, voxel);
 19392        return voxelBounds.Overlaps(queryBounds, Fixed64.Zero);
 393    }
 394
 395    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 396    private static bool IsIndexInQueryBounds(
 397        VoxelGrid grid,
 398        VoxelIndex index,
 399        TopologyVoxelAabb queryBounds)
 400    {
 22401        TopologyVoxelAabb voxelBounds = TopologyVoxelAabb.FromIndex(grid, index);
 22402        return voxelBounds.Overlaps(queryBounds, Fixed64.Zero);
 403    }
 404
 405    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 406    private static GridDiagnosticCellState GetCellState(Voxel voxel)
 407    {
 8788408        GridDiagnosticCellState state = GridDiagnosticCellState.None;
 8788409        if (!voxel.IsOccupied && !voxel.IsBlocked)
 8776410            state |= GridDiagnosticCellState.Empty;
 411
 8788412        if (voxel.IsOccupied)
 6413            state |= GridDiagnosticCellState.Occupied;
 414
 8788415        if (voxel.IsBlocked)
 6416            state |= GridDiagnosticCellState.Blocked;
 417
 8788418        if (voxel.IsBoundaryVoxel)
 8782419            state |= GridDiagnosticCellState.Boundary;
 420
 8788421        if (voxel.IsPartioned)
 6422            state |= GridDiagnosticCellState.Partitioned;
 423
 8788424        return state;
 425    }
 426
 427    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 428    private static GridDiagnosticCellState GetMissingAddressCellState(
 429        VoxelGrid grid,
 430        VoxelIndex index)
 431    {
 17432        GridDiagnosticCellState state = GridDiagnosticCellState.MissingSparseAddress;
 17433        if (grid.IsOnBoundary(index))
 17434            state |= GridDiagnosticCellState.Boundary;
 435
 17436        return state;
 437    }
 438
 439    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 440    private static bool MatchesStateFilters(
 441        GridDiagnosticCellState state,
 442        GridDiagnosticCellState requiredStates,
 443        GridDiagnosticCellState excludedStates)
 444    {
 8805445        if (requiredStates != GridDiagnosticCellState.None && (state & requiredStates) != requiredStates)
 81446            return false;
 447
 8724448        return excludedStates == GridDiagnosticCellState.None || (state & excludedStates) == 0;
 449    }
 450
 451    private static bool TryGetSparseAddressRange(
 452        VoxelGrid grid,
 453        bool hasBounds,
 454        TopologyVoxelAabb queryBounds,
 455        out VoxelIndex minIndex,
 456        out VoxelIndex maxIndex)
 457    {
 6458        if (hasBounds)
 5459            return TopologyVoxelRangeUtility.TryGetCandidateRange(grid, queryBounds, out minIndex, out maxIndex);
 460
 1461        minIndex = new VoxelIndex(0, 0, 0);
 1462        maxIndex = new VoxelIndex(grid.Width - 1, grid.Height - 1, grid.Length - 1);
 1463        return grid.Width > 0 && grid.Height > 0 && grid.Length > 0;
 464    }
 465
 466    private static bool TryVisitCell<TVisitor>(
 467        in GridDiagnosticCell cell,
 468        int maxCells,
 469        ref TVisitor visitor,
 470        ref int cellCount,
 471        ref int skippedCellCount,
 472        out GridDiagnosticQueryStatus status)
 473        where TVisitor : struct, IGridDiagnosticCellVisitor
 474    {
 8698475        if (cellCount >= maxCells)
 476        {
 3477            skippedCellCount++;
 3478            status = GridDiagnosticQueryStatus.MaxCellsExceeded;
 3479            return false;
 480        }
 481
 8695482        cellCount++;
 8695483        if (!visitor.Visit(in cell))
 484        {
 1485            skippedCellCount++;
 1486            status = GridDiagnosticQueryStatus.Truncated;
 1487            return false;
 488        }
 489
 8694490        status = GridDiagnosticQueryStatus.Completed;
 8694491        return true;
 492    }
 493
 494    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 495    private static GridDiagnosticCell CreatePhysicalCell(
 496        GridWorld world,
 497        VoxelGrid grid,
 498        Voxel voxel,
 499        GridDiagnosticCellState state) =>
 8681500        new(
 8681501            GridDiagnosticCellKind.Physical,
 8681502            world.SpawnToken,
 8681503            grid.GridIndex,
 8681504            grid.SpawnToken,
 8681505            voxel.Index,
 8681506            voxel.WorldPosition,
 8681507            grid.Configuration.TopologyKind,
 8681508            grid.StorageKind,
 8681509            grid.Configuration.TopologyMetrics,
 8681510            state,
 8681511            voxel.WorldIndex);
 512
 513    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 514    private static GridDiagnosticCell CreateMissingAddressCell(
 515        GridWorld world,
 516        VoxelGrid grid,
 517        VoxelIndex index,
 518        GridDiagnosticCellState state) =>
 17519        new(
 17520            GridDiagnosticCellKind.MissingSparseAddress,
 17521            world.SpawnToken,
 17522            grid.GridIndex,
 17523            grid.SpawnToken,
 17524            index,
 17525            grid.GetWorldPosition(index),
 17526            grid.Configuration.TopologyKind,
 17527            GridStorageKind.Sparse,
 17528            grid.Configuration.TopologyMetrics,
 17529            state,
 17530            new WorldVoxelIndex(world.SpawnToken, grid.GridIndex, grid.SpawnToken, index));
 531
 532    private struct ResultListVisitor : IGridDiagnosticCellVisitor
 533    {
 534        private readonly SwiftList<GridDiagnosticCell> _results;
 535
 536        public ResultListVisitor(SwiftList<GridDiagnosticCell> results)
 537        {
 28538            _results = results;
 28539        }
 540
 541        public bool Visit(in GridDiagnosticCell cell)
 542        {
 112543            _results.Add(cell);
 112544            return true;
 545        }
 546    }
 547
 548    private struct PhysicalCellVisitor<TVisitor> : IVoxelStorageVisitor
 549        where TVisitor : struct, IGridDiagnosticCellVisitor
 550    {
 551        private readonly GridWorld _world;
 552        private readonly VoxelGrid _grid;
 553        private readonly GridDiagnosticQuery _query;
 554        private readonly bool _hasBounds;
 555        private readonly TopologyVoxelAabb _queryBounds;
 556        private readonly VoxelIndex _minIndex;
 557        private readonly VoxelIndex _maxIndex;
 558
 559        public TVisitor Visitor;
 560        public int CellCount;
 561        public int SkippedCellCount;
 562        public GridDiagnosticQueryStatus Status;
 563
 564        public PhysicalCellVisitor(
 565            GridWorld world,
 566            VoxelGrid grid,
 567            in GridDiagnosticQuery query,
 568            bool hasBounds,
 569            TopologyVoxelAabb queryBounds,
 570            VoxelIndex minIndex,
 571            VoxelIndex maxIndex,
 572            TVisitor visitor,
 573            int cellCount,
 574            int skippedCellCount)
 575        {
 86576            _world = world;
 86577            _grid = grid;
 86578            _query = query;
 86579            _hasBounds = hasBounds;
 86580            _queryBounds = queryBounds;
 86581            _minIndex = minIndex;
 86582            _maxIndex = maxIndex;
 86583            Visitor = visitor;
 86584            CellCount = cellCount;
 86585            SkippedCellCount = skippedCellCount;
 86586            Status = GridDiagnosticQueryStatus.Completed;
 86587        }
 588
 589        public bool Visit(Voxel voxel)
 590        {
 8813591            if (_hasBounds && !IsVoxelInQueryBounds(_grid, voxel, _queryBounds, _minIndex, _maxIndex))
 29592                return true;
 593
 8784594            GridDiagnosticCellState state = GetCellState(voxel);
 8784595            if (!MatchesStateFilters(state, _query.RequiredStates, _query.ExcludedStates))
 107596                return true;
 597
 8677598            GridDiagnosticCell cell = CreatePhysicalCell(_world, _grid, voxel, state);
 8677599            return TryVisitCell(
 8677600                in cell,
 8677601                _query.MaxCells,
 8677602                ref Visitor,
 8677603                ref CellCount,
 8677604                ref SkippedCellCount,
 8677605                out Status);
 606        }
 607    }
 608}
Generated by: ReportGenerator 5.5.10.0
06/22/2026 - 03:11:01
GitHub | reportgenerator.io

Methods/Properties

GetCellsInto(GridForge.Grids.GridWorld,GridForge.Diagnostics.GridDiagnosticQuery&,SwiftCollections.SwiftList`1<GridForge.Diagnostics.GridDiagnosticCell>,GridForge.Diagnostics.GridDiagnosticScratch)
VisitCells(GridForge.Grids.GridWorld,GridForge.Diagnostics.GridDiagnosticQuery&,TVisitor&,GridForge.Diagnostics.GridDiagnosticScratch)
VisitCellsCore(GridForge.Grids.GridWorld,GridForge.Diagnostics.GridDiagnosticQuery&,TVisitor&,GridForge.Diagnostics.GridDiagnosticScratch)
TryResolvePhysicalCell(GridForge.Grids.GridWorld,GridForge.Diagnostics.GridDiagnosticCell&,GridForge.Grids.VoxelGrid&,GridForge.Grids.Voxel&)
VisitGridCells(GridForge.Grids.GridWorld,GridForge.Grids.VoxelGrid,GridForge.Diagnostics.GridDiagnosticQuery&,System.Boolean,GridForge.Grids.Topology.TopologyVoxelAabb,TVisitor&)
VisitGridCells(GridForge.Grids.GridWorld,GridForge.Grids.VoxelGrid,GridForge.Diagnostics.GridDiagnosticQuery&,System.Boolean,GridForge.Grids.Topology.TopologyVoxelAabb,TVisitor&,System.Int32&,System.Int32&)
VisitPhysicalCells(GridForge.Grids.GridWorld,GridForge.Grids.VoxelGrid,GridForge.Diagnostics.GridDiagnosticQuery&,System.Boolean,GridForge.Grids.Topology.TopologyVoxelAabb,TVisitor&,System.Int32&,System.Int32&)
VisitSparseAddressCells(GridForge.Grids.GridWorld,GridForge.Grids.VoxelGrid,GridForge.Diagnostics.GridDiagnosticQuery&,System.Boolean,GridForge.Grids.Topology.TopologyVoxelAabb,TVisitor&,System.Int32&,System.Int32&)
ShouldVisitGrid(GridForge.Grids.VoxelGrid,GridForge.Diagnostics.GridDiagnosticQuery&)
RequiresMissingAddressBounds(GridForge.Grids.GridWorld,GridForge.Diagnostics.GridDiagnosticQuery&,System.Boolean)
RequiresMissingAddressBounds(GridForge.Grids.VoxelGrid,GridForge.Diagnostics.GridDiagnosticQuery&,System.Boolean)
RequiresMissingAddressBounds(GridForge.Diagnostics.GridDiagnosticQuery&,System.Boolean)
UsesSparseAddressTraversal(GridForge.Grids.VoxelGrid,GridForge.Diagnostics.GridDiagnosticQuery&)
UsesMissingAddressMode(GridForge.Diagnostics.GridDiagnosticAddressMode)
TryGetQueryBounds(GridForge.Diagnostics.GridDiagnosticQuery&,GridForge.Grids.Topology.TopologyVoxelAabb&)
IsVoxelInQueryBounds(GridForge.Grids.VoxelGrid,GridForge.Grids.Voxel,GridForge.Grids.Topology.TopologyVoxelAabb,GridForge.Spatial.VoxelIndex,GridForge.Spatial.VoxelIndex)
IsIndexInQueryBounds(GridForge.Grids.VoxelGrid,GridForge.Spatial.VoxelIndex,GridForge.Grids.Topology.TopologyVoxelAabb)
GetCellState(GridForge.Grids.Voxel)
GetMissingAddressCellState(GridForge.Grids.VoxelGrid,GridForge.Spatial.VoxelIndex)
MatchesStateFilters(GridForge.Diagnostics.GridDiagnosticCellState,GridForge.Diagnostics.GridDiagnosticCellState,GridForge.Diagnostics.GridDiagnosticCellState)
TryGetSparseAddressRange(GridForge.Grids.VoxelGrid,System.Boolean,GridForge.Grids.Topology.TopologyVoxelAabb,GridForge.Spatial.VoxelIndex&,GridForge.Spatial.VoxelIndex&)
TryVisitCell(GridForge.Diagnostics.GridDiagnosticCell&,System.Int32,TVisitor&,System.Int32&,System.Int32&,GridForge.Diagnostics.GridDiagnosticQueryStatus&)
CreatePhysicalCell(GridForge.Grids.GridWorld,GridForge.Grids.VoxelGrid,GridForge.Grids.Voxel,GridForge.Diagnostics.GridDiagnosticCellState)
CreateMissingAddressCell(GridForge.Grids.GridWorld,GridForge.Grids.VoxelGrid,GridForge.Spatial.VoxelIndex,GridForge.Diagnostics.GridDiagnosticCellState)
.ctor(SwiftCollections.SwiftList`1<GridForge.Diagnostics.GridDiagnosticCell>)
Visit(GridForge.Diagnostics.GridDiagnosticCell&)
.ctor(GridForge.Grids.GridWorld,GridForge.Grids.VoxelGrid,GridForge.Diagnostics.GridDiagnosticQuery&,System.Boolean,GridForge.Grids.Topology.TopologyVoxelAabb,GridForge.Spatial.VoxelIndex,GridForge.Spatial.VoxelIndex,TVisitor,System.Int32,System.Int32)
Visit(GridForge.Grids.Voxel)