ObliqueRightCoordinates.cs

using System.Drawing;
using Gondwana.Scenes;
 
namespace Gondwana.Drawing.Coordinates;

internal sealed class ObliqueRightCoordinates : ISceneLayerCoordinates
{
    public Point GetAnchorPixelAtSceneLayerCoordinates(SceneLayer sceneLayer, PointF layerPoint)
    {
        GetGeometry(sceneLayer, out _, out int H, out int skewX, out int faceWidth);
 
        float x = -sceneLayer.OriginPx.X
                  + layerPoint.X * faceWidth
                  + layerPoint.Y * skewX;
 
        float y = -sceneLayer.OriginPx.Y
                  + layerPoint.Y * H;
 
        return new Point(
            (int)Math.Floor(x),
            (int)Math.Floor(y));
    }

    public PointF GetSceneLayerCoordinatesAtPixel(SceneLayer sceneLayer, PointF pixelPt)
    {
        GetGeometry(sceneLayer, out _, out int H, out int skewX, out int faceWidth);
 
        float row = (pixelPt.Y + sceneLayer.OriginPx.Y) / H;
        float col = (pixelPt.X + sceneLayer.OriginPx.X - row * skewX) / faceWidth;
 
        return new PointF(col, row);
    }

    public List<SceneLayerTile> GetSceneLayerTilesInPixelRange(
        SceneLayer sceneLayer,
        Rectangle worldPixelRange,
        bool includeOverhang)
    {
        var result = new List<SceneLayerTile>();
        var candidateRange = TileBounds.GetTransformedTileCandidateRange(sceneLayer, worldPixelRange, includeOverhang);
 
        var upperLeft = GetSceneLayerCoordinatesAtPixel(
            sceneLayer,
            new PointF(candidateRange.Left, candidateRange.Top));
 
        var upperRight = GetSceneLayerCoordinatesAtPixel(
            sceneLayer,
            new PointF(candidateRange.Right, candidateRange.Top));
 
        var lowerLeft = GetSceneLayerCoordinatesAtPixel(
            sceneLayer,
            new PointF(candidateRange.Left, candidateRange.Bottom));
 
        var lowerRight = GetSceneLayerCoordinatesAtPixel(
            sceneLayer,
            new PointF(candidateRange.Right, candidateRange.Bottom));
 
        int minX = (int)Math.Floor(new[]
        {
            upperLeft.X,
            upperRight.X,
            lowerLeft.X,
            lowerRight.X
        }.Min()) - 1;
 
        int maxX = (int)Math.Ceiling(new[]
        {
            upperLeft.X,
            upperRight.X,
            lowerLeft.X,
            lowerRight.X
        }.Max()) + 1;
 
        int minY = (int)Math.Floor(new[]
        {
            upperLeft.Y,
            upperRight.Y,
            lowerLeft.Y,
            lowerRight.Y
        }.Min()) - 1;
 
        int maxY = (int)Math.Ceiling(new[]
        {
            upperLeft.Y,
            upperRight.Y,
            lowerLeft.Y,
            lowerRight.Y
        }.Max()) + 1;
 
        for (int y = minY; y <= maxY; y++)
        {
            for (int x = minX; x <= maxX; x++)
            {
                var tile = sceneLayer[x, y];
                if (tile is null)
                    continue;
 
                var tileRange = GetPixelRangeForTile(tile, includeOverhang);
                if (tileRange.IntersectsWith(worldPixelRange))
                    result.Add(tile);
            }
        }
 
        return result;
    }

    public Rectangle GetPixelRangeForTile(Tile tile, bool includeOverhang)
    {
        var anchor = GetAnchorPixelAtSceneLayerCoordinates(
            tile.SceneLayer,
            tile.SceneLayerCoordinates);
 
        var baseRect = new Rectangle(
            anchor.X,
            anchor.Y,
            tile.SceneLayer.TileWidth,
            tile.SceneLayer.TileHeight);
 
        return TileBounds.ApplyTileGeometry(baseRect, tile, includeOverhang);
    }

    public Rectangle GetPixelRangeForTileList(List<Tile> tileList, bool includeOverhang)
    {
        Rectangle result = Rectangle.Empty;
 
        foreach (var tile in tileList)
        {
            var tileRange = GetPixelRangeForTile(tile, includeOverhang);
            result = result.IsEmpty
                ? tileRange
                : Rectangle.Union(result, tileRange);
        }
 
        return result;
    }

    public SceneLayerTile GetAdjacentSceneLayerTile(
        SceneLayerTile layerPoint,
        CardinalDirections direction)
    {
        var sceneLayer = layerPoint.SceneLayer;
        int x = layerPoint.GridCoordinatesAbs.X;
        int y = layerPoint.GridCoordinatesAbs.Y;
 
        return direction switch
        {
            CardinalDirections.N => sceneLayer.ResolveWrappedTile(x, y - 1),
            CardinalDirections.NE => sceneLayer.ResolveWrappedTile(x + 1, y - 1),
            CardinalDirections.E => sceneLayer.ResolveWrappedTile(x + 1, y),
            CardinalDirections.SE => sceneLayer.ResolveWrappedTile(x + 1, y + 1),
            CardinalDirections.S => sceneLayer.ResolveWrappedTile(x, y + 1),
            CardinalDirections.SW => sceneLayer.ResolveWrappedTile(x - 1, y + 1),
            CardinalDirections.W => sceneLayer.ResolveWrappedTile(x - 1, y),
            CardinalDirections.NW => sceneLayer.ResolveWrappedTile(x - 1, y - 1),
            _ => null
        };
    }

    public Point[] GetPolygonPts(Tile tile, bool includeOverhang)
    {
        GetGeometry(
            tile.SceneLayer,
            out int W,
            out int H,
            out int skewX,
            out int faceWidth);
 
        var anchor = GetAnchorPixelAtSceneLayerCoordinates(
            tile.SceneLayer,
            tile.SceneLayerCoordinates);
 
        var overhang = includeOverhang
            ? tile.Overhang
            : Spacing.None;
 
        return new[]
        {
            new Point(
                anchor.X - overhang.Left,
                anchor.Y - overhang.Top),
 
            new Point(
                anchor.X + faceWidth + overhang.Right,
                anchor.Y - overhang.Top),
 
            new Point(
                anchor.X + W + overhang.Right,
                anchor.Y + H + overhang.Bottom),
 
            new Point(
                anchor.X + skewX - overhang.Left,
                anchor.Y + H + overhang.Bottom)
        };
    }

    public PointF FindEquivalentSceneLayerCoordinates(
        PointF valColRow,
        int xUpperBound,
        int yUpperBound)
    {
        float modX = valColRow.X % (xUpperBound + 1);
        float modY = valColRow.Y % (yUpperBound + 1);
 
        if (modX < 0)
            modX += xUpperBound + 1;
 
        if (modY < 0)
            modY += yUpperBound + 1;
 
        return new PointF(modX, modY);
    }
 
    private static void GetGeometry(
        SceneLayer sceneLayer,
        out int width,
        out int height,
        out int skewX,
        out int faceWidth)
    {
        width = sceneLayer.TileWidth;
        height = sceneLayer.TileHeight;
 
        // The full tile image remains W x H. Half of W is used by the
        // row-wise shear; the remaining width is the horizontal tile face.
        skewX = width / 2;
        faceWidth = width - skewX;
    }
}