private void DoToolSceneGUI(ToolBase tool) { var tileSystem = target as TileSystem; // Toggle preview material using control key. this.CheckSwitchImmediatePreviewMaterial(); ToolUtility.CheckToolKeyboardShortcuts(); // Preserve current state of handles. Matrix4x4 originalMatrix = Handles.matrix; Color restoreHandleColor = Handles.color; // Place handles within local space of tile system. Handles.matrix = tileSystem.transform.localToWorldMatrix; // Tools cannot interact with locked tile systems! if (!tileSystem.Locked) { tool.OnSceneGUI(this.toolEvent, this); } else { Vector3 activeCenter = Vector3.zero; activeCenter.x += this.toolEvent.MousePointerTileIndex.column * tileSystem.CellSize.x + tileSystem.CellSize.x / 2f; activeCenter.y -= this.toolEvent.MousePointerTileIndex.row * tileSystem.CellSize.y + tileSystem.CellSize.y / 2f; ToolHandleUtility.DrawWireBox(activeCenter, tileSystem.CellSize); } // Restore former state of handles. Handles.matrix = originalMatrix; Handles.color = restoreHandleColor; }
private void TrackMouseInput() { Event e = Event.current; // Refresh status of left/right mouse button when mouse is not being dragged // or stop dragging when middle mouse button is pressed. if (e.button > 1 || this.toolEvent.Type == EventType.MouseMove) { this.toolEvent.IsRightButtonPressed = this.toolEvent.IsLeftButtonPressed = false; } switch (this.toolEvent.Type) { case EventType.MouseDown: if (!this.UpdateToolEventFromCursor(e.mousePosition)) { break; } if (ToolManager.Instance.CurrentTool != null && GUIUtility.hotControl == 0) { this.toolEvent.IsRightButtonPressed = this.toolEvent.IsLeftButtonPressed = false; // Note: Do not allow use of control or shift with right button // because otherwise it would not be possible to pan and // zoom viewport! if ((e.button == 0 || e.button == 1) && !e.alt && (!e.control || e.shift || e.button == 0)) { if (e.button == 0) { this.toolEvent.IsLeftButtonPressed = true; } else if (e.button == 1) { this.toolEvent.IsRightButtonPressed = true; } GUIUtility.hotControl = this.sceneControlID; s_AnchorTool = ToolManager.Instance.CurrentTool; } } break; case EventType.MouseUp: this.toolEvent.IsRightButtonPressed = this.toolEvent.IsLeftButtonPressed = false; if (GUIUtility.hotControl == this.sceneControlID) { GUIUtility.hotControl = 0; s_AnchorTool = null; } break; case EventType.MouseMove: case EventType.MouseDrag: this.UpdateToolEventFromCursor(e.mousePosition); break; } }
private static void ToolManager_ToolChanged(ToolBase oldTool, ToolBase newTool) { if (oldTool == null && newTool != null) { s_RestoreAnnotationUtilityShowGrid = AnnotationUtilityShowGrid; if (HookEnabled.Value) { AnnotationUtilityShowGrid = false; } } else if (newTool == null) { AnnotationUtilityShowGrid = s_RestoreAnnotationUtilityShowGrid; } }
/// <summary> /// Hide or unhide tool. /// </summary> /// <param name="tool">Tool.</param> /// <param name="hide">Specify a value of <c>true</c> to hide tool; otherwise /// a value of <c>false</c> to unhide tool.</param> public static void HideTool(ToolBase tool, bool hide) { if (tool._visible == !hide) { return; } tool._visible = !hide; if (hide) { Hidden.Value.Add(tool.GetType().FullName); } else { Hidden.Value.Remove(tool.GetType().FullName); } Hidden.MarkDirty(); }
private static void OnDrawGizmosSelected(TileSystem system, GizmoType gizmoType) { DrawTileSystemGizmosSelected(system, 2.0f); // Do not display gizmos when tile system is locked, this would be confusing! if (system.Locked) { return; } if (!RtsPreferences.ToolImmediatePreviews) { return; } ToolBase currentTool = ToolManager.Instance.CurrentTool; if (currentTool != null && ToolBase.IsEditorNearestControl) { ImmediatePreviewUtility.PreviewMaterial.color = RtsPreferences.ToolImmediatePreviewsTintColor; currentTool.OnDrawGizmos(system); } }
private void DoTool(ToolBase tool, bool isMouseEvent, bool wasSceneActiveControl) { var tileSystem = target as TileSystem; this.toolEvent.MousePointerTileIndex = this.toolEvent.LastMousePointerTileIndex; if (!EditorApplication.isPlaying) { // Mark the current scene as being dirty. EditorSceneManager.MarkSceneDirty(tileSystem.gameObject.scene); } // Allow tool to manipulate event data if desired. tool.OnRefreshToolEvent(this.toolEvent, this); ToolUtility.ActiveTileIndex = this.toolEvent.MousePointerTileIndex; // Use currently selected tool! this.DoToolSceneGUI(tool); if (isMouseEvent) { // Tools cannot interact with locked tile systems! if (!tileSystem.Locked) { // Allow tool to respond to all mouse events. bool isSceneActiveControl = GUIUtility.hotControl == this.sceneControlID; if (wasSceneActiveControl || isSceneActiveControl) { tool.OnTool(this.toolEvent, this); switch (this.toolEvent.Type) { case EventType.MouseDown: case EventType.MouseDrag: if (isSceneActiveControl) { Event.current.Use(); } break; case EventType.MouseUp: if (wasSceneActiveControl) { tool.OnToolInactive(this.toolEvent, this); Event.current.Use(); } break; } } else { tool.OnToolInactive(this.toolEvent, this); } } // Force redraw in scene views. SceneView.RepaintAll(); // Force redraw in game views. EditorInternalUtility.RepaintAllGameViews(); } }
/// <summary> /// Selects tool for use within custom system. /// </summary> /// <param name="tool">Tool that is to be selected. Specify `null` to /// revert to previous Unity tool.</param> /// <returns> /// Instance of tool that was selected. /// </returns> public ToolBase SelectTool(ToolBase tool) { if (tool != null) { this.AutoActivateTileSystem(); if (ToolUtility.ActiveTileSystem == null) { // Deselect tool because no tile system is selected! tool = null; } else if (this.currentTool == null) { // Reveal active tile system in scene palette when tool is first activated. // Let's not keep scrolling to the active tile system each time the user // selects another tool since this can be quite annoying! ToolUtility.RevealTileSystem(ToolUtility.ActiveTileSystem, false); // Automatically show tool palette upon activating tool if specified // in user preferences. if (RtsPreferences.AutoShowToolPalette) { ToolUtility.ShowToolPalette(false); } } } if (tool != null) { // Should current Unity tool be preserved whilst custom tool is used? if (UnityEditor.Tools.current != Tool.None) { this.previousUnityTool = UnityEditor.Tools.current; UnityEditor.Tools.current = Tool.None; } } else if (UnityEditor.Tools.current == Tool.None) { // Revert back to former Unity tool because tool has been deselected! UnityEditor.Tools.current = this.previousUnityTool; } // Will tool selection actually change? if (tool == this.currentTool) { return(tool); } // Reset active plop reference to avoid issues when switching tools. ToolUtility.ActivePlop = null; if (this.currentTool != null) { this.previousTool = this.currentTool; } // Switch to specified tool. var oldTool = this.currentTool; this.currentTool = tool; if (oldTool != null) { oldTool.OnDisable(); } if (tool != null) { if (oldTool == null) { // No tool was active prior to using this method to select a tool. this.BeginEditMode(); } tool.OnEnable(); } else if (oldTool != null) { // A tool was active prior to using this method to deselect tool. this.ExitEditMode(); } // Raise event for tool change. if (this.ToolChanged != null) { try { this.ToolChanged(oldTool, this.currentTool); } catch (Exception ex) { Debug.LogException(ex); } } ToolUtility.RepaintToolPalette(); // Brush palette only needs to be repainted when tool is first selected or deselected. if (oldTool == null || tool == null) { ToolUtility.RepaintBrushPalette(); } SceneView.RepaintAll(); return(tool); }
private ToolBase DrawAvailableToolEntry(Rect position, ToolBase tool) { position.width -= 25; Rect eyePosition = position; eyePosition.x = position.xMax; eyePosition.width = 25; string tipText = tool.Visible ? TileLang.ParticularText("Action", "Click to hide tool") : TileLang.ParticularText("Action", "Click to show tool"); int eyeControlID = RotorzEditorGUI.GetHoverControlID(eyePosition, tipText); switch (Event.current.GetTypeForControl(eyeControlID)) { case EventType.Repaint: Color restoreColor = GUI.color; if (!tool.Visible) { GUI.color = new Color(0f, 0f, 0f, 0.55f); } if (tool.IconNormal != null) { Rect iconPosition = position; iconPosition.width = 22; iconPosition.height = 22; GUI.DrawTexture(iconPosition, tool.IconNormal); } position.x += 25; position.width -= 25; position.height -= 2; RotorzEditorStyles.Instance.LabelMiddleLeft.Draw(position, tool.Label, false, false, false, false); if (!tool.Visible) { GUI.color = restoreColor; } eyePosition.x += 3; eyePosition.y = eyePosition.y + (eyePosition.height - 18) / 2; eyePosition.width = 21; eyePosition.height = 18; GUI.DrawTexture(eyePosition, tool.Visible ? RotorzEditorStyles.Skin.EyeOpen : RotorzEditorStyles.Skin.EyeShut); break; case EventType.MouseDown: if (Event.current.button == 0 && eyePosition.Contains(Event.current.mousePosition)) { tool.Visible = !tool.Visible; GUI.changed = true; Event.current.Use(); } break; } return(tool); }
/// <summary> /// Gets a value indicating whether tool is hidden. /// </summary> /// <param name="tool">Tool.</param> /// <returns> /// A value of <c>true</c> if tool is hidden; otherwise a value of <c>false</c>. /// </returns> public static bool IsToolHidden(ToolBase tool) { return(Hidden.Value.Contains(tool.GetType().FullName)); }