private void DrawProceduralField(TilesetBrush brush, Tileset tileset) { using (var content = ControlContent.WithTrailableTip( TileLang.ParticularText("Property", "Procedural"), TileLang.Text("Allows individual atlas brushes to override property of tileset.") )) { // Need to make width of "Procedural" popup shorter. GUILayout.BeginHorizontal(GUILayout.Width(200)); InheritYesNo newProcedural = (InheritYesNo)EditorGUILayout.EnumPopup(content, brush.procedural); if (newProcedural != brush.procedural) { brush.procedural = newProcedural; if (!brush.IsProcedural) { // Ensure that required procedural mesh exists! if (BrushUtility.EnsureTilesetMeshExists(tileset, brush.tileIndex)) { AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(tileset.tileMeshAsset)); } } } Rect position = GUILayoutUtility.GetLastRect(); GUI.Label(new Rect(position.x + position.width, position.y, 100, position.height), "= " + (brush.IsProcedural ? TileLang.Text("Procedural") : TileLang.Text("Non-Procedural")), EditorStyles.miniLabel); GUILayout.EndHorizontal(); ExtraEditorGUI.TrailingTip(content); } }
/// <summary> /// Cleanup tileset mesh assets that are not referenced by tileset brushes. /// </summary> /// <remarks> /// <para>Meshes will become missing in scenes and assets where tile meshes /// were previously used (i.e. where previously used tileset brushes have been /// deleted). Previously painted tiles should be refreshed.</para> /// </remarks> /// <param name="tileset">The tileset.</param> public static void CleanupTilesetMeshes(Tileset tileset) { if (tileset == null) { throw new ArgumentNullException("tileset"); } // No mesh assets to cleanup! if (tileset.tileMeshAsset == null || tileset.tileMeshes == null) { return; } var tilesetRecord = BrushDatabase.Instance.FindTilesetRecord(tileset); if (tilesetRecord == null) { throw new Exception("Tileset record was not found for '" + tileset.name + "'"); } int keep = 0, lastIndex = 0; for (int i = 0; i < tileset.tileMeshes.Length; ++i) { Mesh m = tileset.tileMeshes[i]; if (m == null) { continue; } // Find out if at least one tileset brush uses this mesh. foreach (BrushAssetRecord record in tilesetRecord.BrushRecords) { TilesetBrush brush = record.Brush as TilesetBrush; // Only consider non-procedural tileset brushes! if (brush != null && brush.tileIndex == i && !brush.IsProcedural) { // Do not delete mesh asset! m = null; ++keep; break; } } if (m != null) { tileset.tileMeshes[i] = null; EditorUtility.SetDirty(tileset); Object.DestroyImmediate(m, true); } else { // Index of last mesh that was kept. lastIndex = i; } } // Were any mesh assets required? if (keep == 0) { // Remove asset altogether. AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(tileset.tileMeshAsset)); tileset.tileMeshAsset = null; } else { // Shrink tile mesh map if possible. Array.Resize(ref tileset.tileMeshes, lastIndex + 1); // Re-import mesh asset. AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(tileset.tileMeshAsset)); } DesignerWindow.RepaintWindow(); }
/// <summary> /// Upgrades atlas brush (v1.x) into a tileset brush (v2.x). /// </summary> /// <remarks> /// <para>These are now called tileset brushes because they utilise a central /// tileset asset which makes it easier to manage such brushes.</para> /// </remarks> /// <param name="record">Record for existing v1.x brush.</param> private void UpgradeAtlasBrush(RtsBrushAssetRecordWrapper record) { MonoBehaviour oldBrush = record.brush; Transform oldTransform = oldBrush.transform; // Cannot upgrade atlas tile brush if tileset was not generated Tileset tileset = GenerateTilesetFromAtlasBrush(oldBrush); if (tileset == null) { Debug.LogError(string.Format("Could not generate tileset for atlas brush '{0}'.", oldBrush.name)); return; } Texture2D atlasTexture = (Texture2D)_fiAtlasTileBrush_atlasTexture.GetValue(oldBrush); int atlasTileWidth = (int)_fiAtlasTileBrush_atlasTileWidth.GetValue(oldBrush); int atlasRow = (int)_fiAtlasTileBrush_atlasRow.GetValue(oldBrush); int atlasColumn = (int)_fiAtlasTileBrush_atlasColumn.GetValue(oldBrush); // Create the new tileset brush. int atlasColumns = atlasTexture.width / atlasTileWidth; int tileIndex = atlasRow * atlasColumns + atlasColumn; TilesetBrush newBrush = BrushUtility.CreateTilesetBrush(record.displayName, tileset, tileIndex, InheritYesNo.Inherit); // Was unit collider added to original atlas brush? BoxCollider automaticCollider = oldBrush.collider as BoxCollider; if (automaticCollider != null && automaticCollider.size == Vector3.one && automaticCollider.center == Vector3.zero) { newBrush.addCollider = true; } int componentCount = oldTransform.GetComponents <Component>().Length; if (newBrush.addCollider) { --componentCount; } // Should prefab be generated and attached? // - Attach prefab if it contains child game objects. // - Attach prefab if collider is non-standard. // - Contains extra components (1=transform, 2=brush, 3=filter, 4=renderer). bool attachPrefab = (oldTransform.childCount > 0) || (!newBrush.addCollider && oldBrush.collider != null) || (componentCount != 4) ; if (attachPrefab) { GameObject attachment = PrefabUtility.InstantiatePrefab(oldBrush.gameObject) as GameObject; // Destroy the previous brush component. Object.DestroyImmediate(attachment.GetComponent(_tyTileBrush)); // Destroy collider as it's not needed. if (newBrush.addCollider) { Object.DestroyImmediate(attachment.collider); } // Remove mesh filter and renderer components. Object.DestroyImmediate(attachment.renderer); Object.DestroyImmediate(attachment.GetComponent <MeshFilter>()); string assetPath = GetUniqueMigratedPath(oldBrush.name + ".prefab"); newBrush.attachPrefab = PrefabUtility.CreatePrefab(assetPath, attachment); Object.DestroyImmediate(attachment); } CopyCommonBrushProperties(newBrush, record.brush); RtsUpgradedBrushMap.BrushMappings.SetMapping(record.brush, newBrush); if (newBrush.visibility == BrushVisibility.Shown) { newBrush.visibility = BrushVisibility.Favourite; } else { newBrush.visibility = BrushVisibility.Shown; } }
private bool FillColliderMeshData() { //Debug.Log( "[" + ParentTilemap.name + "] FillColliderMeshData -> " + name); if (tileSet == null || parent_tileMap.tileMapColliderType == TileMapColliderType.None) { return(false); } System.Type collider2DType = parent_tileMap.tileMap2DColliderType == TileMap2DColliderType.EdgeCollider2D ? typeof(EdgeCollider2D) : typeof(PolygonCollider2D); Component[] aColliders2D = null; if (parent_tileMap.tileMapColliderType == TileMapColliderType._3D) { int totalTiles = width * height; if (mesh_collider_vertice_list == null) { mesh_collider_vertice_list = new List <Vector3>(totalTiles * 4); mesh_collider_triangle_list = new List <int>(totalTiles * 6); } else { mesh_collider_vertice_list.Clear(); mesh_collider_triangle_list.Clear(); } } else //if (ParentTilemap.ColliderType == eColliderType._2D) { has_2D_colliders = true; open_edge_list.Clear(); aColliders2D = GetComponents(collider2DType); } float halvedCollDepth = parent_tileMap.collider_depth / 2f; bool isEmpty = true; for (int ty = 0, tileIdx = 0; ty < height; ++ty) { for (int tx = 0; tx < width; ++tx, ++tileIdx) { uint tileData = tileData_list[tileIdx]; if (tileData != TileSetConst.TileData_Empty) { int tileId = (int)(tileData & TileSetConst.TileDataMask_TileId); Tile tile = tileSet.GetTile(tileId); if (tile != null) { #if ENABLE_MERGED_SUBTILE_COLLIDERS TilesetBrush brush = ParentTilemap.Tileset.FindBrush(Tileset.GetBrushIdFromTileData(tileData)); Vector2[] subTileMergedColliderVertices = brush ? brush.GetMergedSubtileColliderVertices(ParentTilemap, GridPosX + tx, GridPosY + ty, tileData) : null; #else Vector2[] subTileMergedColliderVertices = null; #endif bool hasMergedColliders = subTileMergedColliderVertices != null; TileColliderData tileCollData = tile.tileColliderData; if (tileCollData.type != TileColliderType.None || hasMergedColliders) { isEmpty = false; int neighborCollFlags = 0; // don't remove, even using neighborTileCollData, neighborTileCollData is not filled if tile is empty bool isSurroundedByFullColliders = true; for (int i = 0; i < neighbor_segment_min_max.Length; ++i) { neighbor_segment_min_max[i].x = float.MaxValue; neighbor_segment_min_max[i].y = float.MinValue; } System.Array.Clear(neighbor_tileColliderData, 0, neighbor_tileColliderData.Length); if (!hasMergedColliders) { if ((tileData & (TileSetConst.TileFlag_FlipH | TileSetConst.TileFlag_FlipV | TileSetConst.TileFlag_Rot90)) != 0) { tileCollData = tileCollData.Clone(); tileCollData.ApplyFlippingFlags(tileData); } for (int i = 0; i < 4; ++i) { uint neighborTileData; bool isTriggerOrPolygon = parent_tileMap.is_trigger || parent_tileMap.tileMapColliderType == TileMapColliderType._2D && parent_tileMap.tileMap2DColliderType == TileMap2DColliderType.PolygonCollider2D; switch (i) { case 0: // Up Tile neighborTileData = (tileIdx + width) < tileData_list.Count ? tileData_list[tileIdx + width] : isTriggerOrPolygon ? TileSetConst.TileData_Empty : parent_tileMap.GetTileData(offset_grid_x + tx, offset_grid_y + ty + 1); break; case 1: // Right Tile neighborTileData = (tileIdx + 1) % width != 0 ? //(tileIdx + 1) < m_tileDataList.Count ? tileData_list[tileIdx + 1] : isTriggerOrPolygon ? TileSetConst.TileData_Empty : parent_tileMap.GetTileData(offset_grid_x + tx + 1, offset_grid_y + ty); break; case 2: // Down Tile neighborTileData = tileIdx >= width ? tileData_list[tileIdx - width] : isTriggerOrPolygon ? TileSetConst.TileData_Empty : parent_tileMap.GetTileData(offset_grid_x + tx, offset_grid_y + ty - 1); break; case 3: // Left Tile neighborTileData = tileIdx % width != 0 ? //neighborTileId = tileIdx >= 1 ? tileData_list[tileIdx - 1] : isTriggerOrPolygon ? TileSetConst.TileData_Empty : parent_tileMap.GetTileData(offset_grid_x + tx - 1, offset_grid_y + ty); break; default: neighborTileData = TileSetConst.TileData_Empty; break; } int neighborTileId = (int)(neighborTileData & TileSetConst.TileDataMask_TileId); if (neighborTileId != TileSetConst.TileId_Empty) { Vector2 segmentMinMax; TileColliderData neighborTileCollider; neighborTileCollider = tileSet.tile_list[neighborTileId].tileColliderData; if ((neighborTileData & (TileSetConst.TileFlag_FlipH | TileSetConst.TileFlag_FlipV | TileSetConst.TileFlag_Rot90)) != 0) { neighborTileCollider = neighborTileCollider.Clone(); if ((neighborTileData & TileSetConst.TileFlag_FlipH) != 0) { neighborTileCollider.FlipH(); } if ((neighborTileData & TileSetConst.TileFlag_FlipV) != 0) { neighborTileCollider.FlipV(); } if ((neighborTileData & TileSetConst.TileFlag_Rot90) != 0) { neighborTileCollider.Rot90(); } } neighbor_tileColliderData[i] = neighborTileCollider; isSurroundedByFullColliders &= (neighborTileCollider.type == TileColliderType.Full); if (neighborTileCollider.type == TileColliderType.None) { segmentMinMax = new Vector2(float.MaxValue, float.MinValue); //NOTE: x will be min, y will be max } else if (neighborTileCollider.type == TileColliderType.Full) { segmentMinMax = new Vector2(0f, 1f); //NOTE: x will be min, y will be max neighborCollFlags |= (1 << i); } else { segmentMinMax = new Vector2(float.MaxValue, float.MinValue); //NOTE: x will be min, y will be max neighborCollFlags |= (1 << i); for (int j = 0; j < neighborTileCollider.vertices.Length; ++j) { Vector2 v = neighborTileCollider.vertices[j]; { if (i == 0 && v.y == 0 || i == 2 && v.y == 1) //Top || Bottom { if (v.x < segmentMinMax.x) { segmentMinMax.x = v.x; } if (v.x > segmentMinMax.y) { segmentMinMax.y = v.x; } } else if (i == 1 && v.x == 0 || i == 3 && v.x == 1) //Right || Left { if (v.y < segmentMinMax.x) { segmentMinMax.x = v.y; } if (v.y > segmentMinMax.y) { segmentMinMax.y = v.y; } } } } } neighbor_segment_min_max[i] = segmentMinMax; } else { isSurroundedByFullColliders = false; } } } // Create Mesh Colliders if (isSurroundedByFullColliders && !hasMergedColliders) { //Debug.Log(" Surrounded! " + tileIdx); } else { float px0 = tx * cell_size.x; float py0 = ty * cell_size.y; Vector2[] collVertices = subTileMergedColliderVertices; if (!hasMergedColliders) { collVertices = tileCollData.type == TileColliderType.Full ?TileConst.Full_Collider_Tile_Vertices : tileCollData.vertices; } for (int i = 0; i < collVertices.Length; ++i) { Vector2 s0 = collVertices[i]; Vector2 s1 = collVertices[i == (collVertices.Length - 1) ? 0 : i + 1]; if (hasMergedColliders) { ++i; // add ++i; in this case to go 2 by 2 because the collVertices for merged colliders will have the segments in pairs } // full collider optimization if ((tileCollData.type == TileColliderType.Full) && ( (i == 0 && neighbor_tileColliderData[3].type == TileColliderType.Full) || // left tile has collider (i == 1 && neighbor_tileColliderData[0].type == TileColliderType.Full) || // top tile has collider (i == 2 && neighbor_tileColliderData[1].type == TileColliderType.Full) || // right tile has collider (i == 3 && neighbor_tileColliderData[2].type == TileColliderType.Full) // bottom tile has collider ) ) { continue; } // polygon collider optimization else // if( tileCollData.type == eTileCollider.Polygon ) Or Full colliders if neighbor is not Full as well { Vector2 n, m; if (s0.y == 1f && s1.y == 1f) // top side { if ((neighborCollFlags & 0x1) != 0) // top tile has collider { n = neighbor_segment_min_max[0]; if (n.x < n.y && n.x <= s0.x && n.y >= s1.x) { continue; } } } else if (s0.x == 1f && s1.x == 1f) // right side { if ((neighborCollFlags & 0x2) != 0) // right tile has collider { n = neighbor_segment_min_max[1]; if (n.x < n.y && n.x <= s1.y && n.y >= s0.y) { continue; } } } else if (s0.y == 0f && s1.y == 0f) // bottom side { if ((neighborCollFlags & 0x4) != 0) // bottom tile has collider { n = neighbor_segment_min_max[2]; if (n.x < n.y && n.x <= s1.x && n.y >= s0.x) { continue; } } } else if (s0.x == 0f && s1.x == 0f) // left side { if ((neighborCollFlags & 0x8) != 0) // left tile has collider { n = neighbor_segment_min_max[3]; if (n.x < n.y && n.x <= s0.y && n.y >= s1.y) { continue; } } } else if (s0.y == 1f && s1.x == 1f) // top - right diagonal { if ((neighborCollFlags & 0x1) != 0 && (neighborCollFlags & 0x2) != 0) { n = neighbor_segment_min_max[0]; m = neighbor_segment_min_max[1]; if ((n.x < n.y && n.x <= s0.x && n.y == 1f) && (m.x < m.y && m.x <= s1.y && m.y == 1f)) { continue; } } } else if (s0.x == 1f && s1.y == 0f) // right - bottom diagonal { if ((neighborCollFlags & 0x2) != 0 && (neighborCollFlags & 0x4) != 0) { n = neighbor_segment_min_max[1]; m = neighbor_segment_min_max[2]; if ((n.x < n.y && n.x == 0f && n.y >= s0.y) && (m.x < m.y && m.x <= s1.x && m.y == 1f)) { continue; } } } else if (s0.y == 0f && s1.x == 0f) // bottom - left diagonal { if ((neighborCollFlags & 0x4) != 0 && (neighborCollFlags & 0x8) != 0) { n = neighbor_segment_min_max[2]; m = neighbor_segment_min_max[3]; if ((n.x < n.y && n.x == 0f && n.y >= s0.x) && (m.x < m.y && m.x == 0f && m.y >= s1.y)) { continue; } } } else if (s0.x == 0f && s1.y == 1f) // left - top diagonal { if ((neighborCollFlags & 0x8) != 0 && (neighborCollFlags & 0x1) != 0) { n = neighbor_segment_min_max[3]; m = neighbor_segment_min_max[0]; if ((n.x < n.y && n.x <= s0.y && n.y == 1f) && (m.x < m.y && m.x == 0f && m.y >= s1.x)) { continue; } } } } // Update s0 and s1 to world positions s0.x = px0 + cell_size.x * s0.x; s0.y = py0 + cell_size.y * s0.y; s1.x = px0 + cell_size.x * s1.x; s1.y = py0 + cell_size.y * s1.y; if (parent_tileMap.tileMapColliderType == TileMapColliderType._3D) { int collVertexIdx = mesh_collider_vertice_list.Count; mesh_collider_vertice_list.Add(new Vector3(s0.x, s0.y, -halvedCollDepth)); mesh_collider_vertice_list.Add(new Vector3(s0.x, s0.y, halvedCollDepth)); mesh_collider_vertice_list.Add(new Vector3(s1.x, s1.y, halvedCollDepth)); mesh_collider_vertice_list.Add(new Vector3(s1.x, s1.y, -halvedCollDepth)); mesh_collider_triangle_list.Add(collVertexIdx + 0); mesh_collider_triangle_list.Add(collVertexIdx + 1); mesh_collider_triangle_list.Add(collVertexIdx + 2); mesh_collider_triangle_list.Add(collVertexIdx + 2); mesh_collider_triangle_list.Add(collVertexIdx + 3); mesh_collider_triangle_list.Add(collVertexIdx + 0); } else //if( ParentTilemap.ColliderType == eColliderType._2D ) { int linkedSegments = 0; int segmentIdxToMerge = -1; for (int edgeIdx = open_edge_list.Count - 1; edgeIdx >= 0 && linkedSegments < 2; --edgeIdx) { LinkedList <Vector2> edgeSegments = open_edge_list[edgeIdx]; if (edgeSegments.First.Value == edgeSegments.Last.Value) { continue; //skip closed edges } if (edgeSegments.Last.Value == s0) { if (segmentIdxToMerge >= 0) { LinkedList <Vector2> segmentToMerge = open_edge_list[segmentIdxToMerge]; if (s0 == segmentToMerge.First.Value) { for (LinkedListNode <Vector2> node = segmentToMerge.First.Next; node != null; node = node.Next) { edgeSegments.AddLast(node.Value); } open_edge_list.RemoveAt(segmentIdxToMerge); } /* Cannot join head with head or tail with tail, it will change the segment normal * else * for (LinkedListNode<Vector2> node = segmentToMerge.Last.Previous; node != null; node = node.Previous) * edgeSegments.AddLast(node.Value);*/ } else { segmentIdxToMerge = edgeIdx; edgeSegments.AddLast(s1); } ++linkedSegments; } /* Cannot join head with head or tail with tail, it will change the segment normal * else if( edgeSegments.Last.Value == s1 ) * else if (edgeSegments.First.Value == s0)*/ else if (edgeSegments.First.Value == s1) { if (segmentIdxToMerge >= 0) { LinkedList <Vector2> segmentToMerge = open_edge_list[segmentIdxToMerge]; if (s1 == segmentToMerge.Last.Value) { for (LinkedListNode <Vector2> node = edgeSegments.First.Next; node != null; node = node.Next) { segmentToMerge.AddLast(node.Value); } open_edge_list.RemoveAt(edgeIdx); } /* Cannot join head with head or tail with tail, it will change the segment normal * else * for (LinkedListNode<Vector2> node = edgeSegments.First.Next; node != null; node = node.Next) * segmentToMerge.AddFirst(node.Value);*/ } else { segmentIdxToMerge = edgeIdx; edgeSegments.AddFirst(s0); } ++linkedSegments; } } if (linkedSegments == 0) { LinkedList <Vector2> newEdge = new LinkedList <Vector2>(); newEdge.AddFirst(s0); newEdge.AddLast(s1); open_edge_list.Add(newEdge); } } } } } } } } } if (parent_tileMap.tileMapColliderType == TileMapColliderType._2D) { //+++ Process Edges //(NOTE: this was added to fix issues related with lighting, otherwise leave this commented) { // Remove vertex inside a line RemoveRedundantVertices(open_edge_list); // Split segments (NOTE: This is not working with polygon colliders) /*/ commented unless necessary for performance reasons * if (ParentTilemap.Collider2DType == e2DColliderType.EdgeCollider2D) * { * openEdges = SplitSegments(openEdges); * } * //*/ } //--- //Create Edges for (int i = 0; i < open_edge_list.Count; ++i) { LinkedList <Vector2> edgeSegments = open_edge_list[i]; bool reuseCollider = i < aColliders2D.Length; Collider2D collider2D = reuseCollider ? (Collider2D)aColliders2D[i] : (Collider2D)gameObject.AddComponent(collider2DType); collider2D.enabled = true; collider2D.isTrigger = parent_tileMap.is_trigger; collider2D.sharedMaterial = parent_tileMap.physicMaterial2D; if (parent_tileMap.tileMap2DColliderType == TileMap2DColliderType.EdgeCollider2D) { ((EdgeCollider2D)collider2D).points = edgeSegments.ToArray(); } else { ((PolygonCollider2D)collider2D).SetPath(0, edgeSegments.ToArray()); } } //Destroy unused edge colliders for (int i = open_edge_list.Count; i < aColliders2D.Length; ++i) { if (!is_on_validate) { DestroyImmediate(aColliders2D[i]); } else { ((Collider2D)aColliders2D[i]).enabled = false; } } } return(!isEmpty); }
// '°', '├', '═', '┤', | 0, 2, 10, 8, // '┬', '╔', '╦', '╗', | 4, 6, 14, 12, // '║', '╠', '╬', '╣', | 5, 7, 15, 13, // '┴', '╚', '╩', '╝', | 1, 3, 11, 9, public override uint[] GetSubtiles(global::CreativeSpore.SuperTilemapEditor.Tilemap tilemap, int gridX, int gridY, uint tileData) { CalculateNeighbourData(tilemap, gridX, gridY, tileData); // tiles that need subtile division if (s_needsSubTiles) { uint[] aSubTileData = null; if (s_neighIdx == 0) //° { aSubTileData = new uint[] { TileIds[3], TileIds[9], TileIds[6], TileIds[12] }; } else if (s_neighIdx == 4)//┬ { aSubTileData = new uint[] { TileIds[6], TileIds[12], TileIds[6], TileIds[12] }; } else if (s_neighIdx == 5)//║ { aSubTileData = new uint[] { TileIds[7], TileIds[13], TileIds[7], TileIds[13] }; } else if (s_neighIdx == 1)//┴ { aSubTileData = new uint[] { TileIds[3], TileIds[9], TileIds[3], TileIds[9] }; } else if (s_neighIdx == 2)//├ { aSubTileData = new uint[] { TileIds[3], TileIds[3], TileIds[6], TileIds[6] }; } else if (s_neighIdx == 10)//═ { aSubTileData = new uint[] { TileIds[11], TileIds[11], TileIds[14], TileIds[14] }; } else if (s_neighIdx == 8)//┤ { aSubTileData = new uint[] { TileIds[9], TileIds[9], TileIds[12], TileIds[12] }; } // NOTE: this case '╬' cut the tiles different (using corner tiles). // If it is commented, and default case is used, instead or corner tiles, it will use the center tile '╬' // Depending on the graphics it could be interesting add a check box to choose between using this or not. else if (s_neighIdx == 15)// ╬ { aSubTileData = new uint[] { InteriorCornerTileIds[0], InteriorCornerTileIds[1], InteriorCornerTileIds[2], InteriorCornerTileIds[3] }; } else { aSubTileData = new uint[] { TileIds[s_neighIdx], TileIds[s_neighIdx], TileIds[s_neighIdx], TileIds[s_neighIdx] }; } for (int i = 0; i < s_showDiagonal.Length; ++i) { if (s_showDiagonal[i]) { aSubTileData[i] = InteriorCornerTileIds[3 - i]; } // Add animated tiles { TilesetBrush brush = Tileset.FindBrush(Tileset.GetBrushIdFromTileData(aSubTileData[i])); if (brush && brush.IsAnimated()) { TilemapChunk.RegisterAnimatedBrush(brush, i); } } } return(aSubTileData); } // Add animated tiles { TilesetBrush brush = Tileset.FindBrush(Tileset.GetBrushIdFromTileData(s_tileData)); if (brush && brush.IsAnimated()) { TilemapChunk.RegisterAnimatedBrush(brush); } } return(null); }