SceneLayer.cs

using System.Collections;
using System.Drawing;
using System.Runtime.Serialization;
using Gondwana.Drawing;
using Gondwana.Drawing.Coordinates;
using Gondwana.Drawing.Direct;
using Gondwana.Drawing.Sprites;
using Gondwana.Effects;
using Gondwana.Physics.Collisions;
using Gondwana.Rendering;
using Gondwana.Timers;
using Newtonsoft.Json;
 
namespace Gondwana.Scenes;

[JsonObject(IsReference = true)]
public class SceneLayer : IEnumerable<SceneLayerTile>, IDisposable
{
    #region events

    public event Action<SceneLayer>? SceneLayerTileSizeChanged;

    public event Action<SceneLayer>? VisibleChanged;

    public event Action<SceneLayer>? WrappingChanged;

    public event Action<SceneLayer>? ShowGridLinesChanged;

    public event Action<SceneLayer>? ShowCollisionBoxesChanged;

    public event Action<SceneLayer>? ZOrderChanged;

    public event Action<SceneLayer>? ParallaxChanged;

    public event Action<SceneLayer>? OriginPxChanged;

    public event Action<SceneLayer>? Disposing;
 
    #endregion events
 
    #region private fields
 
    private int _tileWidth;     // rendered width
    private int _tileHeight;    // rendered height
    private bool _visible;      // is SceneLayer to be rendered; useful with multiple layers
    private string _defaultTileCollisionProfile = CollisionProfileNames.World;
    private bool _fixedGridRenderEligibilityDirty;
    private bool _fixedGridRenderEligible = true;
    private bool _sceneLayerTileArrayExternallyExposed;
 
    [JsonIgnore]
    internal float EffectOpacity { get; set; } = 1f;
 
    [JsonIgnore]
    internal float EffectReveal { get; set; } = 1f;
 
    [JsonIgnore]
    internal EffectDirection EffectRevealDirection { get; set; } = EffectDirection.FromLeftToRight;
 
    [JsonIgnore]
    internal PointF EffectOffsetFactor { get; set; } = PointF.Empty;
 
    [JsonIgnore]
    internal PointF EffectOffsetPx { get; set; } = PointF.Empty;
 
    #endregion private fields
 
    #region constructors / finalizer

    protected internal SceneLayer(int columnCount,
                                  int rowCount,
                                  int width = 32,
                                  int height = 32,
                                  float parallax = 1,
                                  CoordinateSystemTypes coordinateSystem = CoordinateSystemTypes.Orthogonal)
    {
        var tileArray = new SceneLayerTile[columnCount, rowCount];
 
        InitValues(tileArray, width, height, parallax, coordinateSystem);
    }
 
    [JsonConstructor]
    private SceneLayer() : this(0, 0) { }
 
    [OnDeserialized]
    private void OnDeserialized(StreamingContext context)
    {
        // Preserve the deserialized tiles and presentation state. Re-running
        // InitValues here used to replace every loaded tile with an empty cell.
        bool fastPathEligible = true;
        int? fixedZOrder = null;
 
        for (int x = 0; x < GridColumnCount; x++)
            for (int y = 0; y < GridRowCount; y++)
            {
                var tile = _sceneLayerTileArray[x, y] ??= new SceneLayerTile(this);
                tile.parentSceneLayer = this;
                if (tile.Transform != TileTransform.Identity) TransformedTiles.Add(tile);
                tile.sceneLayerCoordinates = new Point(x, y);
 
                if (tile.GetType() != typeof(SceneLayerTile) || tile.EnableFog)
                    fastPathEligible = false;
 
                if (fixedZOrder.HasValue && fixedZOrder.Value != tile.ZOrder)
                    fastPathEligible = false;
                else
                    fixedZOrder ??= tile.ZOrder;
            }
 
        _fixedGridRenderEligible = fastPathEligible;
        _fixedGridRenderEligibilityDirty = false;
        _sceneLayerTileArrayExternallyExposed = false;
        BuildTileColliders();
    }

    ~SceneLayer()
    {
        Dispose();
    }
 
    #endregion constructors / finalizer
 
    #region properties

    [JsonIgnore]
    public TypedValueBag ValueBag { get; } = new();
 
    [JsonIgnore]
    internal ISceneLayerCoordinates CoordinateSystem { get; private set; } = new OrthogonalCoordinates();

    [JsonProperty]
    public CoordinateSystemTypes CoordinateSystemType
    {
        get
        {
            return CoordinateSystem switch
            {
                OrthogonalCoordinates => CoordinateSystemTypes.Orthogonal,
                IsometricRhombicCoordinates => CoordinateSystemTypes.IsometricRhombic,
                IsometricAxialCoordinates => CoordinateSystemTypes.IsometricAxial,
                HexAxialFlatTopCoordinates => CoordinateSystemTypes.HexAxialFlatTop,
                HexAxialPointedTop => CoordinateSystemTypes.HexAxialPointedTop,
                ObliqueRightCoordinates => CoordinateSystemTypes.ObliqueRight,
                ObliqueLeftCoordinates => CoordinateSystemTypes.ObliqueLeft,
                _ => throw new InvalidOperationException($"Unknown coordinate system type: {CoordinateSystem.GetType().Name}")
            };
        }
        set
        {
            CoordinateSystem = value switch
            {
                CoordinateSystemTypes.Orthogonal => new OrthogonalCoordinates(),
                CoordinateSystemTypes.IsometricRhombic => new IsometricRhombicCoordinates(),
                CoordinateSystemTypes.IsometricAxial => new IsometricAxialCoordinates(),
                CoordinateSystemTypes.HexAxialFlatTop => new HexAxialFlatTopCoordinates(),
                CoordinateSystemTypes.HexAxialPointedTop => new HexAxialPointedTop(),
                CoordinateSystemTypes.ObliqueRight => new ObliqueRightCoordinates(),
                CoordinateSystemTypes.ObliqueLeft => new ObliqueLeftCoordinates(),
                _ => throw new ArgumentOutOfRangeException(nameof(value), $"Unknown coordinate system type: {value}")
            };
        }
    }

    [JsonProperty]
    public string ID { get; protected internal set; } = Guid.NewGuid().ToString();

    [JsonIgnore]
    public Scene Scene { get; internal set; }
 
    [JsonIgnore]
    internal RefreshQueue RefreshQueue { get; set; }
 
    private int _zOrder = 0;

    [JsonProperty]
    public int ZOrder
    {
        get => _zOrder;
        set
        {
            _zOrder = value;
            ZOrderChanged?.Invoke(this);
        }
    }
 
    private float _parallax = 1f;       // 1 = default; <1 is slower, >1 is faster

    [JsonProperty]
    public float Parallax
    {
        get { return _parallax; }
        set
        {
            _parallax = value;
            ParallaxChanged?.Invoke(this);
        }
    }

    [JsonProperty]
    public int TileHeight
    {
        get { return _tileHeight; }
        set
        {
            _tileHeight = value;
            SceneLayerTileSizeChanged?.Invoke(this);
        }
    }

    [JsonProperty]
    public int TileWidth
    {
        get { return _tileWidth; }
        set
        {
            _tileWidth = value;
            SceneLayerTileSizeChanged?.Invoke(this);
        }
    }

    [JsonProperty]
    public bool Visible
    {
        get { return _visible; }
        set
        {
            _visible = value;
            VisibleChanged?.Invoke(this);
        }
    }
 
    [JsonIgnore]
    internal HashSet<SceneLayerTile> TransformedTiles { get; } = new();
 
    [JsonProperty("SceneLayerTileArray")]
    [JsonConverter(typeof(SceneLayerTileArrayConverter))]
    private SceneLayerTile[,] _sceneLayerTileArray;    // array of points; 2 dimensions (X, Y)

    [JsonIgnore]
    public SceneLayerTile[,] SceneLayerTileArray
    {
        get
        {
            // Element replacement through the returned array bypasses SceneLayer mutation
            // notifications. Disable the persistent fast path for this layer rather than risk
            // recording custom/reparented tiles with fixed-grid assumptions.
            _sceneLayerTileArrayExternallyExposed = true;
            return _sceneLayerTileArray;
        }
    }

    [JsonIgnore]
    public int GridColumnCount => _sceneLayerTileArray.GetUpperBound(0) + 1;

    [JsonIgnore]
    public int GridRowCount => _sceneLayerTileArray.GetUpperBound(1) + 1;
 
    [JsonProperty("WrapHorizontally")]
    private bool _wrapHoriz = false;

    [JsonIgnore]
    public bool WrapHorizontally
    {
        get { return _wrapHoriz; }
        set
        {
            _wrapHoriz = value;
            WrappingChanged?.Invoke(this);
        }
    }
 
    [JsonProperty("WrapVertically")]
    private bool _wrapVerti = false;

    [JsonIgnore]
    public bool WrapVertically
    {
        get { return _wrapVerti; }
        set
        {
            _wrapVerti = value;
            WrappingChanged?.Invoke(this);
        }
    }
 
    [JsonProperty("ShowGridLines")]
    private bool showGridLines = false;

    [JsonIgnore]
    public bool ShowGridLines
    {
        get { return showGridLines; }
        set
        {
            showGridLines = value;
            ShowGridLinesChanged?.Invoke(this);
        }
    }
 
    [JsonProperty("ShowCollisionBoxes")]
    private bool showCollisionBoxes = false;

    [JsonIgnore]
    public bool ShowCollisionBoxes
    {
        get { return showCollisionBoxes; }
        set
        {
            showCollisionBoxes = value;
            ShowCollisionBoxesChanged?.Invoke(this);
        }
    }
 
    // World-space origin (in pixels) of this layer's (0,0) tile.
    // Usually (0,0); can be shifted to move the entire layer as a block.
    [JsonProperty("OriginPx")]
    private Point _originPx = Point.Empty;

    [JsonIgnore]
    public Point OriginPx
    {
        get => _originPx;
        set
        {
            if (_originPx == value) return;
            _originPx = value;
            OriginPxChanged?.Invoke(this);
        }
    }

    [JsonIgnore]
    public ColliderRegistry ColliderRegistry { get; private set; } = new();
 
    [JsonIgnore]
    internal CollisionResolver CollisionResolver { get; private set; } = null!;

    [JsonIgnore]
    public CollisionGroupRegistry CollisionGroups => Scene.CollisionGroups;

    [JsonProperty]
    public string DefaultTileCollisionProfile
    {
        get => _defaultTileCollisionProfile;
        set
        {
            if (string.IsNullOrWhiteSpace(value))
            {
                throw new ArgumentException(
                    "Default tile collision profile cannot be empty.",
                    nameof(value));
            }
 
            if (Scene is not null)
            {
                var profile = Scene.CollisionProfiles.Get(value);
                _ = profile.ResolveCollisionGroup(Scene.CollisionGroups);
                _ = profile.ResolveCollidesWith(Scene.CollisionGroups);
            }
 
            _defaultTileCollisionProfile = value;
 
            if (Scene is not null && _sceneLayerTileArray is not null)
                ApplyDefaultTileCollisionProfile();
        }
    }
 
    #endregion properties
 
    #region public methods

    public void SetTileSize(int newWidth, int newHeight)
    {
        _tileWidth = newWidth;
        _tileHeight = newHeight;
        SceneLayerTileSizeChanged?.Invoke(this);
    }

    internal void ApplyDefaultTileCollisionProfile()
    {
        if (Scene is null || _sceneLayerTileArray is null)
            return;
 
        // Resolve once up front so an invalid profile fails before partially
        // updating the layer.
        Scene.CollisionProfiles.Get(_defaultTileCollisionProfile);
 
        foreach (var tile in _sceneLayerTileArray)
            tile?.SetCollisionProfile(_defaultTileCollisionProfile);
    }

    public PointF GridToWorldPx(PointF grid) => CoordinateSystem.GetAnchorPixelAtSceneLayerCoordinates(this, grid);

    public PointF WorldPxToGrid(PointF worldPx) => CoordinateSystem.GetSceneLayerCoordinatesAtPixel(this, worldPx);

    public SceneLayerTile? GetAdjacentTile(SceneLayerTile tile, CardinalDirections direction) => CoordinateSystem.GetAdjacentSceneLayerTile(tile, direction);

    public PointF WrapGrid(PointF grid)
    {
        if (!WrapHorizontally && !WrapVertically)
            return grid;
 
        _ = GetPeriod();
 
        if (!float.IsFinite(grid.X) || !float.IsFinite(grid.Y))
            throw new ArgumentOutOfRangeException(nameof(grid));
 
        var wrapped = CoordinateSystem.FindEquivalentSceneLayerCoordinates(grid, GridColumnCount - 1, GridRowCount - 1);
        return new PointF(WrapHorizontally ? wrapped.X : grid.X, WrapVertically ? wrapped.Y : grid.Y);
    }

    public SceneLayerTile? ResolveWrappedTile(int column, int row)
    {
        if (WrapHorizontally || WrapVertically)
            _ = GetPeriod();
 
        static int Mod(int value, int period) { int remainder = value % period; return remainder < 0 ? remainder + period : remainder; }
 
        return this[WrapHorizontally ? Mod(column, GridColumnCount) : column,
            WrapVertically ? Mod(row, GridRowCount) : row];
    }

    public IEnumerable<PointF> GetWrappedOffsets(RectangleF contentBounds, RectangleF queryBounds)
    {
        if (WrapHorizontally || WrapVertically)
            return GetPeriod().Offsets(contentBounds, queryBounds);
 
        return contentBounds.IntersectsWith(queryBounds) ? new[] { PointF.Empty } : Array.Empty<PointF>();
    }
 
    internal LayerPeriod GetPeriod() => CoordinateSystem.GetWrapPeriod(this);

    public virtual RectangleF GetLayerBoundsPx()
    {
        if (GridColumnCount == 0 || GridRowCount == 0)
            return RectangleF.Empty;
 
        int maxCol = GridColumnCount - 1;
        int maxRow = GridRowCount - 1;
 
        // Corner tiles
        var corners = new[]
        {
            this[0, 0],
            this[maxCol, 0],
            this[0, maxRow],
            this[maxCol, maxRow]
        };
 
        RectangleF result = RectangleF.Empty;
        bool hasBounds = false;
 
        foreach (var tile in corners)
        {
            var px = CoordinateSystem.GetPixelRangeForTile(tile, includeOverhang: true);
            var rf = RectangleF.FromLTRB(px.Left, px.Top, px.Right, px.Bottom);
 
            if (!hasBounds)
            {
                result = rf;
                hasBounds = true;
            }
            else
            {
                result = RectangleF.Union(result, rf);
            }
        }
 
        // Interior placements can extend beyond the corner cells after rotation.
        foreach (var tile in TransformedTiles)
            result = RectangleF.Union(result, tile.DrawLocationWorld);
 
        return result;
    }
 
    #endregion public methods
 
    #region private methods
 
    private void InitValues(SceneLayerTile[,] tileArray, int width, int height, float parallax, CoordinateSystemTypes coordinateSystem)
    {
        _sceneLayerTileArray = tileArray;
        _parallax = parallax;
        _tileWidth = width;
        _tileHeight = height;
        _visible = true;
 
        _originPx = Point.Empty;                  // layer world origin
        EffectOpacity = 1f;
        EffectReveal = 1f;
        EffectRevealDirection = EffectDirection.FromLeftToRight;
        EffectOffsetFactor = PointF.Empty;
        EffectOffsetPx = PointF.Empty;
 
        CoordinateSystemType = coordinateSystem;
 
        ColliderRegistry = new ColliderRegistry { SceneLayer = this };
        CollisionResolver = new CollisionResolver(ColliderRegistry);
 
        // let each SceneLayerTile in array know its position in the array
        SaveGridCoordinatesToSceneLayerTiles();
        _fixedGridRenderEligible = true;
        _fixedGridRenderEligibilityDirty = false;
        _sceneLayerTileArrayExternallyExposed = false;
        BuildTileColliders();
        // Unbound scenes retain dirty regions for a future bitmap host. Once bound,
        // the scene policy disables queue writes for full-frame GL rendering.
        RefreshQueue = new RefreshQueue(() => Scene?.UsesDirtyRegionRendering ?? true);
    }
 
    private void SaveGridCoordinatesToSceneLayerTiles()
    {
        // let each SceneLayerTile in array know its position in the array
        for (int X = 0; X <= _sceneLayerTileArray.GetUpperBound(0); X++)
        {
            for (int Y = 0; Y <= _sceneLayerTileArray.GetUpperBound(1); Y++)
            {
                _sceneLayerTileArray[X, Y] = new SceneLayerTile(this);
                _sceneLayerTileArray[X, Y].sceneLayerCoordinates = new Point(X, Y);
            }
        }
    }
 
    private void BuildTileColliders()
    {
        foreach (var tile in _sceneLayerTileArray)
        {
            if (tile is null)
                continue;
 
            tile.EnsureCollider();
        }
    }
 
    internal bool IsFixedGridSnapshotFastPathEligible
    {
        get
        {
            if (_sceneLayerTileArrayExternallyExposed)
                return false;
 
            if (_fixedGridRenderEligibilityDirty)
                RecalculateFixedGridRenderEligibility();
 
            return _fixedGridRenderEligible;
        }
    }
 
    internal void InvalidateFixedGridRenderEligibility() =>
        _fixedGridRenderEligibilityDirty = true;
 
    private void RecalculateFixedGridRenderEligibility()
    {
        bool eligible = true;
        int? fixedZOrder = null;
 
        foreach (var tile in _sceneLayerTileArray)
        {
            if (tile is null ||
                tile.GetType() != typeof(SceneLayerTile) ||
                !ReferenceEquals(tile.SceneLayer, this) ||
                tile.EnableFog)
            {
                eligible = false;
                break;
            }
 
            if (fixedZOrder.HasValue && fixedZOrder.Value != tile.ZOrder)
            {
                eligible = false;
                break;
            }
 
            fixedZOrder ??= tile.ZOrder;
        }
 
        _fixedGridRenderEligible = eligible;
        _fixedGridRenderEligibilityDirty = false;
    }
 
    internal virtual List<IDrawable> GetDrawablesInWorldRect(Rectangle worldRect, bool includeOverhang = true) =>
        GetDrawablesInWorldRectCore(
            worldRect,
            includeOverhang,
            collectSortDiagnostics: false,
            out _);
 
    internal virtual List<IDrawable> GetDrawablesInWorldRectWithDiagnostics(
        Rectangle worldRect,
        out long sortTicks,
        bool includeOverhang = true) =>
        GetDrawablesInWorldRectCore(
            worldRect,
            includeOverhang,
            collectSortDiagnostics: true,
            out sortTicks);
 
    private List<IDrawable> GetDrawablesInWorldRectCore(
        Rectangle worldRect,
        bool includeOverhang,
        bool collectSortDiagnostics,
        out long sortTicks)
    {
        if (WrapHorizontally || WrapVertically)
            return GetWrappedDrawables(worldRect, collectSortDiagnostics, out sortTicks);
 
        // Make selection rect covering so we never miss the edge tile.
        // Drawing is still clipped later, so over-selecting is safe.
        var queryRect = worldRect;
        queryRect.Inflate(TileWidth, TileHeight);
        queryRect.Inflate(1, 1);
 
        // 1) Grid tiles. Every projection supplies a conservative render query whose
        // traversal follows fixed-tile depth order for that coordinate system.
        var renderTiles = CoordinateSystem.GetSceneLayerTilesForRendering(
            this,
            worldRect,
            includeOverhang);
        var sceneLayerTiles = renderTiles.Tiles;
 
        var list = new List<IDrawable>(sceneLayerTiles.Count);
        bool uniformGridZOrder = true;
        int? gridZOrder = null;
 
        for (int i = 0; i < sceneLayerTiles.Count; i++)
        {
            var tile = sceneLayerTiles[i];
 
            if (!tile.Visible || !HasRenderableTileContent(tile))
                continue;
 
            int tileZ = tile.ZOrder;
            if (gridZOrder.HasValue && gridZOrder.Value != tileZ)
                uniformGridZOrder = false;
            else
                gridZOrder ??= tileZ;
 
            list.Add(tile);
        }
 
        bool hasNonGridDrawables = false;
 
        // 2) Sprites
        var sprites = SpriteManager.Instance.GetSpritesInWorldRectRange(
            queryRect,
            this,
            fullEnclosures: false);
 
        for (int i = 0; i < sprites.Count; i++)
        {
            var sprite = sprites[i];
 
            if (sprite is null)
                continue;
 
            if (!sprite.VisualBoundsWorld.IntersectsWith(queryRect))
                continue;
 
            list.Add(sprite);
            hasNonGridDrawables = true;
        }
 
        // 3) DirectDrawing instances
        var drawings = DirectDrawingManager.Instance.GetDrawingsForLayer(this);
 
        for (int i = 0; i < drawings.Count; i++)
        {
            var drawing = drawings[i];
 
            if (!drawing.Visible)
                continue;
 
            if (drawing.Mode != DirectDrawingMode.SceneLayer)
                continue;
 
            if (!drawing.WorldBounds.IntersectsWith(worldRect))
                continue;
 
            list.Add(drawing);
            hasNonGridDrawables = true;
        }
 
        // Projection-specific render queries are emitted in fixed-tile depth order.
        // Per-tile Z differences or geometry-changing transforms still fall back to
        // verification/sort so the optimization cannot change rendering semantics.
        bool gridOrderGuaranteed =
            renderTiles.IsRenderOrdered &&
            uniformGridZOrder;
 
        long sortStartTick = collectSortDiagnostics ? HighResTimer.GetCurrentTick() : 0;
        if (hasNonGridDrawables)
        {
            list.Sort(CompareDrawables);
        }
        else if (!gridOrderGuaranteed && !IsSorted(list, CompareDrawables))
        {
            list.Sort(CompareDrawables);
        }
 
        sortTicks = collectSortDiagnostics
            ? Math.Max(0, HighResTimer.GetCurrentTick() - sortStartTick)
            : 0;
 
        return list;
    }
 
    private List<IDrawable> GetWrappedDrawables(
        Rectangle worldRect,
        bool collectSortDiagnostics,
        out long sortTicks)
    {
        var period = GetPeriod();
        var instances = new List<IDrawable>();
        void Add(IDrawable drawable, RectangleF bounds)
        {
            if (!drawable.Visible) return;
            foreach (var offset in period.Offsets(bounds, worldRect))
            {
                if (instances.Count >= 1_000_000)
                    throw new InvalidOperationException("Too many visible wrapped instances.");
                instances.Add(new WrappedDrawable(drawable, this, offset));
            }
        }
 
        // Inspect actual artwork bounds, including overhang, rather than assuming
        // a tile-sized margin can enclose all content.
        foreach (var tile in _sceneLayerTileArray)
            if (tile is not null) Add(tile, tile.DrawLocationWorld);
        foreach (var sprite in SpriteManager.Instance.AllSprites)
            if (ReferenceEquals(sprite.SceneLayer, this)) Add(sprite, sprite.VisualBoundsWorld);
        foreach (var drawing in DirectDrawingManager.Instance.GetDrawingsForLayer(this))
            if (drawing.Mode == DirectDrawingMode.SceneLayer) Add(drawing, drawing.WorldBounds);
 
        long sortStartTick = collectSortDiagnostics ? HighResTimer.GetCurrentTick() : 0;
        instances.Sort(CompareWrappedDrawables);
        sortTicks = collectSortDiagnostics
            ? Math.Max(0, HighResTimer.GetCurrentTick() - sortStartTick)
            : 0;
 
        return instances;
    }
 
    private bool HasRenderableTileContent(SceneLayerTile tile)
    {
        // Derived tiles may provide custom Draw behavior even without a frame.
        if (tile.GetType() != typeof(SceneLayerTile))
            return true;
 
        if (tile.CurrentFrame.Tilesheet is not null)
            return true;
 
        // Empty cells still participate when a diagnostic/post-draw overlay needs
        // their geometry.
        return tile.EnableFog ||
            ShowGridLines ||
            (ShowCollisionBoxes && tile.CollisionsEnabled);
    }
 
    private static bool IsSorted(
        List<IDrawable> drawables,
        Comparison<IDrawable> comparison)
    {
        for (int i = 1; i < drawables.Count; i++)
        {
            if (comparison(drawables[i - 1], drawables[i]) > 0)
                return false;
        }
 
        return true;
    }
 
    private static int CompareWrappedDrawables(IDrawable a, IDrawable b)
    {
        var x = (WrappedDrawable)a;
        var y = (WrappedDrawable)b;
        int z = a.ZOrder.CompareTo(b.ZOrder);
        if (z != 0) return z;
 
        if (x.Owner is Tile ta && y.Owner is Tile tb)
        {
            if (ta.IsPositionFixed != tb.IsPositionFixed)
                return ta.IsPositionFixed ? -1 : 1;
 
            float ay =
                (ta.IsPositionFixed
                    ? ta.DrawLocationWorld.Top + ta.Overhang.Top
                    : ta.DrawLocationWorld.Bottom - ta.Overhang.Bottom - 1) +
                x.Offset.Y;
            float by =
                (tb.IsPositionFixed
                    ? tb.DrawLocationWorld.Top + tb.Overhang.Top
                    : tb.DrawLocationWorld.Bottom - tb.Overhang.Bottom - 1) +
                y.Offset.Y;
            int depth = ay.CompareTo(by);
            if (depth != 0) return depth;
 
            int horizontal =
                (ta.DrawLocationWorld.Left + x.Offset.X)
                .CompareTo(tb.DrawLocationWorld.Left + y.Offset.X);
            if (horizontal != 0) return horizontal;
        }
 
        int identity = a.Id.CompareTo(b.Id);
        return identity != 0
            ? identity
            : (x.Offset.Y, x.Offset.X).CompareTo((y.Offset.Y, y.Offset.X));
    }
 
    private static int CompareDrawables(IDrawable a, IDrawable b)
    {
        int z = a.ZOrder.CompareTo(b.ZOrder);
        if (z != 0)
            return z;
 
        if (a is Tile ta && b is Tile tb)
            return ta.CompareTo(tb);
 
        return a.Id.CompareTo(b.Id);
    }
 
    #endregion private methods
 
    #region indexers

    public SceneLayerTile? this[int x, int y] => GetIndexer_NoWrap(x, y);

    public SceneLayerTile? this[Point pt] => this[pt.X, pt.Y];

    public SceneLayerTile? this[PointF ptF] => this[(int)ptF.X, (int)ptF.Y];
 
    private SceneLayerTile? GetIndexer_NoWrap(int x, int y)
    {
        if (x > _sceneLayerTileArray.GetUpperBound(0)
            || y > _sceneLayerTileArray.GetUpperBound(1)
            || x < 0
            || y < 0)
            return null;
        else
            return _sceneLayerTileArray[x, y];
    }
 
    #endregion indexers
 
    #region IEnumerable Members

    public IEnumerator GetEnumerator() => ((IEnumerable<SceneLayerTile>)this).GetEnumerator();

    IEnumerator<SceneLayerTile> IEnumerable<SceneLayerTile>.GetEnumerator()
    {
        for (int x = 0; x <= _sceneLayerTileArray.GetUpperBound(0); x++)
        {
            for (int y = 0; y <= _sceneLayerTileArray.GetUpperBound(1); y++)
            {
                yield return _sceneLayerTileArray[x, y];
            }
        }
    }
 
    #endregion IEnumerable Members
 
    #region IDisposable Members

    public virtual void Dispose()
    {
        GC.SuppressFinalize(this);
 
        Disposing?.Invoke(this);
 
        foreach (SceneLayerTile gridPt in this)
            gridPt.Dispose();
 
        // cancel all subscriptions to this object
        SceneLayerTileSizeChanged = null;
        VisibleChanged = null;
        WrappingChanged = null;
        Disposing = null;
    }
 
    #endregion IDisposable Members
 
    #region empty SceneLayer

    public static SceneLayer Empty { get; } = new EmptySceneLayer();
 
    private sealed class EmptySceneLayer : SceneLayer
    {
        internal EmptySceneLayer()
            : base(columnCount: 0, rowCount: 0, width: 1, height: 1)
        {
            Visible = false;
            ZOrder = int.MinValue;
            Parallax = 1f;
        }
    }
 
    #endregion empty SceneLayer
}