#if UNITY_EDITOR
using UnityEngine;
using UnityEditor;
using System;
using System.Collections.Generic;
using System.Linq;

namespace GSpawn
{
    public class TileRuleGridRayHit
    {
        private TileRuleGrid        _hitGrid;
        private float               _hitEnter;
        private Vector3             _hitPoint;
        private Vector3             _hitNormal;
        private Vector3Int          _hitCellCoords;

        public TileRuleGrid         hitGrid             { get { return _hitGrid; } }
        public float                hitEnter            { get { return _hitEnter; } }
        public Vector3              hitPoint            { get { return _hitPoint; } }
        public Vector3              hitNormal           { get { return _hitNormal; } }
        public Vector3Int           hitCellCoords       { get { return _hitCellCoords; } }

        public TileRuleGridRayHit(Ray hitRay, TileRuleGrid hitGrid, Vector3 hitNormal, float hitEnter, Vector3Int hitCellCoords)
        {
            _hitGrid            = hitGrid;
            _hitEnter           = hitEnter;
            _hitPoint           = hitRay.GetPoint(hitEnter);
            _hitNormal          = hitNormal;
            _hitCellCoords      = hitCellCoords;
        }
    }

    public struct TileRuleGridCellRange
    {
        private Vector3Int _min;
        private Vector3Int _max;

        public Vector3Int min { get { return _min; } set { _min = value; sortCoords(); } }
        public Vector3Int max { get { return _max; } set { _max = value; sortCoords(); } }

        public TileRuleGridCellRange(Vector3Int minCoords, Vector3Int maxCoords)
        {
            _min = minCoords;
            _max = maxCoords;
            sortCoords();
        }

        private void sortCoords()
        {
            if (_min.x > _max.x) { int t = _min.x; _min.x = _max.x; _max.x = t; }
            if (_min.y > _max.y) { int t = _min.y; _min.y = _max.y; _max.y = t; }
            if (_min.z > _max.z) { int t = _min.z; _min.z = _max.z; _max.z = t; }
        }
    }

    [Serializable]
    public class TileRuleGridRampCells : SerializableHashSet<Vector3Int> { }

    [Serializable]
    public class TileRuleGridState
    {
        [SerializeField]
        public TileRuleGridRampCells rampCells = new TileRuleGridRampCells();

        public void clear()
        {
            rampCells.Clear();
        }
    }

    public class TileRuleGrid : ScriptableObject, IUIItemStateProvider
    {
        private class EditData
        {
            public HashSet<Vector3Int> addedRampCells       = new HashSet<Vector3Int>();
            public HashSet<Vector3Int> removedRampCells     = new HashSet<Vector3Int>();

            public void clear()
            {
                addedRampCells.Clear();
                removedRampCells.Clear();
            }
        }

        private enum TilePaintReason
        {
            Paint = 0,
            Erase,
            Connect,
            Refresh,
        }

        private class TilePaintParams
        {
            public Vector3Int       cellCoords          = new Vector3Int();
            public bool             paintingRamp        = false;
            public TilePaintReason  paintReason         = TilePaintReason.Paint;

            public void clear()
            {
                paintingRamp    = false;
                paintReason     = TilePaintReason.Paint;
            }
        }

        private class TileSpawnData
        {
            [NonSerialized]
            public TileRule         rule;
            [NonSerialized]
            public TileRulePrefab   rulePrefab;
            [NonSerialized]
            public Quaternion       rotation        = Quaternion.identity;
            [NonSerialized]
            public Vector3          scale           = Vector3.one;
            [NonSerialized]
            public bool             flipSpriteX     = false;
            [NonSerialized]
            public bool             flipSpriteY     = false;
            [NonSerialized]
            public bool             isRamp          = false;

            public void reset()
            {
                rule        = null;
                rulePrefab  = null;
                rotation    = Quaternion.identity;
                scale       = Vector3.one;
                flipSpriteX = false;
                flipSpriteY = false;
                isRamp      = false;
            }
        }

        static TileRuleGrid()
        {
            _neighOffsets_R1 = new Vector2Int[8];
            _neighOffsets_R2 = new Vector2Int[24];
            _neighOffsets_R3 = new Vector2Int[48];

            int arrayIndex = 0;
            for (int r = -1; r <= 1; ++r)
            {
                for(int c = -1; c <= 1; ++c)
                {
                    if (r != 0 || c != 0)
                    {
                        _neighOffsets_R1[arrayIndex++] = new Vector2Int(c, r);
                    }
                }
            }

            arrayIndex = 0;
            for (int r = -2; r <= 2; ++r)
            {
                for (int c = -2; c <= 2; ++c)
                {
                    if (r != 0 || c != 0)
                    {
                        _neighOffsets_R2[arrayIndex++] = new Vector2Int(c, r);
                    }
                }
            }

            arrayIndex = 0;
            for (int r = -3; r <= 3; ++r)
            {
                for (int c = -3; c <= 3; ++c)
                {
                    if (r != 0 || c != 0)
                    {
                        _neighOffsets_R3[arrayIndex++] = new Vector2Int(c, r);
                    }
                }
            }
        }

        private static Vector2Int[]     _neighOffsets_R1;
        private static Vector2Int[]     _neighOffsets_R2;
        private static Vector2Int[]     _neighOffsets_R3;

        private Dictionary<Vector3Int, GameObject>  _tileMap        = new Dictionary<Vector3Int, GameObject>();
        
        [SerializeField]
        private GameObject              _gameObject;
        [NonSerialized]
        private Transform               _transform;
        [SerializeField]
        private TileRuleGridSettings    _settings;
        [SerializeField]
        private PluginGuid              _guid                       = new PluginGuid(Guid.NewGuid());
        [SerializeField]
        private string                  _gridName                   = string.Empty;
        [SerializeField]
        private bool                    _uiSelected;
        [NonSerialized]
        private CopyPasteMode           _uiCopyPasteMode            = CopyPasteMode.None;
        [SerializeField]
        private bool                    _uiExpanded                 = false;
        [SerializeField]
        private TileRuleGridState       _state                      = new TileRuleGridState();
        [NonSerialized]
        private EditData                _editData                   = new EditData();
        [SerializeField]
        private bool                    _usingSprites               = false;

        [SerializeField]
        private bool                        _mirroringEnabled       = false;
        [SerializeField]
        private ObjectMirrorGizmo           _mirrorGizmo            = null;
        [SerializeField]
        private ObjectMirrorGizmoSettings   _mirrorGizmoSettings    = null;

        [NonSerialized]
        private Vector2Int[]            _neighborOffsets            = null;
        [NonSerialized]
        private TileRuleProfile         _ruleProfile;
        [NonSerialized]
        private HashSet<Vector3Int>     _occupiedCells              = new HashSet<Vector3Int>();
        [NonSerialized]
        private List<Vector3Int>        _cellsAroundVertBorder      = new List<Vector3Int>();
        [NonSerialized]
        private List<Vector3Int>        _cellsBelow                 = new List<Vector3Int>();
        [NonSerialized]
        private HashSet<Vector3Int>     _eraseBrushCells            = new HashSet<Vector3Int>();
        [NonSerialized]
        private TilePaintParams             _tilePaintParams        = new TilePaintParams();
        [NonSerialized]
        private TileSpawnData               _tileSpawnData          = new TileSpawnData();
        [NonSerialized]
        private TileRulePrefabPickParams    _prefabPickParams       = new TileRulePrefabPickParams();

        [NonSerialized]
        private List<TileRule>          _sortedStdRules             = new List<TileRule>();
        [NonSerialized]
        private List<TileRule>          _sortedPlatformRules        = new List<TileRule>();
        [NonSerialized]
        private List<TileRule>          _sortedRampRules            = new List<TileRule>();

        [NonSerialized]
        private List<GameObject>        _objectBuffer               = new List<GameObject>();
        [NonSerialized]
        private List<GameObject>        _prefabInstanceRoots        = new List<GameObject>();
        [NonSerialized]
        private Func<GameObject, bool>  _prefabInstanceRootFilter;
        [NonSerialized]
        private SceneRaycastFilter      _pickCellCoordsFilter       = new SceneRaycastFilter();
        [NonSerialized]
        private ObjectOverlapFilter     _foreignEraseOverlapFilter  = new ObjectOverlapFilter();
        [NonSerialized]
        private List<GameObject>        _foreignObjectBuffer        = new List<GameObject>();
        [NonSerialized]
        private List<Vector3>           _shadowCorners              = new List<Vector3>();
        [NonSerialized]
        private List<Vector3Int>        _cellCoordsBuffer           = new List<Vector3Int>();
        [NonSerialized]
        private List<GameObject>        _meshObjectBuffer           = new List<GameObject>();
        [NonSerialized]
        private List<GameObject>        _objectOverlapBuffer        = new List<GameObject>();
    
        [NonSerialized]
        private Vector3[]               _tileFrame                  = new Vector3[3];

        private TileRuleObjectSpawnSettings     spawnSettings       { get { return ObjectSpawn.instance.tileRuleObjectSpawn.settings; } }

        public PluginGuid               guid                        { get { return _guid; } }
        public TileRuleGridSettings     settings                    { get { return _settings; } }
        public string                   gridName                    { get { return _gridName; } set { if (!string.IsNullOrEmpty(value)) { UndoEx.record(this); _gridName = value; } } }
        public bool                     uiSelected                  { get { return _uiSelected; } set { UndoEx.record(this); _uiSelected = value; } }
        public CopyPasteMode            uiCopyPasteMode             { get { return _uiCopyPasteMode; } set { _uiCopyPasteMode = value; } }
        public bool                     uiExpanded                  { get { return _uiExpanded; } set { _uiExpanded = value; EditorUtility.SetDirty(this); } }

        public Vector3                  gridOrigin                  { get { return _transform.position; } set { UndoEx.record(_transform); _transform.position = value; } }
        public Vector3                  gridRight                   { get { return _transform.right; } }
        public Vector3                  gridUp                      { get { return _transform.up; } }
        public Vector3                  gridLook                    { get { return _transform.forward; } }
        public Quaternion               gridRotation                { get { return _transform.rotation; } set { UndoEx.record(_transform); _transform.rotation = value; } }
        public Plane                    gridPlane                   { get { return new Plane(gridUp, gridOrigin); } }
        public GameObject               gameObject                  { get { return _gameObject; } }
        public Transform                transform                   { get { return _transform; } }

        public bool                         mirroringEnabled        { get { return _mirroringEnabled; } set { UndoEx.record(this); _mirroringEnabled = value; EditorUtility.SetDirty(this); } }
        public ObjectMirrorGizmo            mirrorGizmo             { get { return _mirrorGizmo; } }
        public ObjectMirrorGizmoSettings    mirrorGizmoSettings     { get { return _mirrorGizmoSettings; } }
        public Vector3Int                   mirrorGizmoCellCoords   { get { return worldPointToCellCoords(_mirrorGizmo.position); } set { UndoEx.record(_mirrorGizmo); _mirrorGizmo.position = cellCoordsToCellPosition(value); SceneView.RepaintAll(); } }

        public static void getCellsAroundVerticalBorder(Vector3Int coords, List<Vector3Int> cellCoords)
        {
            cellCoords.Clear();
            cellCoords.Add(new Vector3Int(coords.x - 1, coords.y, coords.z));
            cellCoords.Add(new Vector3Int(coords.x + 1, coords.y, coords.z));
            cellCoords.Add(new Vector3Int(coords.x, coords.y, coords.z - 1));
            cellCoords.Add(new Vector3Int(coords.x, coords.y, coords.z + 1));
            cellCoords.Add(new Vector3Int(coords.x - 1, coords.y, coords.z - 1));
            cellCoords.Add(new Vector3Int(coords.x - 1, coords.y, coords.z + 1));
            cellCoords.Add(new Vector3Int(coords.x + 1, coords.y, coords.z + 1));
            cellCoords.Add(new Vector3Int(coords.x + 1, coords.y, coords.z - 1));
        }

        public static void getCellsAroundVerticalBorder(Vector3Int coords, int radius, List<Vector3Int> cellCoords)
        {
            cellCoords.Clear();
            if (radius < 1) return;

            int minX = coords.x - radius;
            int maxX = coords.x + radius;
            int minZ = coords.z - radius;
            int maxZ = coords.z + radius;

            for (int x = minX; x <= maxX; ++x)
            {
                for (int z = minZ; z <= maxZ; ++z)
                {
                    if (x == coords.x && z == coords.z) continue;

                    cellCoords.Add(new Vector3Int(x, coords.y, z));
                }
            }
        }

        public void initialize(TileRuleGridSettings initialGridSettings)
        {
            _settings.copy(initialGridSettings);

            _gameObject = new GameObject(gridName);
            UndoEx.registerCreatedObject(_gameObject);
            EditorUtility.SetDirty(_gameObject);

            _transform  = _gameObject.transform;

            _mirrorGizmoSettings.moveSnapStep       = settings.cellSize;
            _mirrorGizmoSettings.hasRotationHandles = false;
            _mirrorGizmoSettings.mirrorRotation     = false;
            _mirrorGizmoSettings.mirrorSpanning     = false;

            _usingSprites   = false;
            var ruleProfile = initialGridSettings.tileRuleProfile;
            int numRules    = ruleProfile.numTileRules;
            for (int i = 0; i < numRules; ++i)
            {
                var rule        = ruleProfile.getTileRule(i);
                int numPrefabs  = rule.numPrefabs;
                for (int j = 0; j < numPrefabs; ++j)
                {
                    var prefab  = rule.getPrefab(j);
                    if (prefab.prefabAsset.hierarchyHasOnlySprites(false, false))
                    {
                        _usingSprites = true;
                        break;
                    }
                }
            }
        }

        public void rotateRamp(Vector3Int cellCoords)
        {
            if (isRamp(cellCoords))
            {
                var rampTile = _tileMap[cellCoords];
                UndoEx.recordTransform(rampTile.transform);
                rampTile.transform.rotateAround(Quaternion.AngleAxis(90.0f, gridUp), rampTile.transform.position);
            }
        }

        public void snapMirrorGizmoToView(bool enableGizmo)
        {
            if (enableGizmo && !mirrorGizmo.enabled) mirrorGizmo.enabled = true;
            if (mirrorGizmo.enabled)
            {
                mirrorGizmo.snapToView();
                snapMirrorGizmoPositionToCellBaseCenter();
            }
        }

        public void deleteAllTiles()
        {
            UndoEx.record(this);
            _state.clear();

            _gameObject.getAllChildren(true, true, _objectBuffer);
            foreach(var go in _objectBuffer)
            {
                if (!ObjectGroupDb.instance.isObjectGroup(go))
                {
                    // Note: Might have been previously deleted.
                    if (go != null) UndoEx.destroyGameObjectImmediate(go);
                }
            }

            _tileMap.Clear();
        }

        public void refreshTiles()
        {
            prepareForTileUpdate();
            _editData.clear();

            var tileMapPairs        = _tileMap.ToList();
            int numTileMapPairs     = tileMapPairs.Count;
            bool hasRamps           = _sortedRampRules.Count > 0;
            if (hasRamps)
            {
                int numRampPrefabs = 0;
                foreach (var rule in _sortedRampRules)
                    numRampPrefabs += rule.numPrefabs;

                if (numRampPrefabs == 0) hasRamps = false;
            }

            PluginProgressDialog.begin("Refreshing");
            _tilePaintParams.clear();
            _tilePaintParams.paintReason = TilePaintReason.Refresh;
            for (int pairIndex = 0; pairIndex < numTileMapPairs; ++pairIndex)
            {
                var pair = tileMapPairs[pairIndex];
                PluginProgressDialog.updateProgress("Tile " + pairIndex, (pairIndex + 1) / (float)(numTileMapPairs));

                _tilePaintParams.cellCoords = pair.Key;
                if (isRamp(_tilePaintParams.cellCoords))
                {
                    if (hasRamps)
                    {
                        // Note: Store rotation because the ramp might have been rotated using the keyboard.
                        Quaternion rampRotation = pair.Value.transform.rotation;
                        _tilePaintParams.paintingRamp = true;
                        GameObject ramp = paintTile(_tilePaintParams);

                        // Store ramp rotation.
                        // Note: This can produce incorrect results when multiple ramp prefabs are used which open up
                        //       in different directions in their model pose.
                        if (ramp != null) ramp.transform.rotation = rampRotation;
                    }
                    else
                    {
                        eraseTile(pair.Key);
                        updateSurroundingTiles_IgnoreRamps(pair.Key);
                    }
                }
                else
                {
                    _tilePaintParams.paintingRamp = false;
                    paintTile(_tilePaintParams);
                }
            }

            // Note: Commit edit data here. It has to be done this way for Undo/Redo to work.
            commitEditData();

            PluginProgressDialog.end();
            ObjectSelection.instance.onSelectedObjectsMightHaveBeenDeleted(true);
        }

        [NonSerialized]
        private List<Vector3> _obbCornerBuffer          = new List<Vector3>();
        public void fixObjectOverlaps()
        {
            if (_usingSprites) return;

            UndoEx.saveEnabledState();
            UndoEx.enabled = false;

            var tileMapPairs    = _tileMap.ToList();
            int numTileMapPairs = tileMapPairs.Count;

            ObjectOverlapConfig overlapConfig   = ObjectOverlapConfig.defaultConfig;
            ObjectOverlapFilter overlapFilter   = new ObjectOverlapFilter();
            overlapFilter.objectTypes           = GameObjectType.Mesh;
            // Note: Only children of the tile rule grid will be taken into account.
            overlapFilter.customFilter          = (GameObject go) => { return go.transform.IsChildOf(_transform); };

            ObjectBounds.QueryConfig boundsQConfig  = ObjectBounds.QueryConfig.defaultConfig;
            boundsQConfig.objectTypes               = GameObjectType.Mesh;

            PluginProgressDialog.begin("Fixing Overlaps");
            for (int pairIndex = 0; pairIndex < numTileMapPairs; ++pairIndex)
            {
                var pair        = tileMapPairs[pairIndex];
                GameObject tile = pair.Value;
                PluginProgressDialog.updateProgress("Tile: " + tile.name, (pairIndex + 1) / (float)(numTileMapPairs));

                // Get all meshes in the tiles hierarchy
                tile.getMeshObjectsInHierarchy(false, false, _meshObjectBuffer);
                
                // Loop through each mesh
                foreach (var meshObject in _meshObjectBuffer)
                {
                    OBB obb = ObjectBounds.calcWorldOBB(meshObject, boundsQConfig);
                    if (!obb.isValid) continue;

                    obb.calcCorners(_obbCornerBuffer, false);

                    GameObject prefabAsset = meshObject.getPrefabAsset();
                    if (prefabAsset == null) continue;  // Note: Should not happen.

                    // Gather overlapping objects
                    PluginScene.instance.overlapBox(obb, overlapFilter, overlapConfig, _objectOverlapBuffer);
                    
                    // Loop through each overlapped object and disable its renderer if:
                    //  -if it's not a child of the current tile we are processing;
                    //  -is part of the same prefab asset;
                    //  -it has the same position;
                    foreach (var go in _objectOverlapBuffer)
                    {
                        if (!go.transform.IsChildOf(tile.transform))
                        {
                            // Calculate object OBB
                            OBB otherOBB = ObjectBounds.calcWorldOBB(go, boundsQConfig);
                            if (!obb.isValid) continue;

                            // Same center?
                            const float posEps = 1e-3f;
                            if (Vector3.Magnitude(otherOBB.center - obb.center) < posEps)
                            {
                                // Sizes should roughly match along the grid X and Z axes
                                const float sizeEsp = 1e-2f;
                                float s0 = Vector3Ex.getSizeAlongAxis(obb.size, obb.rotation, gridRight);
                                float s1 = Vector3Ex.getSizeAlongAxis(otherOBB.size, otherOBB.rotation, gridRight);
                                if (Mathf.Abs(s0 - s1) > sizeEsp) continue;

                                s0  = Vector3Ex.getSizeAlongAxis(obb.size, obb.rotation, gridLook);
                                s1  = Vector3Ex.getSizeAlongAxis(otherOBB.size, otherOBB.rotation, gridLook);
                                if (Mathf.Abs(s0 - s1) > sizeEsp) continue;

                                // All conditions are met. Disable renderer and colliders.
                                go.setMeshOrSkinnedMeshRendererEnabled(false);
                                go.setAllCollidersEnabled(false);
                            }
                        }
                    }
                }
            }

            UndoEx.restoreEnabledState();
            PluginProgressDialog.end();
        }

        public bool calcShadowCasterOBBCorners(OBB obb, int cellY, List<Vector3> corners)
        {
            corners.Clear();

            if (cellY <= -1) Box3D.calcFaceCorners(obb.center, obb.size, obb.rotation, Box3DFace.Top, corners);
            else if (cellY >= 1) Box3D.calcFaceCorners(obb.center, obb.size, obb.rotation, Box3DFace.Bottom, corners);
            else return false;

            return true;
        }

        public Plane getGridPlane(int yOffset)
        {
            return new Plane(gridUp, gridOrigin + yOffset * gridUp * settings.cellSize.y);
        }

        public bool pickTileCellCoords(Ray ray, bool pickAdjacent, out Vector3Int cellCoords)
        {
            cellCoords = Vector3Int.zero;
            if (pickAdjacent) return pickTileCellCoordsAdjacent(ray, out cellCoords);
            else return pickTileCellCoords(ray, out cellCoords);
        }

        public bool pickTileCellCoords(Ray ray, out Vector3Int cellCoords)
        {
            cellCoords = Vector3Int.zero;

            _pickCellCoordsFilter.raycastGrid = false;
            _pickCellCoordsFilter.objectTypes = GameObjectType.Mesh | GameObjectType.Sprite;

            var raycastConfig = ObjectRaycastConfig.defaultConfig;
            raycastConfig.raycastPrecision = ObjectRaycastPrecision.BestFit;

            var sceneHit = PluginScene.instance.raycastClosest(ray, _pickCellCoordsFilter, raycastConfig);
            if (sceneHit.wasObjectHit && sceneHit.objectHit.hitObject.transform.IsChildOf(_transform))
            {
                Vector3 hitPt   = sceneHit.objectHit.hitPoint;
                hitPt           -= sceneHit.objectHit.hitNormal * 1e-2f;
                cellCoords      = worldPointToVisualCellCoords(hitPt);
                return true;
            }

            return false;
        }

        public bool pickTileCellCoordsAdjacent(Ray ray, out Vector3Int cellCoords)
        {
            cellCoords = Vector3Int.zero;

            _pickCellCoordsFilter.raycastGrid = false;
            _pickCellCoordsFilter.objectTypes = GameObjectType.Mesh | GameObjectType.Sprite;

            var raycastConfig = ObjectRaycastConfig.defaultConfig;
            raycastConfig.raycastPrecision = ObjectRaycastPrecision.BestFit;

            var sceneHit = PluginScene.instance.raycastClosest(ray, _pickCellCoordsFilter, raycastConfig);
            if (sceneHit.wasObjectHit && sceneHit.objectHit.hitObject.transform.IsChildOf(_transform))
            {
                Vector3 hitPt   = sceneHit.objectHit.hitPoint;
                hitPt           += sceneHit.objectHit.hitNormal * 1e-2f;
                cellCoords      = worldPointToVisualCellCoords(hitPt);
                return true;
            }

            return false;
        }

        public bool pickCellCoords(Ray ray, int yOffset, out Vector3Int cellCoords)
        {
            cellCoords = Vector3Int.zero;

            _pickCellCoordsFilter.raycastGrid = false;
            _pickCellCoordsFilter.objectTypes = GameObjectType.Mesh | GameObjectType.Sprite;

            var sceneHit = PluginScene.instance.raycastClosest(ray, _pickCellCoordsFilter, ObjectRaycastConfig.defaultConfig);
            if (sceneHit.wasObjectHit)
            {
                Vector3 hitPt = sceneHit.objectHit.hitPoint;
                hitPt += gridUp * 1e-3f;        // Note: When clicking near the top of a cell, favor sitting on top.

                cellCoords = worldPointToCellCoords(hitPt);
                return true;
            }
            else
            {
                var gridHit = raycast(ray, yOffset);
                if (gridHit != null)
                {
                    cellCoords = gridHit.hitCellCoords;
                    return true;
                }
            }

            return false;
        }

        public TileRuleGridRayHit raycast(Ray ray)
        {
            float t;
            if (gridPlane.Raycast(ray, out t))
            {
                var cellCoords = worldPointToCellCoords(ray.GetPoint(t));
                cellCoords.y = 0;

                return new TileRuleGridRayHit(ray, this, gridPlane.normal, t, cellCoords);
            }

            return null;
        }

        public TileRuleGridRayHit raycast(Ray ray, int yOffset)
        {
            float t;
            Plane plane = getGridPlane(yOffset);
            if (plane.Raycast(ray, out t))
            {
                var cellCoords = worldPointToCellCoords(ray.GetPoint(t));
                cellCoords.y = yOffset;

                return new TileRuleGridRayHit(ray, this, plane.normal, t, cellCoords);
            }

            return null;
        }

        public OBB calcVisualCellOBB(Vector3Int cellCoords)
        {
            return new OBB(cellCoordsToVisualCellPosition(cellCoords), settings.cellSize, gridRotation);
        }

        public OBB calcCellRangeOBB(Vector3Int minCell, Vector3Int maxCell)
        {
            OBB obb             = new OBB(true);

            Plane plane         = gridPlane;
            obb.center          = plane.projectPoint(cellCoordsToCellPosition(minCell));
            obb.center          += plane.projectPoint(cellCoordsToCellPosition(maxCell));
            obb.center          *= 0.5f;

            int width           = maxCell.x - minCell.x + 1;
            int height          = maxCell.y - minCell.y + 1;
            int depth           = maxCell.z - minCell.z + 1;

            Vector3 cellSize    = settings.cellSize;
            obb.center          += plane.normal * height * 0.5f * cellSize.y;
            obb.center          += plane.normal * minCell.y * cellSize.y;
            obb.size            = new Vector3(width * cellSize.x, height * cellSize.y, depth * cellSize.z);
            obb.rotation        = gridRotation;

            return obb;
        }

        public Vector3Int worldPointToCellCoords(Vector3 pt)
        {
            Vector3 cellSize        = settings.cellSize;
            Vector3 toPt            = pt - gridOrigin;

            return new Vector3Int   (Mathf.RoundToInt(Vector3.Dot(toPt, gridRight)  / cellSize.x),
                                     Mathf.RoundToInt(Vector3.Dot(toPt, gridUp)     / cellSize.y),
                                     Mathf.RoundToInt(Vector3.Dot(toPt, gridLook)   / cellSize.z));
        }

        public Vector3Int worldPointToVisualCellCoords(Vector3 pt)
        {
            Vector3 cellSize    = settings.cellSize;
            Vector3 toPt        = pt - gridOrigin;

            float dotY          = Vector3.Dot(toPt, gridUp);

            return new Vector3Int(Mathf.RoundToInt(Vector3.Dot(toPt, gridRight) / cellSize.x),
                                  Mathf.RoundToInt((dotY - cellSize.y * 0.5f) / cellSize.y),
                                  Mathf.RoundToInt(Vector3.Dot(toPt, gridLook) / cellSize.z));
        }

        public Vector3 cellCoordsToCellPosition(Vector3Int cellCoords)
        {
            Vector3 cellSize        = settings.cellSize;
            return  gridOrigin      + gridRight * (cellCoords.x * cellSize.x)
                                    + gridUp    * (cellCoords.y * cellSize.y)
                                    + gridLook  * (cellCoords.z * cellSize.z);
        }

        public Vector3 cellCoordsToCellPosition(int x, int y, int z)
        {
            Vector3 cellSize        = settings.cellSize;
            return  gridOrigin      + gridRight * (x * cellSize.x)
                                    + gridUp    * (y * cellSize.y)
                                    + gridLook  * (z * cellSize.z);
        }

        public Vector3 cellCoordsToVisualCellPosition(Vector3Int cellCoords)
        {
            Vector3 cellSize        = settings.cellSize;
            return gridOrigin       + gridRight * (cellCoords.x * cellSize.x)
                                    + gridUp    * (cellCoords.y * cellSize.y + cellSize.y * 0.5f)
                                    + gridLook  * (cellCoords.z * cellSize.z);
        }

        public Vector3 cellCoordsToVisualCellPosition(int x, int y, int z)
        {
            Vector3 cellSize        = settings.cellSize;
            return gridOrigin       + gridRight * (x * cellSize.x)
                                    + gridUp    * (y * cellSize.y + cellSize.y * 0.5f)
                                    + gridLook  * (z * cellSize.z);
        }

        public void onSceneGUI(int gridYOffset)
        {
            prepareForTileUpdate();
            _mirrorGizmo.enabled    = _mirroringEnabled;

            Event e = Event.current;
            if (e.isLeftMouseButtonDownEvent()) _editData.clear();
            else if (e.isLeftMouseButtonUpEvent()) commitEditData();

            draw(gridYOffset);
        }

        public void paintTiles(TileRuleBrush brush)
        {
            _tilePaintParams.clear();
            _tilePaintParams.paintReason = TilePaintReason.Paint;

            // Update tiles inside brush
            brush.getCellCoords(_occupiedCells);
            foreach (var cellCoords in _occupiedCells)
            {
                _tilePaintParams.cellCoords = cellCoords;
                paintTile(_tilePaintParams);
            }

            // Update platforms
            brush.getCellCoordsBelowBrush(_cellsBelow);
            foreach (var cellCoords in _cellsBelow)
            {
                if (getTileObject(cellCoords) != null)
                {
                    _tilePaintParams.cellCoords = cellCoords;
                    paintTile(_tilePaintParams);
                }
            }

            // Update tiles around brush borders
            brush.getCellsAroundVerticalBorder((int)settings.tileRuleNeighborRadius, _cellsAroundVertBorder);
            foreach (var cellCoords in _cellsAroundVertBorder)
            {
                // Note: We don't update ramps.
                if ((getTileObject(cellCoords) != null) && !isRamp(cellCoords))
                {
                    _tilePaintParams.cellCoords = cellCoords;
                    paintTile(_tilePaintParams);
                }
            }

            _occupiedCells.Clear();
        }

        public void paintRamps(TileRuleBrush brush)
        {
            if (_sortedRampRules.Count == 0) return;

            _tilePaintParams.clear();
            _tilePaintParams.paintReason    = TilePaintReason.Paint;
            _tilePaintParams.paintingRamp   = true;

            // Update tiles inside brush
            bool paintedRamp = false;
            brush.getCellCoords(_occupiedCells);
            foreach (var cellCoords in _occupiedCells)
            {
                _tilePaintParams.cellCoords = cellCoords;
                if (paintTile(_tilePaintParams) != null) paintedRamp = true;
            }

            // Update platforms
            _tilePaintParams.paintingRamp = false;
            brush.getCellCoordsBelowBrush(_cellsBelow);
            foreach (var cellCoords in _cellsBelow)
            {
                if (getTileObject(cellCoords) != null &&
                    getTileObject(new Vector3Int(cellCoords.x, cellCoords.y + 1, cellCoords.z)) != null)
                {
                    _tilePaintParams.cellCoords = cellCoords;
                    paintTile(_tilePaintParams);
                }
            }

            if (paintedRamp)
            {
                // Update tiles around brush borders
                brush.getCellsAroundVerticalBorder((int)settings.tileRuleNeighborRadius, _cellsAroundVertBorder);
                foreach (var cellCoords in _cellsAroundVertBorder)
                {
                    // Note: We don't update ramps.
                    if ((getTileObject(cellCoords) != null) && !isRamp(cellCoords))
                    {
                        _tilePaintParams.cellCoords = cellCoords;
                        paintTile(_tilePaintParams);
                    }
                }
            }

            _occupiedCells.Clear();
        }

        public void eraseTiles(TileRuleBrush brush)
        {
            _tilePaintParams.clear();
            _tilePaintParams.paintReason = TilePaintReason.Erase;

            // Delete tiles inside brush
            brush.getCellCoords(_eraseBrushCells);
            if (spawnSettings.eraseForeignObjects)
            {
                foreach (var cellCoords in _eraseBrushCells)
                {
                    eraseForeignObjects(cellCoords);
                    eraseTile(cellCoords);
                }
            }
            else
            {
                foreach (var cellCoords in _eraseBrushCells)
                    eraseTile(cellCoords);
            }
            _eraseBrushCells.Clear();

            // Update tiles around brush borders
            brush.getCellsAroundVerticalBorder((int)settings.tileRuleNeighborRadius, _cellsAroundVertBorder);
            foreach (var cellCoords in _cellsAroundVertBorder)
            {
                // Note: We don't update ramps.
                if ((getTileObject(cellCoords) != null) && !isRamp(cellCoords))
                {
                    _tilePaintParams.cellCoords = cellCoords;
                    paintTile(_tilePaintParams);
                }
            }
            _cellsAroundVertBorder.Clear();
        }

        public void connect(TileRuleConnect tileRuleConnect)
        {
            int numConnectionPaths = tileRuleConnect.numConnectionPaths;
            for (int i = 0; i < numConnectionPaths; ++i)
                connect(tileRuleConnect.getConnectionPath(i));
        }

        private void connect(TileRuleConnectionPath connectionPath)
        {
            if (connectionPath.cells.Count == 0) return;

            _tilePaintParams.clear();
            _tilePaintParams.paintReason = TilePaintReason.Connect;

            int numConnectionCells = connectionPath.cells.Count;
            if (numConnectionCells == 0) return;

            // Note: Need to fill the occupied cell set for correctly updating the tiles.
            _occupiedCells.Clear();
            foreach (var cell in  connectionPath.cells)
                _occupiedCells.Add(cell);

            // Store needed data
            Vector3Int platformCoords   = Vector3Int.zero;
            bool fillCorners            = spawnSettings.connectFillCorners;
            bool generateRamps          = spawnSettings.connectGenerateRamps && _sortedRampRules.Count != 0;
            bool movingUp               = connectionPath.firstCell.y < connectionPath.lastCell.y;
            if (connectionPath.firstCell.y == connectionPath.lastCell.y)
            {
                fillCorners     = false;
                generateRamps   = false;
            }

            // Paint tiles
            for (int i = 0; i < numConnectionCells; ++i)
            {
                _tilePaintParams.paintingRamp   = false;
                _tilePaintParams.cellCoords     = connectionPath.cells[i];
                paintTile(_tilePaintParams);

                // Update tiles around this tile. Don't update ramps.
                updateSurroundingTiles_IgnoreRamps(_tilePaintParams.cellCoords);

                // Update the tile below (i.e. turn it into a platform)
                convertTileBelowToPlatform(connectionPath.cells[i]);
            
                // Generate ramp if necessary
                if (generateRamps)
                {
                    // Check if a ramp must be generated
                    bool paintRamp = false;
                    if (movingUp) paintRamp = (i < numConnectionCells - 1) && (connectionPath.cells[i + 1].y - connectionPath.cells[i].y == 1);
                    else paintRamp = (i >= 1) && (connectionPath.cells[i - 1].y - connectionPath.cells[i].y == 1);

                    if (paintRamp)
                    {
                        // Generate ramp
                        _tilePaintParams.paintingRamp   = true;
                        _tilePaintParams.cellCoords     = connectionPath.cells[i];
                        ++_tilePaintParams.cellCoords.y;
                        paintTile(_tilePaintParams);

                        // Update tiles
                        updateSurroundingTiles_IgnoreRamps(_tilePaintParams.cellCoords);
                        convertTileBelowToPlatform(_tilePaintParams.cellCoords);

                        // We need to check if the ramp is sitting in a corner, in which case,
                        // we need to paint tiles in order to make the ramp accessible.
                        if (i >= 1 && i < numConnectionCells - 1) 
                        {
                            Vector3Int currentCoords    = connectionPath.cells[i];
                            Vector3Int prevCoords       = connectionPath.cells[i - 1];
                            Vector3Int nextCoords       = connectionPath.cells[i + 1];
                            if (movingUp)
                            {
                                if (currentCoords.z == prevCoords.z && currentCoords.z != nextCoords.z)
                                {
                                    int zCoord = currentCoords.z + (int)Mathf.Sign(currentCoords.z - nextCoords.z);

                                    _cellCoordsBuffer.Clear();
                                    _cellCoordsBuffer.Add(new Vector3Int(currentCoords.x, currentCoords.y, zCoord));
                                    _cellCoordsBuffer.Add(new Vector3Int(prevCoords.x, currentCoords.y, zCoord));
                                    paintTilesAndUpdateSurroundings(_cellCoordsBuffer);
                                }
                                else
                                if (currentCoords.x == prevCoords.x && currentCoords.x != nextCoords.x)
                                {
                                    int xCoord = currentCoords.x + (int)Mathf.Sign(currentCoords.x - nextCoords.x);

                                    _cellCoordsBuffer.Clear();
                                    _cellCoordsBuffer.Add(new Vector3Int(xCoord, currentCoords.y, currentCoords.z));
                                    _cellCoordsBuffer.Add(new Vector3Int(xCoord, currentCoords.y, prevCoords.z));
                                    paintTilesAndUpdateSurroundings(_cellCoordsBuffer);
                                }
                            }
                            else
                            {
                                if (currentCoords.z == prevCoords.z && currentCoords.z != nextCoords.z)
                                {
                                    int xCoord = currentCoords.x + (int)Mathf.Sign(currentCoords.x - prevCoords.x);

                                    _cellCoordsBuffer.Clear();
                                    _cellCoordsBuffer.Add(new Vector3Int(xCoord, currentCoords.y, currentCoords.z));
                                    _cellCoordsBuffer.Add(new Vector3Int(xCoord, currentCoords.y, nextCoords.z));
                                    paintTilesAndUpdateSurroundings(_cellCoordsBuffer);
                                }
                                else
                                if (currentCoords.x == prevCoords.x && currentCoords.x != nextCoords.x)
                                {
                                    int zCoord = currentCoords.z + (int)Mathf.Sign(currentCoords.z - prevCoords.z);

                                    _cellCoordsBuffer.Clear();
                                    _cellCoordsBuffer.Add(new Vector3Int(currentCoords.x, currentCoords.y, zCoord));
                                    _cellCoordsBuffer.Add(new Vector3Int(nextCoords.x, currentCoords.y, zCoord));
                                    paintTilesAndUpdateSurroundings(_cellCoordsBuffer);
                                }
                            }
                        }
                    }
                }

                // Generate tiles below to fill corners
                if (fillCorners)
                {
                    // Is the previous or next tile lower?
                    bool paintTileBelow     = (i >= 1 && connectionPath.cells[i - 1].y < connectionPath.cells[i].y);
                    paintTileBelow          |= (i < (numConnectionCells - 1) && connectionPath.cells[i + 1].y < connectionPath.cells[i].y);

                    // Paint tile if necessary
                    if (paintTileBelow)
                    {
                        // Paint tile
                        platformCoords = connectionPath.cells[i];
                        --platformCoords.y;
                        _tilePaintParams.cellCoords = platformCoords;
                        paintTile(_tilePaintParams);

                        // Update tiles
                        updateSurroundingTiles_IgnoreRamps(_tilePaintParams.cellCoords);
                        convertTileBelowToPlatform(_tilePaintParams.cellCoords);
                    }
                }
            }
        }

        [NonSerialized]
        private TilePaintParams _paintParams_PaintAndUpdate = new TilePaintParams();
        private void paintTilesAndUpdateSurroundings(List<Vector3Int> cellCoords)
        {
            foreach (var coords in cellCoords)
            {
                _paintParams_PaintAndUpdate.paintingRamp   = false;
                _paintParams_PaintAndUpdate.cellCoords     = coords;
                paintTile(_paintParams_PaintAndUpdate);
                updateSurroundingTiles_IgnoreRamps(_paintParams_PaintAndUpdate.cellCoords);
                convertTileBelowToPlatform(coords);
            }
        }

        [NonSerialized]
        private TilePaintParams _paintParams_UpdateSurrounding = new TilePaintParams();
        private void updateSurroundingTiles_IgnoreRamps(Vector3Int tileCoords)
        {
            _paintParams_UpdateSurrounding.paintingRamp = false;
            getCellsAroundVerticalBorder(tileCoords, (int)settings.tileRuleNeighborRadius, _cellsAroundVertBorder);
            foreach (var cellCoords in _cellsAroundVertBorder)
            {
                if ((getTileObject(cellCoords) != null) && !isRamp(cellCoords))
                {
                    _paintParams_UpdateSurrounding.cellCoords = cellCoords;
                    paintTile(_paintParams_UpdateSurrounding);
                }
            }
        }

        [NonSerialized]
        private TilePaintParams _paintParams_ConvertToPlatform = new TilePaintParams();
        private void convertTileBelowToPlatform(Vector3Int tileAbove)
        {
            _paintParams_ConvertToPlatform.paintingRamp = false;
            Vector3Int cellBelow = new Vector3Int(tileAbove.x, tileAbove.y - 1, tileAbove.z);
            if (getTileObject(cellBelow) != null)
            {
                _paintParams_ConvertToPlatform.cellCoords = cellBelow;
                paintTile(_paintParams_ConvertToPlatform);
            }
        }

        private void draw(int yOffset)
        {
            GridHandles.DrawConfig drawConfig   = new GridHandles.DrawConfig();
            drawConfig.cellSizeX                = settings.cellSize.x;
            drawConfig.cellSizeZ                = settings.cellSize.z;
            drawConfig.wireColor                = settings.wireColor;
            drawConfig.fillColor                = settings.fillColor;
            drawConfig.origin                   = gridOrigin + gridUp * yOffset * settings.cellSize.y;
            drawConfig.right                    = gridRight;
            drawConfig.look                     = gridLook;
            drawConfig.planeNormal              = gridUp;
            drawConfig.drawCoordSystem          = GridPrefs.instance.drawCoordSystem;
            drawConfig.xAxisColor               = GridPrefs.instance.xAxisColor;
            drawConfig.yAxisColor               = GridPrefs.instance.yAxisColor;
            drawConfig.zAxisColor               = GridPrefs.instance.zAxisColor;
            drawConfig.finiteAxisLength         = GridPrefs.instance.finiteAxisLength;
            drawConfig.infiniteXAxis            = GridPrefs.instance.infiniteXAxis;
            drawConfig.infiniteYAxis            = GridPrefs.instance.infiniteYAxis;
            drawConfig.infiniteZAxis            = GridPrefs.instance.infiniteXAxis;
            GridHandles.drawInfinite(drawConfig, PluginCamera.camera);

            // Note: Draw the gizmo over the grid.
            _mirrorGizmo.rotation               = gridRotation;
            _mirrorGizmo.tileRuleGrid           = this;
            _mirrorGizmo.tileRuleGridYOffset    = yOffset;
            _mirrorGizmo.midSnapMode            = MirrorGizmoMidSnapMode.TileRuleGrid;
            _mirrorGizmo.onSceneGUI();

            // Note: Always force the gizmo to sit at the base of a cell. Random positions not allowed inside a tile grid.
            snapMirrorGizmoPositionToCellBaseCenter();

            if (_mirrorGizmo.isDraggingHandles) TileRuleObjectSpawnUI.instance.refresh();
        }

        public void drawShadow(List<Vector3> shadowCasterCorners, Color shadowLineColor, Color shadowColor)
        {
            HandlesEx.saveColor();
            Handles.color = shadowLineColor;

            Plane plane = gridPlane;
            _shadowCorners.Clear();
            foreach (var pt in shadowCasterCorners)
            {
                Vector3 prjPt = plane.projectPoint(pt);
                Handles.DrawLine(pt, prjPt);

                _shadowCorners.Add(prjPt);
            }

            Handles.color = shadowColor;
            Handles.DrawLine(_shadowCorners[0], _shadowCorners[1]);
            Handles.DrawLine(_shadowCorners[1], _shadowCorners[2]);
            Handles.DrawLine(_shadowCorners[2], _shadowCorners[3]);
            Handles.DrawLine(_shadowCorners[3], _shadowCorners[0]);

            HandlesEx.restoreColor();
        }

        private void snapMirrorGizmoPositionToCellBaseCenter()
        {
            _mirrorGizmo.position = cellCoordsToCellPosition(worldPointToCellCoords(_mirrorGizmo.position));
        }

        private GameObject paintTile(TilePaintParams paintParams)
        {
            // Must we paint a platform?
            Vector3Int cellCoords = paintParams.cellCoords;
            bool paintingPlatform = _sortedPlatformRules.Count != 0 && mustPaintPlatform(cellCoords);

            // Identify the tile rule list that we're going to use
            Vector3Int neighborMaskCoords = cellCoords;
            var tileRules = _sortedStdRules;
            if (paintingPlatform)
            {
                tileRules = _sortedPlatformRules;

                /*var moveUpCoords = neighborMaskCoords;
                ++moveUpCoords.y;
                while (getTileObject(moveUpCoords) != null)
                {
                    neighborMaskCoords = moveUpCoords;
                    ++moveUpCoords.y;
                }*/
            }
            else if (paintParams.paintingRamp) tileRules = _sortedRampRules;

            // Check if we have a matching rule for this position. If not, we can exit.
            ulong neighborMask  = calcNeighborMask(neighborMaskCoords, paintParams);
            TileRuleMaskMatchResult matchResult;
            TileRule tileRule   = matchRule(neighborMask, tileRules, !paintParams.paintingRamp, out matchResult);
            if (tileRule == null) return null;

            // Destroy the old tile that resides at this position
            GameObject oldTile = getTileObject(cellCoords);
            if (oldTile != null)
            {
                // Remove the tile record and destroy the game object
                removeTileRecord(cellCoords);
                UndoEx.destroyGameObjectImmediate(oldTile);

                // Note: If we are painting ramps, don't do anything. The tile
                //       will just be replaced with another ramp. Otherwise,
                //       we need to update the edit data accordingly.
                if (!paintParams.paintingRamp)
                {
                    if (isRamp(cellCoords))
                        _editData.removedRampCells.Add(cellCoords);
                }
            }
            else
            {
                // Just in case tile objects were deleted using means other than the tile rule interface
                if (!paintParams.paintingRamp)
                {
                    if (isRamp(cellCoords))
                        _editData.removedRampCells.Add(cellCoords);
                }
                removeTileRecordIfExists(cellCoords);
            }

            // Setup the prefab pick params
            _prefabPickParams.grid          = this;
            _prefabPickParams.cellCoords    = cellCoords;

            // Finally, we can spawn a new tile. Calculate the spawn data.
            _tileSpawnData.reset();
            _tileSpawnData.rule         = tileRule;
            _tileSpawnData.rulePrefab   = tileRule.pickPrefab(_prefabPickParams);
            if (_tileSpawnData.rulePrefab == null) return null;

            _tileSpawnData.isRamp       = paintParams.paintingRamp && !paintingPlatform;
            // Note: Always apply rotation even if mirroring was used. We need to orient the object
            //       so that it sits on the grid plane.
            //Quaternion baseRotation         = _tileSpawnData.rulePrefab.prefabAsset.transform.rotation;
            if (_usingSprites) _tileSpawnData.rotation = Quaternion.LookRotation(-gridUp, TileRuleMask.maskRotationToLookAxis(matchResult.maskRotation, gridRotation));// * baseRotation;
            else _tileSpawnData.rotation = Quaternion.LookRotation(TileRuleMask.maskRotationToLookAxis(matchResult.maskRotation, gridRotation), gridUp);// * baseRotation;

            // Check if mirroring was used to match the rule. In that case
            // we will have to apply scale to the object.
            if (matchResult.maskMirrorAxis != TileRuleMaskMirrorAxis.None)
            {
                _tileSpawnData.scale = _tileSpawnData.rulePrefab.prefabAsset.transform.localScale;
                _tileFrame[0] = _tileSpawnData.rotation * Vector3.right;
                _tileFrame[1] = _tileSpawnData.rotation * Vector3.up;
                _tileFrame[2] = _tileSpawnData.rotation * Vector3.forward;

                int affectedAxisIndex = 0;
                switch (matchResult.maskMirrorAxis)
                {
                    case TileRuleMaskMirrorAxis.X:

                        affectedAxisIndex = TransformEx.findIndexOfMostAlignedAxis(_tileFrame, gridRight);
                        break;

                    case TileRuleMaskMirrorAxis.Z:

                        affectedAxisIndex = TransformEx.findIndexOfMostAlignedAxis(_tileFrame, gridLook);
                        break;
                }

                if (_usingSprites)
                {
                    if (affectedAxisIndex == 0) _tileSpawnData.flipSpriteX = true;
                    else if (affectedAxisIndex == 1) _tileSpawnData.flipSpriteY = true;
                }
                else _tileSpawnData.scale[affectedAxisIndex] = -_tileSpawnData.scale[affectedAxisIndex];
            }
            else _tileSpawnData.scale = _tileSpawnData.rulePrefab.prefabAsset.transform.localScale;

            // Spawn the tile and return
            return spawnTile(cellCoords, _tileSpawnData);
        }

        private TilePaintParams _eraseTile_PaintParams = new TilePaintParams();
        private void eraseTile(Vector3Int cellCoords)
        {
            // Destroy tile if present
            if (destroyTileForErase(cellCoords))
            {
                // A tile was present. We need to account for any platform that
                // might have been sitting below it.
                Vector3Int platformCoords = new Vector3Int(cellCoords.x, cellCoords.y - 1, cellCoords.z);
                if (getTileObject(platformCoords) != null)
                {
                    _eraseTile_PaintParams.cellCoords = platformCoords;
                    paintTile(_eraseTile_PaintParams);
                }
            }
        }

        private void eraseForeignObjects(Vector3Int cellCoords)
        {
            var overlapOBB              = calcVisualCellOBB(cellCoords);
            overlapOBB.inflate(-1e-2f);
            var overlapConfig           = ObjectOverlapConfig.defaultConfig;
            overlapConfig.prefabMode    = ObjectOverlapPrefabMode.OnlyPrefabInstanceRoot;

            PluginScene.instance.overlapBox(overlapOBB, _foreignEraseOverlapFilter, overlapConfig, _foreignObjectBuffer);
            foreach (var go in _foreignObjectBuffer)
                UndoEx.destroyGameObjectImmediate(go);
        }

        private void commitEditData()
        {
            UndoEx.record(this);

            foreach (var cell in _editData.removedRampCells)
                _state.rampCells.Remove(cell);

            foreach (var cell in _editData.addedRampCells)
                _state.rampCells.Add(cell);

            _editData.clear();
        }

        private void prepareForTileUpdate()
        {
            #pragma warning disable 0612
            _ruleProfile = settings.tileRuleProfile;

            switch (settings.tileRuleNeighborRadius)
            {
                case TileRuleNeighborRadius.One:

                    _neighborOffsets = _neighOffsets_R1;
                    break;

                case TileRuleNeighborRadius.Two:

                    _neighborOffsets = _neighOffsets_R2;
                    break;

                case TileRuleNeighborRadius.Three:

                    _neighborOffsets = _neighOffsets_R3;
                    break;
            }

            // Note: Sort the tile rules based on the number of bits which are set to 1.
            _ruleProfile.getTileRules(TileRuleType.Standard, _sortedStdRules);
            _sortedStdRules.RemoveAll(item => item.numReqOnBitsSet == 0);
            sortRulesDescending(_sortedStdRules);

            _ruleProfile.getTileRules(TileRuleType.Platform, _sortedPlatformRules);
            _sortedPlatformRules.RemoveAll(item => item.numReqOnBitsSet == 0);
            sortRulesDescending(_sortedPlatformRules);

            _ruleProfile.getTileRules(TileRuleType.Ramp, _sortedRampRules);
            _sortedRampRules.RemoveAll(item => item.numReqOnBitsSet == 0);
            sortRulesDescending(_sortedRampRules);
            #pragma warning restore 0612
        }

        private void sortRulesDescending(List<TileRule> tileRules)
        {
            tileRules.Sort(delegate (TileRule r0, TileRule r1) 
            { 
                return (r1.numReqOnBitsSet + r1.numReqOffBitsSet).CompareTo(r0.numReqOnBitsSet + r0.numReqOffBitsSet); });
        }

        private bool mustPaintPlatform(Vector3Int cellCoords)
        {
            if (_sortedPlatformRules.Count == 0) return false;

            // First, check if we are below any of the cells that are marked as occupied
            var checkCell = new Vector3Int(cellCoords.x, cellCoords.y + 1, cellCoords.z);
            if (_occupiedCells.Contains(checkCell)) return true;

            // Just check if there is an object above
            return getTileObject(checkCell) != null;
        }

        private bool isRamp(Vector3Int cell)
        {
            if (_editData.removedRampCells.Contains(cell)) return false;
            return _editData.addedRampCells.Contains(cell) || _state.rampCells.Contains(cell);
        }

        private TileRule matchRule(ulong ruleMask, List<TileRule> tileRules, bool pickFirstWithPrefabs, out TileRuleMaskMatchResult matchResult)
        {
            matchResult     = new TileRuleMaskMatchResult(false);
            int numRules    = tileRules.Count;
            if (numRules == 0) return null;

            for (int i = 0; i < numRules; ++i)
            {
                var tileRule = tileRules[i];

                // Skip rules with no prefabs
                if (tileRule.numPrefabs == 0) continue;

                matchResult = tileRule.match(ruleMask);
                if (matchResult.matched) return tileRule;
            }

            if (pickFirstWithPrefabs)
            {
                foreach (var tileRule in tileRules)
                {
                    if (tileRule.numPrefabs != 0)
                    {
                        matchResult.matched         = true;
                        matchResult.maskRotation    = TileRuleMaskRotation.None;
                        return tileRule;
                    }
                }
            }

            return null;
        }

        private GameObject spawnTile(Vector3Int cellCoords, TileSpawnData spawnData)
        {
            var rulePrefab = spawnData.rulePrefab;
            if (rulePrefab != null)
            {
                Vector3 position        = cellCoordsToCellPosition(cellCoords);
                GameObject tileObject   = rulePrefab.pluginPrefab.spawn(position, spawnData.rotation, spawnData.scale);
        
                // Flip sprite if necessary
                if (spawnData.flipSpriteX)
                {
                    var spriteRenderer      = tileObject.getSpriteRendererInChildren();
                    spriteRenderer.flipX    = !spriteRenderer.flipX;       // Note: It may already be flipped. So always flip relative to the current flip state.
                }
                else
                if (spawnData.flipSpriteY)
                {
                    var spriteRenderer      = tileObject.getSpriteRendererInChildren();
                    spriteRenderer.flipY    = !spriteRenderer.flipY;
                }

                // If the rule prefab is associated with an object group, we need to ensure
                // that the object group is a child of the grid. Otherwise, we detach the
                // object from the group and attach it to the grid.
                if (tileObject.transform.parent != _transform)
                {
                    // The object is attached to an object group or it doesn't have a parent.
                    if (tileObject.transform.parent == null || !tileObject.transform.parent.IsChildOf(_transform))
                        tileObject.transform.parent = _transform;
                }

                // Store the new tile
                addTileRecord(cellCoords, tileObject);
              
                // If we are spawning a ramp, store the cell coordinates of the ramp
                if (spawnData.isRamp) _editData.addedRampCells.Add(cellCoords);

                return tileObject;
            }

            return null;
        }

        private bool destroyTileForErase(Vector3Int cellCoords)
        {
            var tileObject = getTileObject(cellCoords);
            if (tileObject != null)
            {
                if (isRamp(cellCoords))
                    _editData.removedRampCells.Add(cellCoords);

                removeTileRecord(cellCoords);
                UndoEx.destroyGameObjectImmediate(tileObject);

                return true;
            }
            else
            {
                if (isRamp(cellCoords))
                    _editData.removedRampCells.Add(cellCoords);

                removeTileRecordIfExists(cellCoords);
            }

            return false;
        }

        private ulong calcNeighborMask(Vector3Int cellCoords, TilePaintParams paintParams)
        {
            ulong ruleMask = TileRuleMask.defaultReqOnMask;
            for (int i = 0; i < _neighborOffsets.Length; ++i)
            {
                var offset  = _neighborOffsets[i];

                var coords  = cellCoords;
                coords.x    += offset.x;
                coords.z    += offset.y;

                var tile    = getTileObject(coords);

                if ((tile != null && (!paintParams.paintingRamp || !isRamp(coords))) || _occupiedCells.Contains(coords))
                {
                    // Note: Subtract offset.y instead of adding, because in bit mask space, rows decrease upwards.
                    ruleMask |= TileRuleMask.setBit(ruleMask, TileRuleMask.middleBitRow - offset.y, TileRuleMask.middleBitCol + offset.x);
                }
            }

            return ruleMask;
        }

        private void addTileRecord(Vector3Int cellCoords, GameObject tileObject)
        {
            _tileMap.Add(cellCoords, tileObject);
        }

        private GameObject getTileObject(Vector3Int cellCoords)
        {
            GameObject tileObject = null;
            _tileMap.TryGetValue(cellCoords, out tileObject);

            return tileObject;
        }

        private void removeTileRecord(Vector3Int cellCoords)
        {
            _tileMap.Remove(cellCoords);
        }

        private void removeTileRecordIfExists(Vector3Int cellCoords)
        {
            if (_tileMap.ContainsKey(cellCoords))
                _tileMap.Remove(cellCoords);
        }

        private void onUndoRedo()
        {
            registerTilesWithGrid();
        }

        private void onHierarchyChanged()
        {
            if (_gameObject == null)
            {
                UndoEx.saveEnabledState();
                UndoEx.enabled = false;
                TileRuleGridDb.instance.deleteGrid(this);
                UndoEx.restoreEnabledState();
                TileRuleObjectSpawnUI.instance.refresh();
                return;
            }
            else
            if (_gameObject.name != _gridName)
            {
                UndoEx.record(this);
                _gridName= _gameObject.name;
                TileRuleObjectSpawnUI.instance.refresh();
            }
        }

        private void registerTilesWithGrid()
        {
            // Note: Could happen if the grid has just been created (it's being called from OnEnable).
            if (_gameObject == null) return;

            _tileMap.Clear();

            getChildTileRulePrefabInstances(_prefabInstanceRoots);
            foreach (var go in _prefabInstanceRoots)
            {
                Vector3Int cellCoords = worldPointToCellCoords(go.transform.position);
                addTileRecord(cellCoords, go);
            }
        }

        private void getChildTileRulePrefabInstances(List<GameObject> tileRulePrefabInstances)
        {
            _prefabInstanceRootFilter = (GameObject go) =>
            { return !ObjectGroupDb.instance.isObjectGroup(go) && _ruleProfile.containsPrefab(go.getPrefabAsset()); };
            _gameObject.getAllChildren(true, true, _objectBuffer);
            GameObjectEx.getOutermostPrefabInstanceRoots(_objectBuffer, tileRulePrefabInstances, _prefabInstanceRootFilter);
        }

        private void OnEnable()
        {
            if (_settings == null)      _settings       = ScriptableObject.CreateInstance<TileRuleGridSettings>();
            if (_gameObject != null)    _transform      = _gameObject.transform;

            EditorApplication.hierarchyChanged  += onHierarchyChanged;
            Undo.undoRedoPerformed              += onUndoRedo;

            _ruleProfile = settings.tileRuleProfile;
            registerTilesWithGrid();

            _foreignEraseOverlapFilter.objectTypes  = GameObjectType.All & ~(GameObjectType.Light | GameObjectType.Camera | GameObjectType.Terrain);
            _foreignEraseOverlapFilter.customFilter = (GameObject go) => { return !go.transform.IsChildOf(_transform); };

            if (_mirrorGizmo == null)           _mirrorGizmo            = ScriptableObject.CreateInstance<ObjectMirrorGizmo>();
            if (_mirrorGizmoSettings == null)   _mirrorGizmoSettings    = ScriptableObject.CreateInstance<ObjectMirrorGizmoSettings>();

            _mirrorGizmo.sharedSettings = _mirrorGizmoSettings;
        }

        private void OnDisable()
        {
            EditorApplication.hierarchyChanged  -= onHierarchyChanged;
            Undo.undoRedoPerformed              -= onUndoRedo;
        }

        private void OnDestroy()
        {
            if (_settings != null)              UndoEx.destroyObjectImmediate(_settings);
            if (_mirrorGizmo != null)           UndoEx.destroyObjectImmediate(_mirrorGizmo);
            if (_mirrorGizmoSettings != null)   UndoEx.destroyObjectImmediate(_mirrorGizmoSettings);
        }
    }
}
#endif