< Summary

Information
Class: GridForge.Diagnostics.GridDiagnostics
Assembly: GridForge
File(s): /home/runner/work/GridForge/GridForge/src/GridForge/Diagnostics/GridDiagnostics.cs
Line coverage
100%
Covered lines: 258
Uncovered lines: 0
Coverable lines: 258
Total lines: 602
Line coverage: 100%
Branch coverage
100%
Covered branches: 146
Total branches: 146
Branch coverage: 100%
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(...)100%2020100%
TryResolvePhysicalCell(...)100%1414100%
VisitGridCells(...)100%22100%
VisitGridCells(...)100%22100%
VisitPhysicalCells(...)100%66100%
VisitSparseAddressCells(...)100%2828100%
ShouldVisitGrid(...)100%66100%
RequiresMissingAddressBounds(...)100%88100%
RequiresMissingAddressBounds(...)100%44100%
RequiresMissingAddressBounds(...)100%44100%
UsesSparseAddressTraversal(...)100%22100%
UsesMissingAddressMode(...)100%22100%
TryGetQueryBounds(...)100%44100%
IsVoxelInQueryBounds(...)100%1212100%
IsIndexInQueryBounds(...)100%11100%
GetCellState(...)100%1212100%
GetMissingAddressCellState(...)100%22100%
MatchesStateFilters(...)100%66100%
TryGetSparseAddressRange(...)100%22100%
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 System.Runtime.CompilerServices;
 9using FixedMathSharp;
 10using GridForge.Grids;
 11using GridForge.Grids.Storage;
 12using GridForge.Grids.Topology;
 13using GridForge.Spatial;
 14using SwiftCollections;
 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    {
 3832        SwiftThrowHelper.ThrowIfNull(results, nameof(results));
 33
 3734        results.Clear();
 35
 3736        ResultListVisitor visitor = new(results);
 3737        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    {
 3650        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    {
 7360        scratch?.Clear();
 7361        if (world == null || !world.IsActive)
 362            return new GridDiagnosticQueryResult(GridDiagnosticQueryStatus.InactiveWorld, 0, 0);
 63
 7064        bool hasBounds = TryGetQueryBounds(query, out TopologyVoxelAabb queryBounds);
 7065        if (query.GridIndex.HasValue)
 66        {
 767            if (!world.TryGetGrid(query.GridIndex.Value, out VoxelGrid? requestedGrid))
 168                return new GridDiagnosticQueryResult(GridDiagnosticQueryStatus.InvalidGrid, 0, 0);
 69
 670            VoxelGrid grid = requestedGrid!;
 671            if (RequiresMissingAddressBounds(grid, query, hasBounds))
 172                return new GridDiagnosticQueryResult(GridDiagnosticQueryStatus.MissingAddressSpaceRequiresBounds, 0, 0);
 73
 574            return VisitGridCells(world, grid, query, hasBounds, queryBounds, ref visitor);
 75        }
 76
 6377        int cellCount = 0;
 6378        int skippedCellCount = 0;
 6379        if (RequiresMissingAddressBounds(world, query, hasBounds))
 280            return new GridDiagnosticQueryResult(GridDiagnosticQueryStatus.MissingAddressSpaceRequiresBounds, 0, 0);
 81
 31682        foreach (VoxelGrid grid in world.ActiveGrids)
 83        {
 9984            if (!ShouldVisitGrid(grid, query))
 85                continue;
 86
 9687            GridDiagnosticQueryStatus status = VisitGridCells(
 9688                world,
 9689                grid,
 9690                query,
 9691                hasBounds,
 9692                queryBounds,
 9693                ref visitor,
 9694                ref cellCount,
 9695                ref skippedCellCount);
 96
 9697            if (status != GridDiagnosticQueryStatus.Completed)
 498                return new GridDiagnosticQueryResult(status, cellCount, skippedCellCount);
 99        }
 100
 57101        return new GridDiagnosticQueryResult(GridDiagnosticQueryStatus.Completed, cellCount, skippedCellCount);
 4102    }
 103
 104    /// <summary>
 105    /// Resolves a physical diagnostic cell descriptor back to its active grid
 106    /// and voxel.
 107    /// </summary>
 108    public static bool TryResolvePhysicalCell(
 109        GridWorld world,
 110        in GridDiagnosticCell cell,
 111        out VoxelGrid? grid,
 112        out Voxel? voxel)
 113    {
 10114        grid = null;
 10115        voxel = null;
 116
 10117        if (world == null
 10118            || cell.Kind != GridDiagnosticCellKind.Physical
 10119            || cell.WorldSpawnToken != world.SpawnToken
 10120            || cell.WorldIndex.WorldSpawnToken != cell.WorldSpawnToken
 10121            || cell.WorldIndex.GridIndex != cell.GridIndex
 10122            || cell.WorldIndex.GridSpawnToken != cell.GridSpawnToken
 10123            || cell.WorldIndex.VoxelIndex != cell.Index)
 124        {
 9125            return false;
 126        }
 127
 1128        return world.TryGetGridAndVoxel(cell.WorldIndex, out grid, out voxel);
 129    }
 130
 131    private static GridDiagnosticQueryResult VisitGridCells<TVisitor>(
 132        GridWorld world,
 133        VoxelGrid grid,
 134        in GridDiagnosticQuery query,
 135        bool hasBounds,
 136        TopologyVoxelAabb queryBounds,
 137        ref TVisitor visitor)
 138        where TVisitor : struct, IGridDiagnosticCellVisitor
 139    {
 5140        int cellCount = 0;
 5141        int skippedCellCount = 0;
 142
 5143        if (!ShouldVisitGrid(grid, query))
 2144            return new GridDiagnosticQueryResult(GridDiagnosticQueryStatus.Completed, 0, 0);
 145
 3146        GridDiagnosticQueryStatus status = VisitGridCells(
 3147            world,
 3148            grid,
 3149            query,
 3150            hasBounds,
 3151            queryBounds,
 3152            ref visitor,
 3153            ref cellCount,
 3154            ref skippedCellCount);
 155
 3156        return new GridDiagnosticQueryResult(status, cellCount, skippedCellCount);
 157    }
 158
 159    private static GridDiagnosticQueryStatus VisitGridCells<TVisitor>(
 160        GridWorld world,
 161        VoxelGrid grid,
 162        in GridDiagnosticQuery query,
 163        bool hasBounds,
 164        TopologyVoxelAabb queryBounds,
 165        ref TVisitor visitor,
 166        ref int cellCount,
 167        ref int skippedCellCount)
 168        where TVisitor : struct, IGridDiagnosticCellVisitor =>
 99169        UsesSparseAddressTraversal(grid, query)
 99170            ? VisitSparseAddressCells(
 99171                world,
 99172                grid,
 99173                query,
 99174                hasBounds,
 99175                queryBounds,
 99176                ref visitor,
 99177                ref cellCount,
 99178                ref skippedCellCount)
 99179            : VisitPhysicalCells(
 99180                world,
 99181                grid,
 99182                query,
 99183                hasBounds,
 99184                queryBounds,
 99185                ref visitor,
 99186                ref cellCount,
 99187                ref skippedCellCount);
 188
 189    private static GridDiagnosticQueryStatus VisitPhysicalCells<TVisitor>(
 190        GridWorld world,
 191        VoxelGrid grid,
 192        in GridDiagnosticQuery query,
 193        bool hasBounds,
 194        TopologyVoxelAabb queryBounds,
 195        ref TVisitor visitor,
 196        ref int cellCount,
 197        ref int skippedCellCount)
 198        where TVisitor : struct, IGridDiagnosticCellVisitor
 199    {
 90200        if (query.AddressMode == GridDiagnosticAddressMode.MissingOnly)
 2201            return GridDiagnosticQueryStatus.Completed;
 202
 88203        VoxelIndex minIndex = default;
 88204        VoxelIndex maxIndex = default;
 88205        if (hasBounds
 88206            && !TopologyVoxelRangeUtility.TryGetCandidateRange(grid, queryBounds, out minIndex, out maxIndex))
 207        {
 1208            return GridDiagnosticQueryStatus.Completed;
 209        }
 210
 87211        PhysicalCellVisitor<TVisitor> physicalVisitor = new(
 87212            world,
 87213            grid,
 87214            query,
 87215            hasBounds,
 87216            queryBounds,
 87217            minIndex,
 87218            maxIndex,
 87219            visitor,
 87220            cellCount,
 87221            skippedCellCount);
 222
 87223        grid.VisitVoxels(ref physicalVisitor);
 87224        visitor = physicalVisitor.Visitor;
 87225        cellCount = physicalVisitor.CellCount;
 87226        skippedCellCount = physicalVisitor.SkippedCellCount;
 87227        return physicalVisitor.Status;
 228    }
 229
 230    private static GridDiagnosticQueryStatus VisitSparseAddressCells<TVisitor>(
 231        GridWorld world,
 232        VoxelGrid grid,
 233        in GridDiagnosticQuery query,
 234        bool hasBounds,
 235        TopologyVoxelAabb queryBounds,
 236        ref TVisitor visitor,
 237        ref int cellCount,
 238        ref int skippedCellCount)
 239        where TVisitor : struct, IGridDiagnosticCellVisitor
 240    {
 9241        if (!TryGetSparseAddressRange(grid, hasBounds, queryBounds, out VoxelIndex minIndex, out VoxelIndex maxIndex))
 1242            return GridDiagnosticQueryStatus.Completed;
 243
 42244        for (int x = minIndex.x; x <= maxIndex.x; x++)
 245        {
 72246            for (int y = minIndex.y; y <= maxIndex.y; y++)
 247            {
 152248                for (int z = minIndex.z; z <= maxIndex.z; z++)
 249                {
 55250                    VoxelIndex index = new(x, y, z);
 55251                    if (hasBounds && !IsIndexInQueryBounds(grid, index, queryBounds))
 252                        continue;
 253
 55254                    if (grid.ContainsVoxel(index))
 255                    {
 8256                        if (query.AddressMode == GridDiagnosticAddressMode.MissingOnly)
 257                            continue;
 258
 4259                        if (!grid.TryGetVoxel(index, out Voxel? voxel) || voxel == null)
 260                            continue;
 261
 4262                        GridDiagnosticCellState state = GetCellState(voxel);
 4263                        if (!MatchesStateFilters(state, query.RequiredStates, query.ExcludedStates))
 264                            continue;
 265
 4266                        GridDiagnosticCell physicalCell = CreatePhysicalCell(world, grid, voxel, state);
 4267                        if (!TryVisitCell(in physicalCell, query.MaxCells, ref visitor, ref cellCount, ref skippedCellCo
 1268                            return physicalStatus;
 269
 270                        continue;
 271                    }
 272
 47273                    GridDiagnosticCellState missingState = GetMissingAddressCellState(grid, index);
 47274                    if (!MatchesStateFilters(missingState, query.RequiredStates, query.ExcludedStates))
 275                        continue;
 276
 47277                    GridDiagnosticCell missingCell = CreateMissingAddressCell(world, grid, index, missingState);
 47278                    if (!TryVisitCell(in missingCell, query.MaxCells, ref visitor, ref cellCount, ref skippedCellCount, 
 1279                        return missingStatus;
 280                }
 281            }
 282        }
 283
 6284        return GridDiagnosticQueryStatus.Completed;
 285    }
 286
 287    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 288    private static bool ShouldVisitGrid(
 289        VoxelGrid grid,
 290        in GridDiagnosticQuery query)
 291    {
 113292        if (query.TopologyKind.HasValue && grid.Configuration.TopologyKind != query.TopologyKind.Value)
 4293            return false;
 294
 109295        return !query.StorageKind.HasValue || grid.StorageKind == query.StorageKind.Value;
 296    }
 297
 298    private static bool RequiresMissingAddressBounds(
 299        GridWorld world,
 300        in GridDiagnosticQuery query,
 301        bool hasBounds)
 302    {
 63303        if (!RequiresMissingAddressBounds(query, hasBounds))
 60304            return false;
 305
 10306        foreach (VoxelGrid grid in world.ActiveGrids)
 307        {
 3308            if (ShouldVisitGrid(grid, query) && grid.StorageKind == GridStorageKind.Sparse)
 2309                return true;
 310        }
 311
 1312        return false;
 2313    }
 314
 315    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 316    private static bool RequiresMissingAddressBounds(
 317        VoxelGrid grid,
 318        in GridDiagnosticQuery query,
 319        bool hasBounds) =>
 6320        ShouldVisitGrid(grid, query)
 6321        && grid.StorageKind == GridStorageKind.Sparse
 6322        && RequiresMissingAddressBounds(query, hasBounds);
 323
 324    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 325    private static bool RequiresMissingAddressBounds(
 326        in GridDiagnosticQuery query,
 327        bool hasBounds) =>
 66328        UsesMissingAddressMode(query.AddressMode)
 66329        && !hasBounds
 66330        && !query.AllowFullAddressSpaceScan;
 331
 332    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 333    private static bool UsesSparseAddressTraversal(
 334        VoxelGrid grid,
 335        in GridDiagnosticQuery query) =>
 99336        grid.StorageKind == GridStorageKind.Sparse
 99337        && UsesMissingAddressMode(query.AddressMode);
 338
 339    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 340    private static bool UsesMissingAddressMode(GridDiagnosticAddressMode addressMode) =>
 112341        addressMode == GridDiagnosticAddressMode.PhysicalAndMissing
 112342        || addressMode == GridDiagnosticAddressMode.MissingOnly;
 343
 344    private static bool TryGetQueryBounds(
 345        in GridDiagnosticQuery query,
 346        out TopologyVoxelAabb bounds)
 347    {
 70348        bounds = default;
 70349        if (!query.BoundsMin.HasValue || !query.BoundsMax.HasValue)
 55350            return false;
 351
 15352        Vector3d min = query.BoundsMin.Value;
 15353        Vector3d max = query.BoundsMax.Value;
 15354        bounds = new TopologyVoxelAabb(
 15355            new Vector3d(
 15356                FixedMath.Min(min.X, max.X),
 15357                FixedMath.Min(min.Y, max.Y),
 15358                FixedMath.Min(min.Z, max.Z)),
 15359            new Vector3d(
 15360                FixedMath.Max(min.X, max.X),
 15361                FixedMath.Max(min.Y, max.Y),
 15362                FixedMath.Max(min.Z, max.Z)));
 15363        return true;
 364    }
 365
 366    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 367    private static bool IsVoxelInQueryBounds(
 368        VoxelGrid grid,
 369        Voxel voxel,
 370        TopologyVoxelAabb queryBounds,
 371        VoxelIndex minIndex,
 372        VoxelIndex maxIndex)
 373    {
 67374        VoxelIndex index = voxel.Index;
 67375        if (index.x < minIndex.x
 67376            || index.x > maxIndex.x
 67377            || index.y < minIndex.y
 67378            || index.y > maxIndex.y
 67379            || index.z < minIndex.z
 67380            || index.z > maxIndex.z)
 381        {
 47382            return false;
 383        }
 384
 20385        TopologyVoxelAabb voxelBounds = TopologyVoxelAabb.FromVoxel(grid, voxel);
 20386        return voxelBounds.Overlaps(queryBounds, Fixed64.Zero);
 387    }
 388
 389    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 390    private static bool IsIndexInQueryBounds(
 391        VoxelGrid grid,
 392        VoxelIndex index,
 393        TopologyVoxelAabb queryBounds)
 394    {
 52395        TopologyVoxelAabb voxelBounds = TopologyVoxelAabb.FromIndex(grid, index);
 52396        return voxelBounds.Overlaps(queryBounds, Fixed64.Zero);
 397    }
 398
 399    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 400    private static GridDiagnosticCellState GetCellState(Voxel voxel)
 401    {
 8789402        GridDiagnosticCellState state = GridDiagnosticCellState.None;
 8789403        if (!voxel.IsOccupied && !voxel.IsBlocked)
 8777404            state |= GridDiagnosticCellState.Empty;
 405
 8789406        if (voxel.IsOccupied)
 6407            state |= GridDiagnosticCellState.Occupied;
 408
 8789409        if (voxel.IsBlocked)
 6410            state |= GridDiagnosticCellState.Blocked;
 411
 8789412        if (voxel.IsBoundaryVoxel)
 8782413            state |= GridDiagnosticCellState.Boundary;
 414
 8789415        if (voxel.IsPartioned)
 6416            state |= GridDiagnosticCellState.Partitioned;
 417
 8789418        return state;
 419    }
 420
 421    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 422    private static GridDiagnosticCellState GetMissingAddressCellState(
 423        VoxelGrid grid,
 424        VoxelIndex index)
 425    {
 47426        GridDiagnosticCellState state = GridDiagnosticCellState.MissingSparseAddress;
 47427        if (grid.IsOnBoundary(index))
 46428            state |= GridDiagnosticCellState.Boundary;
 429
 47430        return state;
 431    }
 432
 433    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 434    private static bool MatchesStateFilters(
 435        GridDiagnosticCellState state,
 436        GridDiagnosticCellState requiredStates,
 437        GridDiagnosticCellState excludedStates)
 438    {
 8836439        if (requiredStates != GridDiagnosticCellState.None && (state & requiredStates) != requiredStates)
 81440            return false;
 441
 8755442        return excludedStates == GridDiagnosticCellState.None || (state & excludedStates) == 0;
 443    }
 444
 445    private static bool TryGetSparseAddressRange(
 446        VoxelGrid grid,
 447        bool hasBounds,
 448        TopologyVoxelAabb queryBounds,
 449        out VoxelIndex minIndex,
 450        out VoxelIndex maxIndex)
 451    {
 9452        if (hasBounds)
 8453            return TopologyVoxelRangeUtility.TryGetCandidateRange(grid, queryBounds, out minIndex, out maxIndex);
 454
 1455        minIndex = new VoxelIndex(0, 0, 0);
 1456        maxIndex = new VoxelIndex(grid.Width - 1, grid.Height - 1, grid.Length - 1);
 1457        return true;
 458    }
 459
 460    private static bool TryVisitCell<TVisitor>(
 461        in GridDiagnosticCell cell,
 462        int maxCells,
 463        ref TVisitor visitor,
 464        ref int cellCount,
 465        ref int skippedCellCount,
 466        out GridDiagnosticQueryStatus status)
 467        where TVisitor : struct, IGridDiagnosticCellVisitor
 468    {
 8729469        if (cellCount >= maxCells)
 470        {
 3471            skippedCellCount++;
 3472            status = GridDiagnosticQueryStatus.MaxCellsExceeded;
 3473            return false;
 474        }
 475
 8726476        cellCount++;
 8726477        if (!visitor.Visit(in cell))
 478        {
 1479            skippedCellCount++;
 1480            status = GridDiagnosticQueryStatus.Truncated;
 1481            return false;
 482        }
 483
 8725484        status = GridDiagnosticQueryStatus.Completed;
 8725485        return true;
 486    }
 487
 488    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 489    private static GridDiagnosticCell CreatePhysicalCell(
 490        GridWorld world,
 491        VoxelGrid grid,
 492        Voxel voxel,
 493        GridDiagnosticCellState state) =>
 8682494        new(
 8682495            GridDiagnosticCellKind.Physical,
 8682496            world.SpawnToken,
 8682497            grid.GridIndex,
 8682498            grid.SpawnToken,
 8682499            voxel.Index,
 8682500            voxel.WorldPosition,
 8682501            grid.Configuration.TopologyKind,
 8682502            grid.StorageKind,
 8682503            grid.Configuration.TopologyMetrics,
 8682504            state,
 8682505            voxel.WorldIndex);
 506
 507    [MethodImpl(MethodImplOptions.AggressiveInlining)]
 508    private static GridDiagnosticCell CreateMissingAddressCell(
 509        GridWorld world,
 510        VoxelGrid grid,
 511        VoxelIndex index,
 512        GridDiagnosticCellState state) =>
 47513        new(
 47514            GridDiagnosticCellKind.MissingSparseAddress,
 47515            world.SpawnToken,
 47516            grid.GridIndex,
 47517            grid.SpawnToken,
 47518            index,
 47519            grid.GetWorldPosition(index),
 47520            grid.Configuration.TopologyKind,
 47521            GridStorageKind.Sparse,
 47522            grid.Configuration.TopologyMetrics,
 47523            state,
 47524            new WorldVoxelIndex(world.SpawnToken, grid.GridIndex, grid.SpawnToken, index));
 525
 526    private struct ResultListVisitor : IGridDiagnosticCellVisitor
 527    {
 528        private readonly SwiftList<GridDiagnosticCell> _results;
 529
 530        public ResultListVisitor(SwiftList<GridDiagnosticCell> results)
 531        {
 37532            _results = results;
 37533        }
 534
 535        public bool Visit(in GridDiagnosticCell cell)
 536        {
 143537            _results.Add(cell);
 143538            return true;
 539        }
 540    }
 541
 542    private struct PhysicalCellVisitor<TVisitor> : IVoxelStorageVisitor
 543        where TVisitor : struct, IGridDiagnosticCellVisitor
 544    {
 545        private readonly GridWorld _world;
 546        private readonly VoxelGrid _grid;
 547        private readonly GridDiagnosticQuery _query;
 548        private readonly bool _hasBounds;
 549        private readonly TopologyVoxelAabb _queryBounds;
 550        private readonly VoxelIndex _minIndex;
 551        private readonly VoxelIndex _maxIndex;
 552
 553        public TVisitor Visitor;
 554        public int CellCount;
 555        public int SkippedCellCount;
 556        public GridDiagnosticQueryStatus Status;
 557
 558        public PhysicalCellVisitor(
 559            GridWorld world,
 560            VoxelGrid grid,
 561            in GridDiagnosticQuery query,
 562            bool hasBounds,
 563            TopologyVoxelAabb queryBounds,
 564            VoxelIndex minIndex,
 565            VoxelIndex maxIndex,
 566            TVisitor visitor,
 567            int cellCount,
 568            int skippedCellCount)
 569        {
 87570            _world = world;
 87571            _grid = grid;
 87572            _query = query;
 87573            _hasBounds = hasBounds;
 87574            _queryBounds = queryBounds;
 87575            _minIndex = minIndex;
 87576            _maxIndex = maxIndex;
 87577            Visitor = visitor;
 87578            CellCount = cellCount;
 87579            SkippedCellCount = skippedCellCount;
 87580            Status = GridDiagnosticQueryStatus.Completed;
 87581        }
 582
 583        public bool Visit(Voxel voxel)
 584        {
 8840585            if (_hasBounds && !IsVoxelInQueryBounds(_grid, voxel, _queryBounds, _minIndex, _maxIndex))
 55586                return true;
 587
 8785588            GridDiagnosticCellState state = GetCellState(voxel);
 8785589            if (!MatchesStateFilters(state, _query.RequiredStates, _query.ExcludedStates))
 107590                return true;
 591
 8678592            GridDiagnosticCell cell = CreatePhysicalCell(_world, _grid, voxel, state);
 8678593            return TryVisitCell(
 8678594                in cell,
 8678595                _query.MaxCells,
 8678596                ref Visitor,
 8678597                ref CellCount,
 8678598                ref SkippedCellCount,
 8678599                out Status);
 600        }
 601    }
 602}
Generated by: ReportGenerator 5.5.11.0
08/05/2026 - 05:32:50
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)