private static void CreateIsometricTilemap(GridLayout.CellLayout isometricLayout, string undoMessage) { var root = FindOrCreateRootGrid(); var uniqueName = GameObjectUtility.GetUniqueNameForSibling(root.transform, "Tilemap"); var tilemapGO = ObjectFactory.CreateGameObject(uniqueName, typeof(Tilemap), typeof(TilemapRenderer)); tilemapGO.transform.SetParent(root.transform); tilemapGO.transform.position = Vector3.zero; var grid = root.GetComponent <Grid>(); // Case 1071703: Do not reset cell size if adding a new Tilemap to an existing Grid of the same layout if (isometricLayout != grid.cellLayout) { grid.cellLayout = isometricLayout; grid.cellSize = new Vector3(1.0f, 0.5f, 1.0f); } var tilemapRenderer = tilemapGO.GetComponent <TilemapRenderer>(); tilemapRenderer.sortOrder = TilemapRenderer.SortOrder.TopRight; Selection.activeGameObject = tilemapGO; Undo.RegisterCreatedObjectUndo(tilemapGO, undoMessage); }
/// <summary> /// Rotates the brush by 90 degrees in the given direction. /// </summary> /// <param name="direction">Direction to rotate by.</param> /// <param name="layout">Cell Layout for rotating.</param> public override void Rotate(RotationDirection direction, GridLayout.CellLayout layout) { Vector3Int oldSize = m_Size; BrushCell[] oldCells = m_Cells.Clone() as BrushCell[]; size = new Vector3Int(oldSize.y, oldSize.x, oldSize.z); BoundsInt oldBounds = new BoundsInt(Vector3Int.zero, oldSize); foreach (Vector3Int oldPos in oldBounds.allPositionsWithin) { int newX = direction == RotationDirection.Clockwise ? oldSize.y - oldPos.y - 1 : oldPos.y; int newY = direction == RotationDirection.Clockwise ? oldPos.x : oldSize.x - oldPos.x - 1; int toIndex = GetCellIndex(newX, newY, oldPos.z); int fromIndex = GetCellIndex(oldPos.x, oldPos.y, oldPos.z, oldSize.x, oldSize.y, oldSize.z); m_Cells[toIndex] = oldCells[fromIndex]; } int newPivotX = direction == RotationDirection.Clockwise ? oldSize.y - pivot.y - 1 : pivot.y; int newPivotY = direction == RotationDirection.Clockwise ? pivot.x : oldSize.x - pivot.x - 1; pivot = new Vector3Int(newPivotX, newPivotY, pivot.z); Matrix4x4 rotation = Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0f, 0f, direction == RotationDirection.Clockwise ? 90f : -90f), Vector3.one); Quaternion orientation = Quaternion.Euler(0f, 0f, direction == RotationDirection.Clockwise ? 90f : -90f); foreach (BrushCell cell in m_Cells) { cell.offset = rotation * cell.offset; cell.orientation = cell.orientation * orientation; } }
public override void Flip(FlipAxis flip, GridLayout.CellLayout layout) { if (UnityEngine.Event.current.character == '>') { // TODO flip? } }
//-------------------------------------------------------------------------/ // Ranges //-------------------------------------------------------------------------/ /// <summary> /// Returns the cell range given an origin /// </summary> public static Dictionary <Vector3Int, float> GetRange(Vector3Int origin, int n, GridLayout.CellLayout layout, Predicate <Vector3Int> predicate) { Dictionary <Vector3Int, float> result = null; switch (layout) { case GridLayout.CellLayout.Rectangle: result = GetRangeRectangle(origin, n, predicate); break; case GridLayout.CellLayout.Hexagon: result = GetRangeHexOffset(origin, n, predicate); break; case GridLayout.CellLayout.Isometric: break; case GridLayout.CellLayout.IsometricZAsY: break; default: break; } return(result); }
static void CreateAssetObject(string defaultAssetName, GridLayout.CellLayout layout, GridLayout.CellSwizzle swizzle, GridPalette.CellSizing cellSizing, Vector3 cellSize) { var assetSelectionPath = AssetDatabase.GetAssetPath(Selection.activeObject); var isFolder = false; if (!string.IsNullOrEmpty(assetSelectionPath)) { isFolder = File.GetAttributes(assetSelectionPath).HasFlag(FileAttributes.Directory); } var path = ProjectWindowUtil.GetActiveFolderPath(); if (isFolder) { path = assetSelectionPath; } var destName = AssetDatabase.GenerateUniqueAssetPath(Path.Combine(path, defaultAssetName)); var icon = EditorGUIUtility.IconContent <GameObject>().image as Texture2D; CreateAssetEndNameEditAction action = ScriptableObject.CreateInstance <CreateAssetEndNameEditAction>(); action.swizzle = swizzle; action.layout = layout; action.cellSize = cellSize; action.cellSizing = cellSizing; StartNewAssetNameEditingDelegate(0, action, destName, icon, ""); }
public override void Rotate(GridBrushBase.RotationDirection direction, GridLayout.CellLayout layout) { Vector3Int size = this.m_Size; GridBrush.BrushCell[] array = this.m_Cells.Clone() as GridBrush.BrushCell[]; this.size = new Vector3Int(size.y, size.x, size.z); BoundsInt boundsInt = new BoundsInt(Vector3Int.zero, size); foreach (Vector3Int current in boundsInt.allPositionsWithin) { int x = (direction != GridBrushBase.RotationDirection.Clockwise) ? current.y : (size.y - current.y - 1); int y = (direction != GridBrushBase.RotationDirection.Clockwise) ? (size.x - current.x - 1) : current.x; int cellIndex = this.GetCellIndex(x, y, current.z); int cellIndex2 = this.GetCellIndex(current.x, current.y, current.z, size.x, size.y, size.z); this.m_Cells[cellIndex] = array[cellIndex2]; } int x2 = (direction != GridBrushBase.RotationDirection.Clockwise) ? this.pivot.y : (size.y - this.pivot.y - 1); int y2 = (direction != GridBrushBase.RotationDirection.Clockwise) ? (size.x - this.pivot.x - 1) : this.pivot.x; this.pivot = new Vector3Int(x2, y2, this.pivot.z); Matrix4x4 rhs = Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0f, 0f, (direction != GridBrushBase.RotationDirection.Clockwise) ? -90f : 90f), Vector3.one); GridBrush.BrushCell[] cells = this.m_Cells; for (int i = 0; i < cells.Length; i++) { GridBrush.BrushCell brushCell = cells[i]; Matrix4x4 matrix = brushCell.matrix; brushCell.matrix = matrix * rhs; } }
private static GameObject CreateNewLayer(GameObject paletteGO, string name, GridLayout.CellLayout layout) { GameObject newLayerGO = new GameObject(name); var tilemap = newLayerGO.AddComponent <Tilemap>(); var renderer = newLayerGO.AddComponent <TilemapRenderer>(); newLayerGO.transform.parent = paletteGO.transform; newLayerGO.layer = paletteGO.layer; // Set defaults for certain layouts switch (layout) { case GridLayout.CellLayout.Hexagon: { tilemap.tileAnchor = Vector3.zero; break; } case GridLayout.CellLayout.Isometric: { renderer.sortOrder = TilemapRenderer.SortOrder.TopRight; break; } case GridLayout.CellLayout.IsometricZAsY: { renderer.sortOrder = TilemapRenderer.SortOrder.TopRight; renderer.mode = TilemapRenderer.Mode.Individual; break; } } return(newLayerGO); }
/// <summary> /// Creates a Palette Asset at the given folder path. /// </summary> /// <param name="folderPath">Folder Path of the Palette Asset.</param> /// <param name="name">Name of the Palette Asset.</param> /// <param name="layout">Grid Layout of the Palette Asset.</param> /// <param name="cellSizing">Cell Sizing of the Palette Asset.</param> /// <param name="cellSize">Cell Size of the Palette Asset.</param> /// <param name="swizzle">Cell Swizzle of the Palette.</param> /// <param name="sortMode">Transparency Sort Mode for the Palette</param> /// <param name="sortAxis">Transparency Sort Axis for the Palette</param> /// <returns>The created Palette Asset if successful.</returns> public static GameObject CreateNewPalette(string folderPath , string name , GridLayout.CellLayout layout , GridPalette.CellSizing cellSizing , Vector3 cellSize , GridLayout.CellSwizzle swizzle , TransparencySortMode sortMode , Vector3 sortAxis) { GameObject temporaryGO = new GameObject(name); Grid grid = temporaryGO.AddComponent <Grid>(); // We set size to kEpsilon to mark this as new uninitialized palette // Nice default size can be decided when first asset is dragged in grid.cellSize = cellSize; grid.cellLayout = layout; grid.cellSwizzle = swizzle; CreateNewLayer(temporaryGO, "Layer1", layout); string path = AssetDatabase.GenerateUniqueAssetPath(folderPath + "/" + name + ".prefab"); Object prefab = PrefabUtility.SaveAsPrefabAssetAndConnect(temporaryGO, path, InteractionMode.AutomatedAction); GridPalette palette = CreateGridPalette(cellSizing, sortMode, sortAxis); AssetDatabase.AddObjectToAsset(palette, prefab); PrefabUtility.ApplyPrefabInstance(temporaryGO, InteractionMode.AutomatedAction); AssetDatabase.Refresh(); Object.DestroyImmediate(temporaryGO); return(AssetDatabase.LoadAssetAtPath <GameObject>(path)); }
public override void Rotate(RotationDirection direction, GridLayout.CellLayout layout) { LayerTile tile = cells[0].tile as LayerTile; if (tile != null) { cells[0].matrix = tile.Rotate(cells[0].matrix, direction == RotationDirection.Clockwise); } }
/// <summary> /// Creates a Palette Asset at the given folder path. /// </summary> /// <param name="folderPath">Folder Path of the Palette Asset.</param> /// <param name="name">Name of the Palette Asset.</param> /// <param name="layout">Grid Layout of the Palette Asset.</param> /// <param name="cellSizing">Cell Sizing of the Palette Asset.</param> /// <param name="cellSize">Cell Size of the Palette Asset.</param> /// <param name="swizzle">Cell Swizzle of the Palette.</param> /// <returns>The created Palette Asset if successful.</returns> public static GameObject CreateNewPalette(string folderPath , string name , GridLayout.CellLayout layout , GridPalette.CellSizing cellSizing , Vector3 cellSize , GridLayout.CellSwizzle swizzle) { return(CreateNewPalette(folderPath, name, layout, cellSizing, cellSize, swizzle, TransparencySortMode.Default, defaultSortAxis)); }
public override void Flip(GridBrushBase.FlipAxis flip, GridLayout.CellLayout layout) { if (flip == GridBrushBase.FlipAxis.X) { this.FlipX(); } else { this.FlipY(); } }
/// <summary>Flips the brush in the given axis.</summary> /// <param name="flip">Axis to flip by.</param> /// <param name="layout">Cell Layout for flipping.</param> public override void Flip(FlipAxis flip, GridLayout.CellLayout layout) { if (flip == FlipAxis.X) { FlipX(); } else { FlipY(); } }
public override void Flip(FlipAxis flip, GridLayout.CellLayout layout) { base.Flip(flip, layout); if (flip == FlipAxis.X) { AddToPrefabRotation(Vector3.up * 180); } else if (flip == FlipAxis.Y) { AddToPrefabRotation(Vector3.forward * 180); } }
public override void Rotate(RotationDirection direction, GridLayout.CellLayout layout) { if (gridBrushes == null) { return; } foreach (var gridBrush in gridBrushes) { gridBrush.Rotate(direction, layout); } }
public override void Rotate(RotationDirection direction, GridLayout.CellLayout layout) { if (Event.current.character == '<') { var tile = cells[0].tile as LayerTile; if (tile != null) { cells[0].matrix = tile.Rotate(cells[0].matrix, direction == RotationDirection.Clockwise); } } }
public override void Flip(FlipAxis flip, GridLayout.CellLayout layout) { if (gridBrushes == null) { return; } foreach (var gridBrush in gridBrushes) { gridBrush.Flip(flip, layout); } }
public override void Rotate(RotationDirection direction, GridLayout.CellLayout layout) { base.Rotate(direction, layout); if (direction == RotationDirection.Clockwise) { AddToPrefabRotation(Vector3.forward * 90f); } else if (direction == RotationDirection.CounterClockwise) { AddToPrefabRotation(Vector3.forward * -90f); } }
public static GameObject CreateNewPaletteNamed(string name, GridLayout.CellLayout layout, GridPalette.CellSizing cellSizing, Vector3 cellSize, GridLayout.CellSwizzle swizzle) { string defaultPath = ProjectBrowser.s_LastInteractedProjectBrowser ? ProjectBrowser.s_LastInteractedProjectBrowser.GetActiveFolderPath() : "Assets"; string folderPath = EditorUtility.SaveFolderPanel("Create palette into folder ", defaultPath, ""); folderPath = FileUtil.GetProjectRelativePath(folderPath); if (string.IsNullOrEmpty(folderPath)) { return(null); } return(CreateNewPalette(folderPath, name, layout, cellSizing, cellSize, swizzle)); }
public static GameObject CreateNewLayer(GameObject paletteGO, string name, GridLayout.CellLayout layout) { GameObject gameObject = new GameObject(name); gameObject.AddComponent <Tilemap>(); gameObject.AddComponent <TilemapRenderer>(); gameObject.transform.parent = paletteGO.transform; gameObject.layer = paletteGO.layer; if (layout == GridLayout.CellLayout.Rectangle) { paletteGO.GetComponent <Grid>().cellSize = new Vector3(1f, 1f, 0f); } return(gameObject); }
public static GameObject CreateNewPaletteNamed(string name, GridLayout.CellLayout layout, GridPalette.CellSizing cellSizing, Vector3 cellSize) { string folder = (!ProjectBrowser.s_LastInteractedProjectBrowser) ? "Assets" : ProjectBrowser.s_LastInteractedProjectBrowser.GetActiveFolderPath(); string text = EditorUtility.SaveFolderPanel("Create palette into folder ", folder, ""); text = FileUtil.GetProjectRelativePath(text); GameObject result; if (string.IsNullOrEmpty(text)) { result = null; } else { result = GridPaletteUtility.CreateNewPalette(text, name, layout, cellSizing, cellSize); } return(result); }
private void FlipY(GridLayout.CellLayout layout) { BrushCell[] oldCells = m_Cells.Clone() as BrushCell[]; BoundsInt oldBounds = new BoundsInt(Vector3Int.zero, m_Size); foreach (Vector3Int oldPos in oldBounds.allPositionsWithin) { int newY = m_Size.y - oldPos.y - 1; int toIndex = GetCellIndex(oldPos.x, newY, oldPos.z); int fromIndex = GetCellIndex(oldPos); m_Cells[toIndex] = oldCells[fromIndex]; } int newPivotY = m_Size.y - pivot.y - 1; pivot = new Vector3Int(pivot.x, newPivotY, pivot.z); FlipCells(ref m_Cells, new Vector3(1f, -1f, 1f), layout == GridLayout.CellLayout.Hexagon); }
/// <summary>Rotates the brush by 90 degrees in the given direction.</summary> /// <param name="direction">Direction to rotate by.</param> /// <param name="layout">Cell Layout for rotating.</param> public override void Rotate(RotationDirection direction, GridLayout.CellLayout layout) { switch (layout) { case GridLayout.CellLayout.Hexagon: RotateHexagon(direction); break; case GridLayout.CellLayout.Isometric: case GridLayout.CellLayout.IsometricZAsY: case GridLayout.CellLayout.Rectangle: { Vector3Int oldSize = m_Size; BrushCell[] oldCells = m_Cells.Clone() as BrushCell[]; size = new Vector3Int(oldSize.y, oldSize.x, oldSize.z); BoundsInt oldBounds = new BoundsInt(Vector3Int.zero, oldSize); foreach (Vector3Int oldPos in oldBounds.allPositionsWithin) { int newX = direction == RotationDirection.Clockwise ? oldPos.y : oldSize.y - oldPos.y - 1; int newY = direction == RotationDirection.Clockwise ? oldSize.x - oldPos.x - 1 : oldPos.x; int toIndex = GetCellIndex(newX, newY, oldPos.z); int fromIndex = GetCellIndex(oldPos.x, oldPos.y, oldPos.z, oldSize.x, oldSize.y, oldSize.z); m_Cells[toIndex] = oldCells[fromIndex]; } int newPivotX = direction == RotationDirection.Clockwise ? pivot.y : oldSize.y - pivot.y - 1; int newPivotY = direction == RotationDirection.Clockwise ? oldSize.x - pivot.x - 1 : pivot.x; pivot = new Vector3Int(newPivotX, newPivotY, pivot.z); Matrix4x4 rotation = direction == RotationDirection.Clockwise ? s_Clockwise : s_CounterClockwise; Matrix4x4 counterRotation = direction != RotationDirection.Clockwise ? s_Clockwise : s_CounterClockwise; foreach (BrushCell cell in m_Cells) { Matrix4x4 oldMatrix = cell.matrix; bool counter = (oldMatrix.lossyScale.x < 0) ^ (oldMatrix.lossyScale.y < 0); cell.matrix = oldMatrix * (counter ? counterRotation : rotation); } } break; } }
public override void Rotate(RotationDirection direction, GridLayout.CellLayout layout) { if (m_RandomRotation) { return; } switch (direction) { case RotationDirection.Clockwise: m_rotationStep = Mod(m_rotationStep + 1, 4); break; case RotationDirection.CounterClockwise: m_rotationStep = Mod(m_rotationStep - 1, 4); break; } base.Rotate(direction, layout); }
public static GameObject CreateNewPalette(string folderPath, string name, GridLayout.CellLayout layout, GridPalette.CellSizing cellSizing, Vector3 cellSize) { GameObject gameObject = new GameObject(name); Grid grid = gameObject.AddComponent <Grid>(); grid.cellSize = cellSize; grid.cellLayout = layout; GridPaletteUtility.CreateNewLayer(gameObject, "Layer1", layout); string text = AssetDatabase.GenerateUniqueAssetPath(folderPath + "/" + name + ".prefab"); UnityEngine.Object @object = PrefabUtility.CreateEmptyPrefab(text); GridPalette gridPalette = ScriptableObject.CreateInstance <GridPalette>(); gridPalette.name = "Palette Settings"; gridPalette.cellSizing = cellSizing; AssetDatabase.AddObjectToAsset(gridPalette, @object); PrefabUtility.ReplacePrefab(gameObject, @object, ReplacePrefabOptions.Default); AssetDatabase.Refresh(); UnityEngine.Object.DestroyImmediate(gameObject); return(AssetDatabase.LoadAssetAtPath <GameObject>(text)); }
public static Vector3Int[] FindNeighboringCells(Vector3Int element, GridLayout.CellLayout layout) { Vector3Int[] result = null; switch (layout) { case GridLayout.CellLayout.Rectangle: result = FindNeighboringCellsRectangle(element); break; case GridLayout.CellLayout.Hexagon: result = FindNeighboringCellsHexOffset(element); break; case GridLayout.CellLayout.Isometric: break; case GridLayout.CellLayout.IsometricZAsY: break; } return(result); }
//-------------------------------------------------------------------------/ // Path //-------------------------------------------------------------------------/ public static Vector3Int[] FindPath(Vector3Int origin, Vector3Int target, GridLayout.CellLayout layout, Predicate <Vector3Int> traversablePredicate = null) { Vector3Int[] result = null; switch (layout) { case GridLayout.CellLayout.Rectangle: result = FindRectanglePath(origin, target, traversablePredicate); break; case GridLayout.CellLayout.Hexagon: result = FindHexOffsetPath(origin, target, traversablePredicate); break; case GridLayout.CellLayout.Isometric: break; case GridLayout.CellLayout.IsometricZAsY: break; } return(result); }
private void Start() { grid = GetComponent <Grid>(); layout = grid.cellLayout; grid_spaces = new GameObject[columns, rows]; switch (layout) { case GridLayout.CellLayout.Rectangle: xstep = 1.0f; zstep = 1.0f; break; case GridLayout.CellLayout.Hexagon: xstep = 1.0f; zstep = 0.75f; break; } for (int x = 0; x < columns; x++) { for (int z = 0; z < rows; z++) { grid_spaces[x, z] = Instantiate(space_prefab); grid_spaces[x, z].transform.parent = transform; switch (layout) { case GridLayout.CellLayout.Rectangle: grid_spaces[x, z].transform.position = new Vector3(0.5f + x * xstep, 0, 0.5f + z * zstep); break; case GridLayout.CellLayout.Hexagon: grid_spaces[x, z].transform.position = new Vector3((z % 2 * 0.5f) + x * xstep, 0, z * zstep); break; } } } }
/// <summary> /// Converts Objects that can be laid out in the Tile Palette and organises them for placement into a given CellLayout /// </summary> /// <param name="sheetTextures">Textures containing 2-N equal sized Sprites</param> /// <param name="singleSprites">All the leftover Sprites that were in same texture but different sizes or just dragged in as Sprite</param> /// <param name="tiles">Just plain tiles</param> /// <param name="cellLayout">Cell Layout to place objects on</param> /// <returns>Dictionary mapping the positions of the Objects on the Grid Layout with details of how to place the Objects</returns> public static Dictionary <Vector2Int, TileDragAndDropHoverData> CreateHoverData(List <Texture2D> sheetTextures, List <Sprite> singleSprites, List <TileBase> tiles, GridLayout.CellLayout cellLayout) { Dictionary <Vector2Int, TileDragAndDropHoverData> result = new Dictionary <Vector2Int, TileDragAndDropHoverData>(); Vector2Int currentPosition = new Vector2Int(0, 0); int width = 0; if (sheetTextures != null) { foreach (Texture2D sheetTexture in sheetTextures) { Dictionary <Vector2Int, TileDragAndDropHoverData> sheet = CreateHoverData(sheetTexture, cellLayout); foreach (KeyValuePair <Vector2Int, TileDragAndDropHoverData> item in sheet) { result.Add(item.Key + currentPosition, item.Value); } Vector2Int min = GetMinMaxRect(sheet.Keys.ToList()).min; currentPosition += new Vector2Int(0, min.y - 1); } } if (currentPosition.x > 0) { currentPosition = new Vector2Int(0, currentPosition.y - 1); } if (singleSprites != null) { width = Mathf.RoundToInt(Mathf.Sqrt(singleSprites.Count)); foreach (Sprite sprite in singleSprites) { result.Add(currentPosition, new TileDragAndDropHoverData(sprite)); currentPosition += new Vector2Int(1, 0); if (currentPosition.x >= width) { currentPosition = new Vector2Int(0, currentPosition.y - 1); } } } if (currentPosition.x > 0) { currentPosition = new Vector2Int(0, currentPosition.y - 1); } if (tiles != null) { width = Math.Max(Mathf.RoundToInt(Mathf.Sqrt(tiles.Count)), width); foreach (TileBase tile in tiles) { result.Add(currentPosition, new TileDragAndDropHoverData(tile)); currentPosition += new Vector2Int(1, 0); if (currentPosition.x >= width) { currentPosition = new Vector2Int(0, currentPosition.y - 1); } } } return(result); }
// Organizes all the sprites in a single texture nicely on a 2D "table" based on their original texture position // Only call this with spritesheet with all Sprites equal size public static Dictionary <Vector2Int, TileDragAndDropHoverData> CreateHoverData(Texture2D sheet, GridLayout.CellLayout cellLayout) { Dictionary <Vector2Int, TileDragAndDropHoverData> result = new Dictionary <Vector2Int, TileDragAndDropHoverData>(); List <Sprite> sprites = GetSpritesFromTexture(sheet); Vector2Int cellPixelSize = EstimateGridPixelSize(sprites); // Get Offset Vector2Int offsetSize = EstimateGridOffsetSize(sprites); // Get Padding Vector2Int paddingSize = EstimateGridPaddingSize(sprites, cellPixelSize, offsetSize); if ((cellLayout == GridLayout.CellLayout.Isometric || cellLayout == GridLayout.CellLayout.IsometricZAsY) && (HasSpriteRectOverlaps(sprites))) { foreach (Sprite sprite in sprites) { GetIsometricGridPosition(sprite, cellPixelSize, offsetSize, out Vector2Int position); result[position] = new TileDragAndDropHoverData(sprite, Vector3.zero, (Vector2)cellPixelSize / sprite.pixelsPerUnit, false); } } else { foreach (Sprite sprite in sprites) { GetGridPosition(sprite, cellPixelSize, offsetSize, paddingSize, out Vector2Int position, out Vector3 offset); result[position] = new TileDragAndDropHoverData(sprite, offset, (Vector2)cellPixelSize / sprite.pixelsPerUnit); } } return(result); }
///<summary>Decode, decompress, and reorder rows of global tile IDs</summary> uint[] ParseGIDs(string encoding, string compression, string data, int width, GridLayout.CellLayout layout) { // Decoding byte[] input; switch (encoding) { case "base64": input = Convert.FromBase64String(data); break; default: throw new NotImplementedException("Encoding: " + (encoding ?? "xml")); } // Decompression byte[] output; switch (compression) { case null: output = input; break; case "gzip": output = CompressionHelper.DecompressGZip(input); break; case "zlib": output = CompressionHelper.DecompressZlib(input); break; default: throw new NotImplementedException("Compression: " + compression); } // Parse bytes as uint32 gids var gids = new uint[output.Length / 4]; Buffer.BlockCopy(output, 0, gids, 0, output.Length); if (layout == GridLayout.CellLayout.Rectangle) { return(ArrayHelper.Reverse(gids, stride: width)); } else if (layout == GridLayout.CellLayout.Isometric) { return(ArrayHelper.Swizzle(gids, stride: width).Reverse().ToArray()); } else { return(gids); } }