/// <inheritdoc/> public override void OnTool(ToolEvent e, IToolContext context) { switch (e.Type) { case EventType.MouseDown: ToolBase fallbackRestoreTool; Brush pickedBrush = null; if (ToolUtility.ActivePlop != null && ToolUtility.ActivePlop.Brush != null) { fallbackRestoreTool = ToolManager.Instance.Find <PlopTool>(); // Get plop at pointer. pickedBrush = ToolUtility.ActivePlop.Brush; // Pick rotation from tile also! ToolUtility.Rotation = ToolUtility.ActivePlop.PaintedRotation; } else { fallbackRestoreTool = ToolManager.DefaultPaintTool; // Get tile at pointer. var tile = context.TileSystem.GetTile(e.MousePointerTileIndex); if (tile != null) { pickedBrush = tile.brush; // Pick rotation from tile also! ToolUtility.Rotation = tile.PaintedRotation; } } // Select brush in tool window and force auto scroll. if (e.IsLeftButtonPressed) { ToolUtility.SelectedBrush = pickedBrush; ToolUtility.RevealBrush(pickedBrush); } else { ToolUtility.SelectedBrushSecondary = pickedBrush; } ToolUtility.RepaintBrushPalette(); // Switch to previous tool or the "Paint" tool. var toolManager = ToolManager.Instance; if (toolManager.PreviousTool != null && toolManager.PreviousTool != this) { toolManager.CurrentTool = toolManager.PreviousTool; } else { toolManager.CurrentTool = fallbackRestoreTool; } break; } }
/// <summary> /// Creates a new tile system using properties from the specified preset. /// </summary> /// <remarks> /// <para>This method does not automatically record the new game object with /// Unity's undo system. If undo functionality is desired then the callee should /// do this.</para> /// </remarks> /// <param name="preset">Tile system preset.</param> /// <returns> /// A new game object with an initialized <see cref="TileSystem"/>. /// </returns> /// <exception cref="System.ArgumentNullException"> /// If <paramref name="preset"/> is <c>null</c>. /// </exception> /// <exception cref="System.InvalidOperationException"> /// <list type="bullet"> /// <item>If preset defines an invalid name for a tile system.</item> /// <item>If preset defines a tile system with less than one cell.</item> /// </list> /// </exception> public static GameObject CreateTileSystemFromPreset(TileSystemPreset preset) { if (preset == null) { throw new ArgumentNullException("preset"); } string name = preset.SystemName.Trim(); if (string.IsNullOrEmpty(name)) { throw new InvalidOperationException("Invalid name for tile system."); } if (preset.Rows < 1 || preset.Columns < 1) { throw new InvalidOperationException("Tile system must have at least one cell."); } // Create empty game object and add tile system component. var go = new GameObject(name); var tileSystem = go.AddComponent <TileSystem>(); tileSystem.CreateSystem(preset.TileWidth, preset.TileHeight, preset.TileDepth, preset.Rows, preset.Columns, preset.ChunkWidth, preset.ChunkHeight); TransformTileSystemUsingPreset(preset, go.transform); SetTileSystemPropertiesFromPreset(preset, tileSystem); // Place at end of the scene palette listing. tileSystem.sceneOrder = int.MaxValue; ToolUtility.RepaintScenePalette(); return(go); }
/// <summary> /// Automatically activate tile system from user selection if appropriate so that /// tool can be selected. /// </summary> private void AutoActivateTileSystem() { ToolUtility.SelectActiveOrParentTileSystem(); if (ToolUtility.ActiveTileSystem == null) { // Okay, no tile system is actually selected. // Select first non-locked if possible; otherwise select first if possible. var tileSystems = ToolUtility.GetAllTileSystemsInScene(); var firstTileSystem = tileSystems.FirstOrDefault(s => s != null && !s.Locked); if (firstTileSystem == null) { firstTileSystem = tileSystems.FirstOrDefault(s => s != null); } if (firstTileSystem != null) { ToolUtility.SelectTileSystem(firstTileSystem); } else { return; } } // When using a tool it only makes sense to have one selected tile system. if (Selection.objects.Length > 1) { Selection.objects = new Object[] { ToolUtility.ActiveTileSystem.gameObject }; } }
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 CreateOrientedBrush(string brushName) { var newOrientedBrush = BrushUtility.CreateOrientedBrush(brushName); ToolUtility.ShowBrushInDesigner(newOrientedBrush); ToolUtility.RepaintBrushPalette(); }
/// <inheritdoc/> public override void OnEnable() { ToolUtility.ShowBrushPalette(false); this.RandomizeVariationShift(); this.EnableVariationShifting = true; }
private void CreateAliasBrush(string brushName, Brush targetBrush) { var newAliasBrush = BrushUtility.CreateAliasBrush(brushName, targetBrush); ToolUtility.ShowBrushInDesigner(newAliasBrush); ToolUtility.RepaintBrushPalette(); }
/// <inheritdoc/> protected override void PrepareOptions(ISettingStore store) { base.PrepareOptions(store); this.settingNozzleSizeOption = store.Fetch <int>("NozzleSize", this.DefaultNozzleSize, filter: value => Mathf.Clamp(value, 1, 19) ); this.settingNozzleSizeOption.ValueChanged += (args) => ToolUtility.RepaintToolPalette(); }
/// <summary> /// Restore tool visibility to defaults. /// </summary> public static void RestoreToolVisibility() { Hidden.RestoreDefaultValue(); foreach (var tool in ToolManager.Instance.Tools) { tool._visible = true; } ToolUtility.RepaintToolPalette(); }
private static void PrepareSettings_Tools(ISettingStore store) { AutoShowToolPalette = store.Fetch <bool>("AutoShowToolPalette", false); AutoShowToolPalette.ValueChanged += (args) => { // Immediately show tool palette if a tool is activated! if (args.NewValue && ToolManager.Instance.CurrentTool != null) { ToolUtility.ShowToolPalette(false); } }; }
void IHasCustomMenu.AddItemsToMenu(GenericMenu menu) { menu.AddItem(new GUIContent(TileLang.ParticularText("Action", "Reset Tool Options")), false, () => { this.clearInputFocus = true; foreach (var tool in ToolManager.Instance.Tools) { tool.Options.RestoreDefaultValues(); } ToolUtility.RepaintToolPalette(); }); }
private void CreateAutotileTileset(string tilesetName) { // Ensure that autotile artwork is re-expanded before proceeding to avoid // ignoring changes that have been made to user input. this.ExpandAutotileArtwork(s_BorderSize); // Create folder for autotile brush assets. string tilesetDirectoryName = tilesetName + " Autotile"; string tilesetDirectoryPath = AssetDatabase.GenerateUniqueAssetPath(BrushUtility.GetBrushAssetPath() + tilesetDirectoryName); Directory.CreateDirectory(Directory.GetCurrentDirectory() + "/" + tilesetDirectoryPath); // Create material for tileset. var atlasTexture = EditorInternalUtility.SavePngAsset(tilesetDirectoryPath + "/atlas.png", this.atlasTexture); var atlasMaterial = BrushUtility.CreateTilesetMaterial(atlasTexture, this.enableAlphaBlending); AssetDatabase.CreateAsset(atlasMaterial, tilesetDirectoryPath + "/atlas.mat"); AssetDatabase.ImportAsset(tilesetDirectoryPath + "/atlas.mat"); // Calculate metrics for tileset. var tilesetMetrics = new TilesetMetrics(atlasTexture, this.tileWidth, this.tileHeight, s_BorderSize, s_Delta); // Create tileset. var autotileTileset = ScriptableObject.CreateInstance <AutotileTileset>(); autotileTileset.Initialize(s_SelectedAutotileLayout, s_InnerJoins, atlasMaterial, atlasTexture, tilesetMetrics); autotileTileset.rawTexture = this.autotileTexture; autotileTileset.procedural = true; autotileTileset.ForceClampEdges = s_EnableClampEdges; Object.DestroyImmediate(this.atlasTexture); this.atlasTexture = null; // Save tileset and its material to asset file. string assetPath = tilesetDirectoryPath + "/" + tilesetName + ".asset"; AssetDatabase.CreateAsset(autotileTileset, assetPath); AssetDatabase.ImportAsset(assetPath); // Ensure that changes are persisted immediately. AssetDatabase.SaveAssets(); // Make sure that "Create Brushes" tab is shown. TilesetDesigner.s_SelectedTab = 0; ToolUtility.ShowTilesetInDesigner(autotileTileset); ToolUtility.RepaintBrushPalette(); }
private void OnKeyboardGUI() { int controlID = GUIUtility.GetControlID(FocusType.Keyboard); if (Event.current.GetTypeForControl(controlID) != EventType.KeyDown) { return; } if (GUIUtility.keyboardControl == 0) { ToolManager.Instance.CheckForKeyboardShortcut(); ToolUtility.CheckToolKeyboardShortcuts(); } }
/// <summary> /// Select and activate nearest tile system in parent hierarchy of selected object. /// </summary> /// <seealso cref="SelectTileSystem(TileSystem)"/> /// <seealso cref="SelectPreviousTileSystem()"/> /// <seealso cref="SelectNextTileSystem()"/> /// <seealso cref="SelectNthTileSystem(int)"/> /// <seealso cref="ActiveTileSystem"/> public static void SelectActiveOrParentTileSystem() { var tileSystem = ActiveTileSystem; // If no tile system is currently active, search the parent hierarchy of the // active game object for a tile system and select it. if (tileSystem == null && Selection.activeTransform != null) { tileSystem = ToolUtility.FindParentTileSystem(Selection.activeTransform); } if (tileSystem != null) { SelectTileSystem(tileSystem); } }
/// <summary> /// Refresh preview image for specified brush and also refresh preview image /// for brushes which depend upon the specified brush. /// </summary> /// <remarks> /// <para>At the moment this only includes alias brushes which target the /// specified brush. In the future this may be updated to include oriented /// brushes which nest the specified brush.</para> /// </remarks> /// <param name="brush">The brush.</param> internal static void RefreshPreviewIncludingDependencies(Brush brush) { BrushAssetRecord record = BrushDatabase.Instance.FindRecord(brush); if (record != null) { AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(brush)); // Refresh preview any alias brushes which target this brush. foreach (var dependencyRecord in FindDependencyBrushes(record.Brush)) { RefreshPreview(dependencyRecord.Brush); } ToolUtility.RepaintBrushPalette(); } }
/// <summary> /// Display user interface to replace tiles by brush in a tile system. /// </summary> /// <exclude/> public static void Command_ReplaceByBrush() { ReplaceByBrushWindow.ShowWindow((target, source, replacement) => { // Perform find and replace. int replaced = 0; switch (target) { default: case ReplaceByBrushTarget.ActiveTileSystem: if (ToolUtility.ActiveTileSystem != null && ToolUtility.ActiveTileSystem.IsEditable && !ToolUtility.ActiveTileSystem.Locked) { replaced = ReplaceByBrush(ToolUtility.ActiveTileSystem, source, replacement); } break; case ReplaceByBrushTarget.SelectedTileSystems: foreach (Object ob in Selection.GetFiltered(typeof(TileSystem), SelectionMode.ExcludePrefab)) { TileSystem system = ob as TileSystem; if (system.IsEditable && !system.Locked) { replaced += ReplaceByBrush(system, source, replacement); } } break; case ReplaceByBrushTarget.All: foreach (var tileSystem in ToolUtility.GetAllTileSystemsInScene()) { if (tileSystem.IsEditable && !tileSystem.Locked) { replaced += ReplaceByBrush(tileSystem, source, replacement); } } break; } string message = string.Format( /* 0: quantity of tiles replaced */ TileLang.Text("Replace by Brush :: Matched and replaced {0} tile(s)."), replaced ); Debug.Log(message + "\n"); }); }
private void DrawTileSystemList() { this.AutoInitializeTileSystemsListControl(); Rect scrollViewPosition = new Rect(0, 0, position.width, position.height); scrollViewPosition.yMin = GUILayoutUtility.GetLastRect().yMax; if (Event.current.type == EventType.Repaint) { this.scrollViewPosition = scrollViewPosition; } Rect listControlPosition = new Rect(0, 0, scrollViewPosition.width, this.systemsListControl.CalculateListHeight(this.systemsListAdaptor)); Rect viewRect = listControlPosition; viewRect.height += 7; if (viewRect.height > scrollViewPosition.height) { viewRect.width -= GUI.skin.verticalScrollbar.fixedWidth + GUI.skin.verticalScrollbar.margin.horizontal; } bool isMouseDownEvent = Event.current.type == EventType.MouseDown; try { this.scrollPosition = GUI.BeginScrollView(scrollViewPosition, this.scrollPosition, viewRect); this.systemsListControl.Draw(listControlPosition, this.systemsListAdaptor); GUI.EndScrollView(); } finally { if (isMouseDownEvent) { this.systemsListAdaptor.CanBeginEditingNameOnMouseUp = true; } } // Clear selection when mouse is clicked in empty area of list. if (Event.current.type == EventType.MouseDown && Event.current.button == 0) { if (scrollViewPosition.Contains(Event.current.mousePosition)) { ToolUtility.SelectTileSystem(null); Event.current.Use(); } } }
private void SelectBrushByIndex(int index) { if (index < 0 && this.BrushListModel.View == BrushListView.Tileset) { this.SelectedObject = null; this.BrushListModel.ScrollPosition = 0f; ToolUtility.RepaintBrushPalette(); this.Repaint(); } else { Brush nextBrush = this.BrushListModel.Records[index].Brush; if (nextBrush != null) { this.SelectedObject = nextBrush; } } }
private void OnUseDefaults() { if (EditorUtility.DisplayDialog( TileLang.ParticularText("Action", "Use Default Preferences"), TileLang.Text("Would you like to use the default preferences?"), TileLang.ParticularText("Action", "Yes"), TileLang.ParticularText("Action", "No") )) { RtsPreferences.ResetToDefaultValues(); // Refresh editor windows. ToolUtility.RepaintToolPalette(); ToolUtility.RepaintBrushPalette(); // Refresh all scene views. SceneView.RepaintAll(); } }
private void DrawToolsTab() { EditorGUI.BeginChangeCheck(); ReorderableListGUI.Title(TileLang.Text("Tool Palette:")); ReorderableListGUI.ListField(this.toolsAdaptor, ReorderableListFlags.HideAddButton | ReorderableListFlags.HideRemoveButtons); if (EditorGUI.EndChangeCheck()) { ToolManagementSettings.SaveToolOrdering(); ToolUtility.RepaintToolPalette(); } ExtraEditorGUI.TrailingTip(TileLang.Text("Specify which tools appear in the tools palette.")); GUILayout.Space(5); RtsPreferences.AutoShowToolPalette.Value = EditorGUILayout.ToggleLeft(TileLang.Text("Automatically show tool palette upon activating tool"), RtsPreferences.AutoShowToolPalette); GUILayout.Space(5); }
private void OnRename(string newName) { try { this.inputTilesetName = BrushDatabase.Instance.RenameTileset(this.Tileset, this.inputTilesetName); // Defocus name input field. GUIUtility.keyboardControl = 0; ToolUtility.RepaintBrushPalette(); } catch (ArgumentException ex) { EditorUtility.DisplayDialog( TileLang.ParticularText("Error", " Was unable to rename tileset"), ex.Message, TileLang.ParticularText("Action", "OK") ); } }
private void CreateTileset(string tilesetName) { // Create folder for atlas assets. string atlasFolder = AssetDatabase.GenerateUniqueAssetPath(BrushUtility.GetBrushAssetPath() + tilesetName); Directory.CreateDirectory(Directory.GetCurrentDirectory() + "/" + atlasFolder); // Create material for tileset. var atlasMaterial = BrushUtility.CreateTilesetMaterial(this.tilesetTexture, this.alpha); AssetDatabase.CreateAsset(atlasMaterial, atlasFolder + "/atlas.mat"); AssetDatabase.ImportAsset(atlasFolder + "/atlas.mat"); // Use edge correction preset? if (this.edgeCorrectionPreset != EdgeCorrectionPreset.Custom) { this.borderSize = 0; this.delta = (this.edgeCorrectionPreset == EdgeCorrectionPreset.InsetUVs) ? 0.5f : 0f; } // Calculate metrics for tileset. this.RecalculateMetrics(); // Create tileset. var tileset = ScriptableObject.CreateInstance <Tileset>(); tileset.Initialize(atlasMaterial, this.tilesetTexture, this.tilesetMetrics); tileset.procedural = this.procedural; // Save tileset and its material to asset file. string assetPath = atlasFolder + "/" + tilesetName + ".asset"; AssetDatabase.CreateAsset(tileset, assetPath); AssetDatabase.ImportAsset(assetPath); // Ensure that changes are persisted immediately. AssetDatabase.SaveAssets(); // Make sure that "Create Brushes" tab is shown. TilesetDesigner.s_SelectedTab = 0; ToolUtility.ShowTilesetInDesigner(tileset); ToolUtility.RepaintBrushPalette(); }
private void _brushList_BrushMouseDown(Brush brush) { // Double-click to ensure that designer window is shown. if (Event.current.clickCount == 2 && brush != null) { ToolUtility.ShowBrushInDesigner(brush); GUIUtility.hotControl = 0; GUIUtility.ExitGUI(); return; } // If right mouse button was depressed, without holding control key, select // as primary brush ready for context menu. if (Event.current.button == 1 && !Event.current.control) { ToolUtility.SelectedBrush = brush; } }
private static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths) { if (!s_EnableScanner) { return; } // Check for new brush/tileset assets. if (ContainsNewBrushOrTileset(importedAssets)) { BrushDatabase.Instance.Rescan(); ToolUtility.RepaintBrushPalette(); } // Check for deleted brush/tileset assets. BrushDatabase.Instance.ClearMissingRecords(); ToolUtility.RepaintBrushPalette(); DesignerWindow.RepaintWindow(); }
internal void DrawBrushesGUI() { this.DrawToolbar(); if (GUIUtility.keyboardControl == 0) { ToolManager.Instance.CheckForKeyboardShortcut(); ToolUtility.CheckToolKeyboardShortcuts(); } GUILayout.Space(-1); // Is selected brush (primary or secondary) about to be changed? this.brushList.Draw(false); this.DrawPrimarySecondaryBrushSwitcher(); GUILayout.Space(5); }
private void OnSelectedObjectChanged() { // Finish up with previous brush editor. this.UnloadDesignerView(); if (this.SelectedObject is Brush) { this.LoadBrushDesignerView(); if (!this.IsLocked) { // Make sure that brush is shown in brush list. this.BrushListModel.SelectedBrush = this.SelectedObject as Brush; ToolUtility.RevealBrush(this.BrushListModel.SelectedBrush, false); } } else if (this.SelectedObject is Tileset) { this.LoadTilesetDesignerView(); if (!this.IsLocked) { // Make sure that tileset is shown in brush list. this.BrushListModel.View = BrushListView.Tileset; this.BrushListModel.SelectedTileset = this.SelectedObject as Tileset; } } if (!this.History.IsNavigating) { if (this.designerView != null && this.SelectedObject != null && this.SelectedObject.Exists) { this.currentState = this.designerView.CreateHistoryState(); this.History.AddToRecent(this.SelectedObject); } } // Clear active input control. this._clearFocusControl = true; this.Repaint(); }
private void OnEnable() { var targetSystem = target as TileSystem; // Mark active target as the active tile system? // - Must be part of current user selection! // - Must not reside within an asset. if (Selection.activeGameObject == targetSystem.gameObject && Selection.instanceIDs.Length == 1) { if (!EditorUtility.IsPersistent(this.target) && ToolUtility.ActiveTileSystem != targetSystem) { ToolUtility.ActiveTileSystem = targetSystem; // Hide selected wireframe if tool is active. if (ToolManager.Instance.CurrentTool != null) { ToolUtility.HideSelectedWireframe(targetSystem); } } } }
private static bool OnOpenAsset(int instanceID, int line) { var asset = EditorUtility.InstanceIDToObject(instanceID); var brush = asset as Brush; if (brush != null) { ToolUtility.ShowBrushInDesigner(brush); return(true); } var tileset = asset as Tileset; if (tileset != null) { ToolUtility.ShowTilesetInDesigner(tileset); return(true); } return(false); }
/// <inheritdoc/> protected override void DoGUI() { // Generate a control ID for the palette window so that keyboard focus can be // easily removed from the active control. int paletteControlID = EditorGUIUtility.GetControlID(FocusType.Keyboard); if (this.clearInputFocus || Event.current.type == EventType.MouseDown || Event.current.type == EventType.KeyDown && Event.current.keyCode == KeyCode.Escape) { this.clearInputFocus = false; EditorGUIUtility.keyboardControl = paletteControlID; this.Repaint(); } if (GUIUtility.keyboardControl == paletteControlID) { ToolManager.Instance.CheckForKeyboardShortcut(); ToolUtility.CheckToolKeyboardShortcuts(); } this.OnToolSelectorGUI(); RotorzEditorGUI.DrawHoverTip(this); }
private void AutoAddPostfixToName() { var tileSystems = ToolUtility.GetAllTileSystemsInScene(); string baseName = Regex.Replace(this.currentPreset.SystemName, "#\\d+$", ""); string nextName = baseName; int increment = 1; while (true) { next: foreach (var tileSystem in tileSystems) { if (tileSystem.name == nextName) { nextName = string.Format("{0} #{1}", baseName, ++increment); goto next; } } break; } this.currentPreset.SystemName = nextName; }