public static BrushBehaviour GetOrCreateBrush(Tilemap tilemap)
{
BrushBehaviour brush = Instance;
if (brush.m_brushTilemap == null)
{
brush.m_brushTilemap = brush.GetComponent <Tilemap>();
}
brush.IsUndoEnabled = tilemap.EnableUndoWhilePainting;
brush.m_brushTilemap.ColliderType = eColliderType.None;
bool needsRefresh = brush.m_brushTilemap.Tileset != tilemap.Tileset;
brush.m_brushTilemap.Tileset = tilemap.Tileset;
brush.m_brushTilemap.CellSize = tilemap.CellSize;
brush.m_brushTilemap.SortingLayerID = tilemap.SortingLayerID;
brush.m_brushTilemap.OrderInLayer = tilemap.OrderInLayer;
brush.m_brushTilemap.Material = tilemap.Material;
brush.m_brushTilemap.TintColor = tilemap.TintColor * 0.7f;
//NOTE: dontsave brush give a lot of problems, like duplication of brushes FindObjectsOfType is not finding them
//brush.m_brushTilemap.Material.hideFlags = HideFlags.DontSave;
//brush.gameObject.hideFlags = HideFlags.HideAndDontSave;
//---
brush.gameObject.hideFlags = HideFlags.HideInHierarchy;
if (needsRefresh)
{
brush.m_brushTilemap.ClearMap();
brush.m_brushTilemap.SetTileData(0, 0, Tileset.k_TileData_Empty); // setting an empty tile, map bounds increase a tile, needed to draw the brush border
brush.m_brushTilemap.UpdateMeshImmediate();
}
return(brush);
}
public void OnSceneGUI()
{
m_dblClick.Update();
Tilemap tilemap = (Tilemap)target;
if (tilemap == null || tilemap.Tileset == null)
{
return;
}
m_brushVisible = s_editMode == eEditMode.Paint;
if (s_editMode == eEditMode.Paint)
{
DoPaintInspector();
if (GetBrushMode() == eBrushMode.Fill && Event.current.type == EventType.Repaint)
{
Color fillPreviewColor = new Color(1f, 1f, 1f, 0.2f);
Color emptyColor = new Color(0f, 0f, 0f, 0f);
Rect rTile = new Rect(Vector2.zero, m_tilemap.CellSize);
foreach (Vector2 tilePos in m_fillPreview)
{
rTile.position = tilePos;
HandlesEx.DrawRectWithOutline(m_tilemap.transform, rTile, fillPreviewColor, emptyColor);
}
}
}
else if (s_editMode == eEditMode.Map)
{
DoMapInspector();
}
BrushBehaviour.SetVisible(m_brushVisible);
}
void OnDisable()
{
if (m_tilemap)
{
UnregisterTilesetEvents(m_tilemap.Tileset);
}
BrushBehaviour.SetVisible(false);
}
private void OnBrushSelected(Tileset source, int prevBrushId, int newBrushId)
{
ResetBrushMode();
BrushBehaviour brush = BrushBehaviour.GetOrCreateBrush((Tilemap)target);
brush.BrushTilemap.ClearMap();
brush.BrushTilemap.SetTileData(0, 0, (uint)(newBrushId << 16) | Tileset.k_TileDataMask_TileId);
brush.BrushTilemap.UpdateMesh();
brush.Offset = Vector2.zero;
}
private void OnTileSelectionChanged(Tileset source)
{
ResetBrushMode();
BrushBehaviour brush = BrushBehaviour.GetOrCreateBrush((Tilemap)target);
brush.BrushTilemap.ClearMap();
if (source.TileSelection != null)
{
for (int i = 0; i < source.TileSelection.selectionData.Count; ++i)
{
int gx = i % source.TileSelection.rowLength;
int gy = i / source.TileSelection.rowLength;
brush.BrushTilemap.SetTileData(gx, gy, (uint)source.TileSelection.selectionData[i]);
}
}
brush.BrushTilemap.UpdateMesh();
brush.Offset = Vector2.zero;
}
public void OnSceneGUI()
{
m_dblClick.Update();
Tilemap tilemap = (Tilemap)target;
if (tilemap == null || tilemap.Tileset == null)
{
return;
}
BrushBehaviour.SetVisible(s_editMode == eEditMode.Paint);
if (s_editMode == eEditMode.Paint)
{
DoPaintInspector();
}
else if (s_editMode == eEditMode.Map)
{
DoMapInspector();
}
}
private void OnToolSelected_BrushToolbar(ToolbarControl source, int selectedToolIdx, int prevSelectedToolIdx)
{
ToolIcons.eToolIcon toolIcon = (ToolIcons.eToolIcon)selectedToolIdx;
switch (toolIcon)
{
case ToolIcons.eToolIcon.Pencil:
TilemapEditor.s_brushMode = TilemapEditor.eBrushMode.Paint;
Tools.current = Tool.None;
break;
case ToolIcons.eToolIcon.Erase:
TilemapEditor.s_brushMode = TilemapEditor.eBrushMode.Erase;
brushPaintToolbar.TriggerButton(0);
Tools.current = Tool.None;
break;
case ToolIcons.eToolIcon.Fill:
TilemapEditor.s_brushMode = TilemapEditor.eBrushMode.Fill;
brushPaintToolbar.TriggerButton(0);
Tools.current = Tool.None;
break;
case ToolIcons.eToolIcon.FlipV:
BrushBehaviour.SFlipV();
Tools.current = Tool.None;
source.SelectedIdx = prevSelectedToolIdx;
break;
case ToolIcons.eToolIcon.FlipH:
BrushBehaviour.SFlipH();
Tools.current = Tool.None;
source.SelectedIdx = prevSelectedToolIdx;
break;
case ToolIcons.eToolIcon.Rot90:
BrushBehaviour.SRot90();
Tools.current = Tool.None;
source.SelectedIdx = prevSelectedToolIdx;
break;
case ToolIcons.eToolIcon.Info:
TilemapEditor.s_displayHelpBox = !TilemapEditor.s_displayHelpBox;
Tools.current = Tool.None;
source.SelectedIdx = prevSelectedToolIdx;
source.SetHighlight(selectedToolIdx, TilemapEditor.s_displayHelpBox);
break;
case ToolIcons.eToolIcon.Refresh:
TilemapGroup tilemapGroup = Selection.activeGameObject.GetComponent <TilemapGroup>();
if (tilemapGroup)
{
foreach (STETilemap tilemap in tilemapGroup.Tilemaps)
{
tilemap.Refresh(true, true, true, true);
}
}
else
{
STETilemap tilemap = Selection.activeGameObject.GetComponent <STETilemap>();
if (tilemap)
{
tilemap.Refresh(true, true, true, true);
}
}
Tools.current = Tool.None;
source.SelectedIdx = prevSelectedToolIdx;
break;
}
}
private void _DoToolbarButton(Rect rToolBtn, ToolIcons.eToolIcon toolIcon)
{
BrushBehaviour brush = BrushBehaviour.GetOrCreateBrush((Tilemap)target);
int iconPadding = 6;
Rect rToolIcon = new Rect(rToolBtn.x + iconPadding, rToolBtn.y + iconPadding, rToolBtn.size.y - 2 * iconPadding, rToolBtn.size.y - 2 * iconPadding);
Color activeColor = new Color(1f, 1f, 1f, 0.8f);
Color disableColor = new Color(1f, 1f, 1f, 0.4f);
switch (toolIcon)
{
case ToolIcons.eToolIcon.Pencil:
GUI.color = GetBrushMode() == eBrushMode.Paint ? activeColor : disableColor;
if (GUI.Button(rToolBtn, new GUIContent("", "Paint")))
{
s_brushMode = eBrushMode.Paint;
}
break;
case ToolIcons.eToolIcon.Erase:
GUI.color = GetBrushMode() == eBrushMode.Erase ? activeColor : disableColor;
if (GUI.Button(rToolBtn, new GUIContent("", "Erase (Hold Shift)")))
{
s_brushMode = eBrushMode.Erase;
}
break;
case ToolIcons.eToolIcon.Fill:
GUI.color = GetBrushMode() == eBrushMode.Fill ? activeColor : disableColor;
if (GUI.Button(rToolBtn, new GUIContent("", "Fill (Double click)")))
{
s_brushMode = eBrushMode.Fill;
}
break;
case ToolIcons.eToolIcon.FlipV:
GUI.color = s_brushFlipV ? activeColor : disableColor;
if (GUI.Button(rToolBtn, new GUIContent("", "Flip Vertical (" + ShortcutKeys.k_FlipV + ")")))
{
brush.FlipV();
s_brushFlipV = !s_brushFlipV;
}
break;
case ToolIcons.eToolIcon.FlipH:
GUI.color = s_brushFlipH ? activeColor : disableColor;
if (GUI.Button(rToolBtn, new GUIContent("", "Flip Horizontal (" + ShortcutKeys.k_FlipH + ")")))
{
brush.FlipH();
s_brushFlipH = !s_brushFlipH;
}
break;
case ToolIcons.eToolIcon.Rot90:
GUI.color = s_brushRot90 ? activeColor : disableColor;
if (GUI.Button(rToolBtn, new GUIContent("", "Rotate 90 clockwise (" + ShortcutKeys.k_Rot90 + "); anticlockwise (" + ShortcutKeys.k_Rot90Back + ")")))
{
if (!s_brushRot90)
{
brush.Rot90();
}
else
{
brush.Rot90Back();
}
s_brushRot90 = !s_brushRot90;
}
break;
case ToolIcons.eToolIcon.Info:
GUI.color = m_displayHelpBox ? activeColor : disableColor;
if (GUI.Button(rToolBtn, new GUIContent("", " Display Help (F1)")))
{
m_displayHelpBox = !m_displayHelpBox;
}
break;
case ToolIcons.eToolIcon.Refresh:
GUI.color = m_displayHelpBox ? activeColor : disableColor;
if (GUI.Button(rToolBtn, new GUIContent("", " Refresh Tilemap (F5)")))
{
TilemapGroup tilemapGroup = Selection.activeGameObject.GetComponent <TilemapGroup>();
if (tilemapGroup)
{
foreach (Tilemap tilemap in tilemapGroup.Tilemaps)
{
tilemap.Refresh(true, true, true, true);
}
}
else
{
m_tilemap.Refresh(true, true, true, true);
}
}
break;
}
GUI.color = Color.white;
GUI.DrawTexture(rToolIcon, ToolIcons.GetToolTexture(toolIcon));
}
private void DoPaintInspector()
{
Event e = Event.current;
Tilemap tilemap = (Tilemap)target;
if (DoToolBar() ||
DragAndDrop.objectReferences.Length > 0 || // hide brush when user is dragging a prefab into the scene
EditorWindow.mouseOverWindow != SceneView.currentDrawingSceneView) // hide brush when it's not over the scene view
{
m_brushVisible = false;
SceneView.RepaintAll();
return;
}
int controlID = GUIUtility.GetControlID(FocusType.Passive);
HandleUtility.AddDefaultControl(controlID);
EventType currentEventType = Event.current.GetTypeForControl(controlID);
bool skip = false;
int saveControl = GUIUtility.hotControl;
try
{
if (currentEventType == EventType.Layout)
{
skip = true;
}
else if (currentEventType == EventType.ScrollWheel)
{
skip = true;
}
if (tilemap.Tileset == null)
{
return;
}
if (!skip)
{
if (e.type == EventType.KeyDown)
{
if (e.keyCode == ShortcutKeys.k_FlipH)
{
BrushBehaviour.GetOrCreateBrush(tilemap).FlipH(!e.shift);
e.Use(); // Use key event
}
else if (e.keyCode == ShortcutKeys.k_FlipV)
{
BrushBehaviour.GetOrCreateBrush(tilemap).FlipV(!e.shift);
e.Use(); // Use key event
}
else if (e.keyCode == ShortcutKeys.k_Rot90)
{
BrushBehaviour.GetOrCreateBrush(tilemap).Rot90(!e.shift);
e.Use(); // Use key event
}
else if (e.keyCode == ShortcutKeys.k_Rot90Back)
{
BrushBehaviour.GetOrCreateBrush(tilemap).Rot90Back(!e.shift);
e.Use(); // Use key event
}
}
EditorGUIUtility.AddCursorRect(new Rect(0f, 0f, (float)Screen.width, (float)Screen.height), MouseCursor.Arrow);
GUIUtility.hotControl = controlID;
{
Plane chunkPlane = new Plane(tilemap.transform.forward, tilemap.transform.position);
Vector2 mousePos = Event.current.mousePosition; mousePos.y = Screen.height - mousePos.y;
Ray ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
float dist;
if (chunkPlane.Raycast(ray, out dist))
{
Rect rTile = new Rect(0, 0, m_tilemap.CellSize.x, m_tilemap.CellSize.y);
rTile.position = tilemap.transform.InverseTransformPoint(ray.GetPoint(dist));
Vector2 tilePos = rTile.position;
if (tilePos.x < 0)
{
tilePos.x -= m_tilemap.CellSize.x;
}
if (tilePos.y < 0)
{
tilePos.y -= m_tilemap.CellSize.y;
}
tilePos.x -= tilePos.x % m_tilemap.CellSize.x;
tilePos.y -= tilePos.y % m_tilemap.CellSize.y;
rTile.position = tilePos;
Vector2 startPos = new Vector2(Mathf.Min(m_startDragging.x, m_endDragging.x), Mathf.Min(m_startDragging.y, m_endDragging.y));
Vector2 endPos = new Vector2(Mathf.Max(m_startDragging.x, m_endDragging.x), Mathf.Max(m_startDragging.y, m_endDragging.y));
Vector2 selectionSnappedPos = BrushUtil.GetSnappedPosition(startPos, m_tilemap.CellSize);
Vector2 selectionSize = BrushUtil.GetSnappedPosition(endPos, m_tilemap.CellSize) - selectionSnappedPos + m_tilemap.CellSize;
BrushBehaviour brush = BrushBehaviour.GetOrCreateBrush(tilemap);
// Update brush transform
m_localPaintPos = (Vector2)tilemap.transform.InverseTransformPoint(ray.GetPoint(dist));
Vector2 brushSnappedPos = BrushUtil.GetSnappedPosition(brush.Offset + m_localPaintPos, m_tilemap.CellSize);
brush.transform.rotation = tilemap.transform.rotation;
brush.transform.localScale = tilemap.transform.lossyScale;
brush.transform.position = tilemap.transform.TransformPoint(new Vector3(brushSnappedPos.x, brushSnappedPos.y, -0.01f));
//---
int prevMouseGridX = m_mouseGridX;
int prevMouseGridY = m_mouseGridY;
if (e.isMouse)
{
m_mouseGridX = BrushUtil.GetGridX(m_localPaintPos, tilemap.CellSize);
m_mouseGridY = BrushUtil.GetGridY(m_localPaintPos, tilemap.CellSize);
}
bool isMouseGridChanged = prevMouseGridX != m_mouseGridX || prevMouseGridY != m_mouseGridY;
//Update Fill Preview
if (GetBrushMode() == eBrushMode.Fill && isMouseGridChanged)
{
m_fillPreview.Clear();
TilemapDrawingUtils.FloodFillPreview(tilemap, brush.Offset + m_localPaintPos, brush.BrushTilemap.GetTileData(0, 0), m_fillPreview);
}
if (
(EditorWindow.focusedWindow == EditorWindow.mouseOverWindow) && // fix painting tiles when closing another window popup over the SceneView like GameObject Selection window
(e.type == EventType.MouseDown || e.type == EventType.MouseDrag && isMouseGridChanged)
)
{
if (e.button == 0)
{
if (m_dblClick.IsDblClick && brush.BrushTilemap.GridWidth == 1 && brush.BrushTilemap.GridHeight == 1)
{
// Restore previous tiledata modified by Paint, because before the double click, a single click is done before
tilemap.SetTileData(brush.Offset + m_localPaintPos, m_floodFillRestoredTileData);
brush.FloodFill(tilemap, brush.Offset + m_localPaintPos, brush.BrushTilemap.GetTileData(0, 0));
}
// Do a brush paint action
else
{
switch (GetBrushMode())
{
case eBrushMode.Paint:
m_floodFillRestoredTileData = tilemap.GetTileData(m_mouseGridX, m_mouseGridY);
brush.Paint(tilemap, brush.Offset + m_localPaintPos);
break;
case eBrushMode.Erase:
brush.Erase(tilemap, brush.Offset + m_localPaintPos);
break;
case eBrushMode.Fill:
brush.FloodFill(tilemap, brush.Offset + m_localPaintPos, brush.BrushTilemap.GetTileData(0, 0));
break;
}
}
}
else if (e.button == 1)
{
if (e.type == EventType.MouseDown)
{
m_isDragging = true;
brush.BrushTilemap.ClearMap();
m_startDragging = m_endDragging = m_localPaintPos;
}
else
{
m_endDragging = m_localPaintPos;
}
}
}
else if (e.type == EventType.MouseUp)
{
if (e.button == 1) // right mouse button
{
m_isDragging = false;
ResetBrushMode();
// Copy one tile
if (selectionSize.x <= m_tilemap.CellSize.x && selectionSize.y <= m_tilemap.CellSize.y)
{
uint tileData = tilemap.GetTileData(m_localPaintPos);
if (tileData == Tileset.k_TileData_Empty)
{
tilemap.Tileset.SelectedTileId = Tileset.k_TileId_Empty;
brush.BrushTilemap.SetTileData(0, 0, Tileset.k_TileData_Empty);
}
else
{
int brushId = Tileset.GetBrushIdFromTileData(tileData);
int tileId = Tileset.GetTileIdFromTileData(tileData);
// Select the copied tile in the tileset, alternating between the brush and the tile drawn by the brush
if (brushId > 0 && brushId != tilemap.Tileset.SelectedBrushId)
{
tilemap.Tileset.SelectedBrushId = brushId;
}
else
{
tilemap.Tileset.SelectedTileId = tileId;
brush.BrushTilemap.SetTileData(0, 0, tileData & ~Tileset.k_TileDataMask_BrushId); // keep tile flags
}
}
// Cut tile if key shift is pressed
if (e.shift)
{
int startGridX = BrushUtil.GetGridX(startPos, m_tilemap.CellSize);
int startGridY = BrushUtil.GetGridY(startPos, m_tilemap.CellSize);
brush.CutRect(tilemap, startGridX, startGridY, startGridX, startGridY);
}
brush.BrushTilemap.UpdateMesh();
brush.Offset = Vector2.zero;
}
// copy a rect of tiles
else
{
int startGridX = BrushUtil.GetGridX(startPos, m_tilemap.CellSize);
int startGridY = BrushUtil.GetGridY(startPos, m_tilemap.CellSize);
int endGridX = BrushUtil.GetGridX(endPos, m_tilemap.CellSize);
int endGridY = BrushUtil.GetGridY(endPos, m_tilemap.CellSize);
// Cut tile if key shift is pressed
if (e.shift)
{
brush.CutRect(tilemap, startGridX, startGridY, endGridX, endGridY);
}
else
{
brush.CopyRect(tilemap, startGridX, startGridY, endGridX, endGridY);
}
brush.Offset.x = m_endDragging.x > m_startDragging.x ? -(endGridX - startGridX) * tilemap.CellSize.x : 0f;
brush.Offset.y = m_endDragging.y > m_startDragging.y ? -(endGridY - startGridY) * tilemap.CellSize.y : 0f;
}
}
}
if (m_isDragging)
{
Rect rGizmo = new Rect(selectionSnappedPos, selectionSize);
HandlesEx.DrawRectWithOutline(tilemap.transform, rGizmo, new Color(), Color.white);
}
else // Draw brush border
{
Rect rBound = new Rect(brush.BrushTilemap.MapBounds.min, brush.BrushTilemap.MapBounds.size);
Color fillColor;
switch (GetBrushMode())
{
case eBrushMode.Paint:
fillColor = new Color(0, 0, 0, 0);
break;
case eBrushMode.Erase:
fillColor = new Color(1f, 0f, 0f, 0.1f);
break;
case eBrushMode.Fill:
fillColor = new Color(1f, 1f, 0f, 0.2f);
break;
default:
fillColor = new Color(0, 0, 0, 0);
break;
}
HandlesEx.DrawRectWithOutline(brush.transform, rBound, fillColor, new Color(1, 1, 1, 0.2f));
}
}
}
if (currentEventType == EventType.MouseDrag && Event.current.button < 2) // 2 is for central mouse button
{
// avoid dragging the map
Event.current.Use();
}
}
}
// Avoid loosing the hotControl because of a triggered exception
catch (System.Exception ex)
{
Debug.LogException(ex);
}
SceneView.RepaintAll();
GUIUtility.hotControl = saveControl;
}
public static ReorderableList CreateTileViewReorderableList(Tileset tileset)
{
ReorderableList tileViewRList = new ReorderableList(tileset.TileViews, typeof(TileView), true, true, true, true);
tileViewRList.onAddDropdownCallback = (Rect buttonRect, ReorderableList l) =>
{
GenericMenu menu = new GenericMenu();
GenericMenu.MenuFunction addTileSelectionFunc = () =>
{
TileSelection tileSelection = tileset.TileSelection.Clone();
tileSelection.FlipVertical(); // flip vertical to fit the tileset coordinate system ( from top to bottom )
tileset.AddTileView("new TileView", tileSelection);
EditorUtility.SetDirty(tileset);
};
GenericMenu.MenuFunction addBrushSelectionFunc = () =>
{
TileSelection tileSelection = BrushBehaviour.CreateTileSelection();
tileset.AddTileView("new TileView", tileSelection);
EditorUtility.SetDirty(tileset);
};
GenericMenu.MenuFunction removeAllTileViewsFunc = () =>
{
if (EditorUtility.DisplayDialog("Warning!", "Are you sure you want to delete all the TileViews?", "Yes", "No"))
{
tileset.RemoveAllTileViews();
EditorUtility.SetDirty(tileset);
}
};
if (tileset.TileSelection != null)
{
menu.AddItem(new GUIContent("Add Tile Selection"), false, addTileSelectionFunc);
}
else
{
menu.AddDisabledItem(new GUIContent("Add Tile Selection to TileView"));
}
if (BrushBehaviour.GetBrushTileset() == tileset && BrushBehaviour.CreateTileSelection() != null)
{
menu.AddItem(new GUIContent("Add Brush Selection"), false, addBrushSelectionFunc);
}
menu.AddSeparator("");
menu.AddItem(new GUIContent("Remove All TileViews"), false, removeAllTileViewsFunc);
menu.AddSeparator("");
menu.AddItem(new GUIContent("Sort By Name"), false, tileset.SortTileViewsByName);
menu.ShowAsContext();
};
tileViewRList.onRemoveCallback = (ReorderableList list) =>
{
if (EditorUtility.DisplayDialog("Warning!", "Are you sure you want to delete the TileView?", "Yes", "No"))
{
ReorderableList.defaultBehaviours.DoRemoveButton(list);
EditorUtility.SetDirty(tileset);
}
};
tileViewRList.drawHeaderCallback = (Rect rect) =>
{
EditorGUI.LabelField(rect, "TileViews", EditorStyles.boldLabel);
Texture2D btnTexture = tileViewRList.elementHeight == 0f ? EditorGUIUtility.FindTexture("winbtn_win_max_h") : EditorGUIUtility.FindTexture("winbtn_win_min_h");
if (GUI.Button(new Rect(rect.width - rect.height, rect.y, rect.height, rect.height), btnTexture, EditorStyles.label))
{
tileViewRList.elementHeight = tileViewRList.elementHeight == 0f ? EditorGUIUtility.singleLineHeight : 0f;
tileViewRList.draggable = tileViewRList.elementHeight > 0f;
}
};
tileViewRList.drawElementCallback = (Rect rect, int index, bool isActive, bool isFocused) =>
{
if (tileViewRList.elementHeight == 0f)
{
return;
}
Rect rLabel = new Rect(rect.x, rect.y, rect.width, EditorGUIUtility.singleLineHeight);
TileView tileView = tileViewRList.list[index] as TileView;
if (index == tileViewRList.index)
{
string newName = EditorGUI.TextField(rLabel, tileView.name);
if (newName != tileView.name)
{
tileset.RenameTileView(tileView.name, newName);
}
}
else
{
EditorGUI.LabelField(rLabel, tileView.name);
}
};
return(tileViewRList);
}
