SceneLayerTile.cs

using System.Drawing;
using Gondwana.Drawing;
using Gondwana.Drawing.Animation;
using Gondwana.Drawing.Collisions;
using Gondwana.Physics.Collisions;
using Newtonsoft.Json;
 
namespace Gondwana.Scenes;

[JsonObject(IsReference = true)]
public class SceneLayerTile : Tile
{
    #region private / internal fields
 
    [JsonIgnore]
    internal SceneLayer parentSceneLayer;

    [JsonProperty]
    internal Point sceneLayerCoordinates;
 
    #endregion private / internal fields
 
    #region constructors / finalizer
 
    [JsonConstructor]
    private SceneLayerTile()
    {
        zOrder = 0;
        visible = true;
 
        // Parent ownership is reconstructed by SceneLayer.OnDeserialized().
        // Use the null-object layer while Json.NET populates inherited Tile
        // properties whose setters may invalidate the parent layer.
        parentSceneLayer = SceneLayer.Empty;
    }
 
    internal SceneLayerTile(SceneLayer sceneLayer)
    {
        zOrder = 0;
        visible = true;
        parentSceneLayer = sceneLayer;
    }

    internal void EnsureCollider()
    {
        if (_collider is null)
        {
            AttachCollider(new TileCollider(
                this,
                collisionGroup: CollisionMasks.None,
                collidesWith: CollisionMasks.None));
        }
    }

    ~SceneLayerTile()
    {
        Dispose();
    }
 
    #endregion constructors / finalizer

    public override bool EnableFog
    {
        get => base.EnableFog;
        set
        {
            bool changed = enableFog != value;
            base.EnableFog = value;
 
            if (changed && !ReferenceEquals(parentSceneLayer, SceneLayer.Empty))
                parentSceneLayer.InvalidateFixedGridRenderEligibility();
        }
    }
 
    private TileTransform _transform;

    [JsonProperty]
    public TileTransform Transform
    {
        get => _transform;
        set
        {
            if (!Enum.IsDefined(value)) throw new ArgumentOutOfRangeException(nameof(value));
            if (_transform == value) return;
            SceneLayer.RefreshQueue.AddWorldRect(DrawLocationWorld);
            _transform = value;
            if (!ReferenceEquals(SceneLayer, SceneLayer.Empty))
            {
                if (value == TileTransform.Identity) SceneLayer.TransformedTiles.Remove(this);
                else SceneLayer.TransformedTiles.Add(this);
            }
            SceneLayer.RefreshQueue.AddWorldRect(DrawLocationWorld);
        }
    }

    [JsonIgnore]
    public Size EffectiveTileSize => TileTransformGeometry.TransformSize(CurrentFrame.TileSize, Transform);

    [JsonIgnore]
    public override Spacing Overhang => TileTransformGeometry.TransformSpacing(CurrentFrame.Overhang, Transform);

    [JsonIgnore]
    public Spacing EffectiveTilePadding => TileTransformGeometry.TransformSpacing(CurrentFrame.TilePadding, Transform);

    [JsonIgnore]
    public CollisionAdjust EffectiveCollisionAdjust => TileTransformGeometry.TransformCollisionAdjust(AdjustCollisionArea, Transform);

    [JsonIgnore]
    public override Rectangle CollisionArea => EffectiveCollisionAdjust.ApplyTo(DrawLocationWorld);

    public override void Draw(Gondwana.Rendering.Backbuffers.BackbufferBase backbuffer, RectangleF destRectScreen)
    {
        if (Transform == TileTransform.Identity)
        {
            base.Draw(backbuffer, destRectScreen);
            return;
        }
 
        var origin = TileTransformGeometry.MapToDestination(new(0, 0), destRectScreen, Transform);
        var x = TileTransformGeometry.MapToDestination(new(1, 0), destRectScreen, Transform);
        var y = TileTransformGeometry.MapToDestination(new(0, 1), destRectScreen, Transform);
        var matrix = new global::SkiaSharp.SKMatrix
        {
            ScaleX = x.X - origin.X,
            SkewX = y.X - origin.X,
            TransX = origin.X,
            SkewY = x.Y - origin.Y,
            ScaleY = y.Y - origin.Y,
            TransY = origin.Y,
            Persp2 = 1
        };
        var canvas = backbuffer.Canvas;
        canvas.Save();
        try
        {
            canvas.Concat(ref matrix);
            base.Draw(backbuffer, new RectangleF(0, 0, 1, 1));
        }
        finally { canvas.Restore(); }
    }

    public override void Dispose()
    {
        parentSceneLayer?.TransformedTiles.Remove(this);
        base.Dispose();
        GC.SuppressFinalize(this);
    }
 
    #region public properties

    [JsonIgnore]
    public override int ZOrder
    {
        get => base.ZOrder;
        set
        {
            bool changed = zOrder != value;
            base.ZOrder = value;
 
            if (changed && !ReferenceEquals(parentSceneLayer, SceneLayer.Empty))
                parentSceneLayer.InvalidateFixedGridRenderEligibility();
        }
    }

    [JsonIgnore]
    public override Rectangle DrawLocationWorld => parentSceneLayer.CoordinateSystem.GetPixelRangeForTile(this, true);

    [JsonIgnore]
    public override bool IsPositionFixed => true;

    [JsonIgnore]
    public override PointF SceneLayerCoordinates => (PointF)sceneLayerCoordinates;

    [JsonIgnore]
    public Point GridCoordinatesAbs => sceneLayerCoordinates;

    [JsonIgnore]
    public override SceneLayer SceneLayer => parentSceneLayer;

    [JsonProperty]
    public bool EnableAnimator
    {
        get { return (animator != null); }
        set
        {
            if (value)
            {
                if (animator == null)
                    animator = new Animator(this);
 
                return;
            }
 
            animator?.Dispose();
            animator = null;
        }
    }
 
    #endregion public properties
}