private void DrawToolbar()
{
GUILayout.BeginHorizontal(EditorStyles.toolbar);
EditorGUI.BeginDisabledGroup(PrefabUtility.GetPrefabType(this.target) == PrefabType.Prefab || this.targets.Length != 1);
if (this.target.IsEditable && GUILayout.Button(TileLang.OpensWindow(TileLang.ParticularText("Action", "Build Prefab")), RotorzEditorStyles.Instance.ToolbarButtonPaddedExtra))
{
TileSystemCommands.Command_BuildPrefab(this.target);
GUIUtility.ExitGUI();
}
EditorGUI.EndDisabledGroup();
GUILayout.FlexibleSpace();
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.GridToggle,
TileLang.ParticularText("Action", "Toggle Grid Display")
)) {
RtsPreferences.ShowGrid.Value = GUILayout.Toggle(RtsPreferences.ShowGrid, content, RotorzEditorStyles.Instance.ToolbarButtonPadded);
}
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.ChunkToggle,
TileLang.ParticularText("Action", "Toggle Chunk Display")
)) {
RtsPreferences.ShowChunks.Value = GUILayout.Toggle(RtsPreferences.ShowChunks, content, RotorzEditorStyles.Instance.ToolbarButtonPadded);
}
EditorGUILayout.Space();
this.DrawHelpButton();
GUILayout.EndHorizontal();
}
private static ControlContent AlignmentContent(string label, SnapAxis axis)
{
Texture2D icon;
string tip;
switch (axis.Alignment)
{
default:
case SnapAlignment.Points:
icon = RotorzEditorStyles.Skin.SnapPoints;
tip = TileLang.ParticularText("SnapAlignment", "Points");
break;
case SnapAlignment.Cells:
icon = RotorzEditorStyles.Skin.SnapCells;
tip = TileLang.ParticularText("SnapAlignment", "Cells");
break;
case SnapAlignment.Free:
icon = label == "X" ? RotorzEditorStyles.Skin.SnapFreeX : RotorzEditorStyles.Skin.SnapFreeY;
tip = TileLang.ParticularText("SnapAlignment", "Free");
break;
}
return(ControlContent.Basic(icon, tip));
}
/// <inheritdoc/>
protected override void DoEnable()
{
this.titleContent = new GUIContent(string.Format(
/* 0: name of product */
TileLang.Text("Preferences - {0}"),
ProductInfo.Name
));
this.InitialSize = this.minSize = new Vector2(500, 342);
this.maxSize = new Vector2(500, 10000);
this.wantsMouseMove = true;
this.tabs = new GUIContent[] {
ControlContent.Basic(TileLang.ParticularText("Preferences|TabLabel", "Tools")),
ControlContent.Basic(TileLang.ParticularText("Preferences|TabLabel", "Painting")),
ControlContent.Basic(TileLang.ParticularText("Preferences|TabLabel", "Grid")),
ControlContent.Basic(TileLang.ParticularText("Preferences|TabLabel", "Misc"))
};
this.scrolling = new Vector2[this.tabs.Length];
this.toolsAdaptor = new GenericListAdaptor <ToolBase>(ToolManager.Instance.toolsInUserOrder, this.DrawAvailableToolEntry, 22);
this.GatherLocaleOptions();
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
var idProperty = property.FindPropertyRelative("id");
var labelProperty = property.FindPropertyRelative("label");
float initialLabelWidth = EditorGUIUtility.labelWidth;
EditorGUIUtility.labelWidth = 64;
if (ProjectSettings.Instance.ShowCategoryIds)
{
using (var content = ControlContent.Basic(
labelText: string.Format(
/* 0: category id */
TileLang.Text("Id: {0}"),
idProperty.intValue
)
)) {
position = EditorGUI.PrefixLabel(position, content);
}
}
labelProperty.stringValue = EditorGUI.TextField(position, labelProperty.stringValue);
EditorGUIUtility.labelWidth = initialLabelWidth;
}
private void DrawTabs()
{
GUILayout.BeginHorizontal();
for (int i = 0; i < this.tabs.Length; ++i)
{
using (var tabLabelContent = ControlContent.Basic(this.tabs[i].Label)) {
Rect position = GUILayoutUtility.GetRect(tabLabelContent, RotorzEditorStyles.Instance.Tab);
int controlID = GUIUtility.GetControlID(FocusType.Passive, position);
switch (Event.current.GetTypeForControl(controlID))
{
case EventType.MouseDown:
if (position.Contains(Event.current.mousePosition))
{
s_SelectedTab = i;
Event.current.Use();
}
break;
case EventType.Repaint:
RotorzEditorStyles.Instance.Tab.Draw(position, tabLabelContent, false, false, s_SelectedTab == i, false);
break;
}
}
}
GUILayout.Box(GUIContent.none, RotorzEditorStyles.Instance.TabBackground);
GUILayout.EndHorizontal();
}
private void DrawHelpButton()
{
GUILayout.Space(33);
Rect position = new Rect(Window.position.width - 37, 2, 34, 26);
using (var helpMenuContent = ControlContent.Basic(
RotorzEditorStyles.Skin.ContextHelp,
TileLang.ParticularText("Action", "Help")
)) {
if (EditorInternalUtility.DropdownMenu(position, helpMenuContent, RotorzEditorStyles.Instance.FlatButton))
{
var helpMenu = new EditorMenu();
helpMenu.AddCommand(TileLang.ParticularText("Action", "Show Tips"))
.Checked(ControlContent.TrailingTipsVisible)
.Action(() => {
ControlContent.TrailingTipsVisible = !ControlContent.TrailingTipsVisible;
});
--position.y;
helpMenu.ShowAsDropdown(position);
}
}
}
private void DrawPrimarySecondaryBrushSwitcher()
{
Rect r;
GUILayout.Space(5);
GUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
GUILayout.Label(RotorzEditorStyles.Skin.MouseLeft);
GUILayout.Box(GUIContent.none, RotorzEditorStyles.Instance.SelectedBrushPreviewBox);
r = GUILayoutUtility.GetLastRect();
if (ToolUtility.SelectedBrush != null)
{
RotorzEditorGUI.DrawBrushPreview(new Rect(r.x + 2, r.y + 2, r.width - 4, r.height - 4), ToolUtility.SelectedBrush);
}
else
{
GUI.Label(r, TileLang.ParticularText("Action", "Erase"), RotorzEditorStyles.Instance.MiniCenteredLabel);
}
GUILayout.Space(10);
GUILayout.Label(RotorzEditorStyles.Skin.MouseRight);
GUILayout.Box(GUIContent.none, RotorzEditorStyles.Instance.SelectedBrushPreviewBox);
r = GUILayoutUtility.GetLastRect();
if (ToolUtility.SelectedBrushSecondary != null)
{
RotorzEditorGUI.DrawBrushPreview(new Rect(r.x + 2, r.y + 2, r.width - 4, r.height - 4), ToolUtility.SelectedBrushSecondary);
}
else
{
GUI.Label(r, TileLang.ParticularText("Action", "Erase"), RotorzEditorStyles.Instance.MiniCenteredLabel);
}
GUILayout.Space(5);
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.SwitchPrimarySecondary,
TileLang.ParticularText("Action", "Switch primary and secondary brushes (X)")
)) {
if (RotorzEditorGUI.HoverButton(content, GUILayout.Height(42)))
{
Brush t = ToolUtility.SelectedBrush;
ToolUtility.SelectedBrush = ToolUtility.SelectedBrushSecondary;
ToolUtility.SelectedBrushSecondary = t;
GUIUtility.ExitGUI();
}
}
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
GUILayout.Space(5);
}
/// <summary>
/// Use to draw menu button somewhere within designer window.
/// </summary>
/// <remarks>
/// <para>Custom menu items can be added to menu by providing a custom implementation
/// of <see cref="AddItemsToMenu"/>.</para>
/// </remarks>
/// <param name="position">Position of button in space of editor window.</param>
/// <param name="tooltip">Tooltip text.</param>
protected void DrawMenuButton(Rect position, string tooltip = null)
{
using (var content = ControlContent.Basic(RotorzEditorStyles.Skin.GearButton, tooltip)) {
if (EditorInternalUtility.DropdownMenu(position, content, RotorzEditorStyles.Instance.FlatButton))
{
this.DisplayMenu(new Rect(position.x, position.y, position.width, position.height - 1));
GUIUtility.ExitGUI();
}
}
}
/// <inheritdoc/>
protected override void DoGUI()
{
Event e = Event.current;
Rect position;
GUILayout.Space(10);
// Draw header area.
using (var titleContent = ControlContent.Basic(ProductInfo.Name)) {
position = GUILayoutUtility.GetRect(1, 100);
if (e.type == EventType.Repaint)
{
Rect headerBackgroundPosition = new Rect(position.x - 2, position.y - 12, position.width + 4, position.height);
if (EditorGUIUtility.isProSkin)
{
GUI.DrawTexture(headerBackgroundPosition, EditorGUIUtility.whiteTexture);
}
else
{
RotorzEditorStyles.Instance.TransparentBox.Draw(headerBackgroundPosition, GUIContent.none, false, false, false, false);
}
Texture2D texAssetBadge = RotorzEditorStyles.Skin.Badge;
GUI.DrawTexture(new Rect(position.x + position.width - texAssetBadge.width - 6, position.y - 3, texAssetBadge.width, texAssetBadge.height), texAssetBadge);
}
position.x += 10;
position.width -= 10;
GUI.Label(position, titleContent, this.labelTitleStyle);
Rect versionLabelPosition = new Rect(position.x, position.y + this.labelTitleStyle.CalcHeight(titleContent, position.width), position.width, 42);
GUI.Label(versionLabelPosition, this.versionString, this.labelVersionStyle);
GUILayout.BeginHorizontal();
this.AddLink(TileLang.ParticularText("Online", "Repository"), "https://github.com/rotorz/unity3d-tile-system", "https://github.com/rotorz/unity3d-tile-system");
GUILayout.EndHorizontal();
}
ExtraEditorGUI.SeparatorLight(marginTop: 17, marginBottom: 7);
// Draw footer area.
var vendorBadge = RotorzEditorStyles.Skin.VendorBadge;
position = GUILayoutUtility.GetRect(1, vendorBadge.height + 5);
if (e.type == EventType.Repaint)
{
GUI.DrawTexture(new Rect(position.x + 7, position.y - 2, vendorBadge.width, vendorBadge.height), vendorBadge);
position.y -= 4;
this.labelLowerRightStyle.Draw(position, "©2011-2017 Rotorz Limited. All rights reserved.", false, false, false, false);
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
Rect rect = new Rect(position.x, position.y, position.width, EditorGUIUtility.singleLineHeight + 1);
var propActive = property.FindPropertyRelative("isActive");
ExtraEditorGUI.ToggleLeft(rect, propActive, label);
rect.y = rect.yMax + 1;
if (propActive.boolValue)
{
++EditorGUI.indentLevel;
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Snap Threshold")
)) {
var propSnapThreshold = property.FindPropertyRelative("snapThreshold");
EditorGUI.PropertyField(rect, propSnapThreshold, content);
rect.y = rect.yMax + 1;
}
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Keep Separate")
)) {
var propKeepSeparate = property.FindPropertyRelative("keepSeparate");
DrawKeepSeparateField(rect, propKeepSeparate, content);
rect.y = rect.yMax + 1;
}
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Include tiles flagged as solid")
)) {
var propIncludeSolidTiles = property.FindPropertyRelative("includeSolidTiles");
ExtraEditorGUI.ToggleLeft(rect, propIncludeSolidTiles, content);
rect.y = rect.yMax + 1;
if (propIncludeSolidTiles.boolValue)
{
++EditorGUI.indentLevel;
using (var content2 = ControlContent.Basic(
TileLang.ParticularText("Property", "Collider Type")
)) {
var propSolidTileColliderType = property.FindPropertyRelative("solidTileColliderType");
EditorGUI.PropertyField(rect, propSolidTileColliderType, content2);
}
--EditorGUI.indentLevel;
}
}
--EditorGUI.indentLevel;
}
}
private void DrawMaintainTilePositionsInWorld(ref bool flag)
{
++EditorGUI.indentLevel;
// "Maintain tile positions in world space"
using (var content = ControlContent.Basic(TileLang.ParticularText("Property", "Maintain tile positions in world space"))) {
flag = EditorGUILayout.ToggleLeft(content, flag);
}
--EditorGUI.indentLevel;
}
private void DrawTilesetNameField()
{
GUILayout.Label(TileLang.ParticularText("Property", "Tileset"), RotorzEditorStyles.Instance.LabelMiddleLeft);
this.inputTilesetName = EditorGUILayout.TextField(this.inputTilesetName, RotorzEditorStyles.Instance.TextFieldRoundEdge);
var currentTilesetName = Tileset.name;
if (this.inputTilesetName != currentTilesetName)
{
string filteredName = this.inputTilesetName;
// Limit to 70 characters.
if (filteredName.Length > 70)
{
filteredName = filteredName.Substring(0, 70);
}
// Restrict to alphanumeric characters.
filteredName = Regex.Replace(filteredName, "[^- A-Za-z0-9_+!~#()]+", "");
using (var content = ControlContent.Basic(
"",
TileLang.ParticularText("Action", "Restore Current Name")
)) {
if (GUILayout.Button(content, RotorzEditorStyles.Instance.TextFieldRoundEdgeCancelButton))
{
GUIUtility.keyboardControl = 0;
this.inputTilesetName = currentTilesetName;
GUIUtility.ExitGUI();
}
}
using (var content = ControlContent.Basic(
TileLang.ParticularText("Action", "Rename")
)) {
if (!string.IsNullOrEmpty(filteredName) && filteredName != currentTilesetName)
{
if (GUILayout.Button(content, RotorzEditorStyles.Instance.ButtonPaddedExtra))
{
currentTilesetName = this.inputTilesetName = filteredName;
this.OnRename(this.inputTilesetName);
GUIUtility.ExitGUI();
}
}
}
}
else
{
GUILayout.Label(GUIContent.none, RotorzEditorStyles.Instance.TextFieldRoundEdgeCancelButtonEmpty);
}
}
protected override void OnHeaderGUI()
{
Rect position = GUILayoutUtility.GetRect(0, 46);
if (Event.current.type == EventType.Repaint)
{
GUI.skin.box.Draw(position, GUIContent.none, false, false, false, false);
GUI.DrawTexture(new Rect(7, 7, 32, 32), RotorzEditorStyles.Skin.Icon_PresetTileSystem);
string headerText = targets.Length == 1
? string.Format(
/* 0: name of tile system preset */
TileLang.Text("{0} (Tile System Preset)"),
target.name
)
: string.Format(
/* 0: quantity of selected tile system presets */
TileLang.Text("{0} Tile System Presets"),
targets.Length
);
EditorStyles.largeLabel.Draw(new Rect(48, 7, position.width - 48, position.height), headerText, false, false, false, false);
}
Rect menuPosition = new Rect(position.width - 25, 7, 22, 16);
if (GUI.Button(menuPosition, RotorzEditorStyles.Skin.SmallGearButton, GUIStyle.none))
{
this.ShowContextMenu(menuPosition);
GUIUtility.ExitGUI();
}
EditorGUI.BeginDisabledGroup(targets.Length != 1);
{
using (var content = ControlContent.Basic(
TileLang.ParticularText("Action", "Create Tile System")
)) {
Vector2 createButtonSize = EditorStyles.miniButton.CalcSize(content);
Rect createButtonPosition = new Rect(position.width - createButtonSize.x - 5, 24, createButtonSize.x, createButtonSize.y);
if (GUI.Button(createButtonPosition, content, EditorStyles.miniButton))
{
var tileSystemGO = TileSystemPresetUtility.CreateTileSystemFromPreset((TileSystemPreset)target);
Selection.activeObject = tileSystemGO;
Undo.RegisterCreatedObjectUndo(tileSystemGO, content.LabelContent.text);
}
}
}
EditorGUI.EndDisabledGroup();
GUILayout.Space(5);
}
private bool ToolButton(GUIContent content, bool on = false)
{
Rect position = GUILayoutUtility.GetRect(content, s_ToolButtonStyle);
int controlID = RotorzEditorGUI.GetHoverControlID(position, content.image != null ? content.text : null);
switch (Event.current.GetTypeForControl(controlID))
{
case EventType.MouseDown:
if (Event.current.button == 0 && position.Contains(Event.current.mousePosition))
{
GUIUtility.hotControl = controlID;
Event.current.Use();
}
break;
case EventType.MouseUp:
if (GUIUtility.hotControl == controlID)
{
GUIUtility.hotControl = 0;
Event.current.Use();
return(position.Contains(Event.current.mousePosition));
}
break;
case EventType.MouseDrag:
if (GUIUtility.hotControl == controlID)
{
Event.current.Use();
}
break;
case EventType.Repaint:
if (content.image != null)
{
using (var tempContent = ControlContent.Basic(content.image)) {
s_ToolButtonStyle.Draw(position, tempContent, controlID, on);
}
}
else
{
using (var tempContent = ControlContent.Basic(content.text)) {
s_ToolButtonStyle.Draw(position, tempContent, controlID, on);
}
}
break;
}
return(false);
}
private void DrawAtlasParametersGUI()
{
EditorGUIUtility.labelWidth = 1;
EditorGUIUtility.fieldWidth = 105;
GUILayout.BeginVertical();
EditorGUI.BeginChangeCheck();
{
ExtraEditorGUI.AbovePrefixLabel(TileLang.ParticularText("Property", "Tile Width (px)"));
this.inputTileWidth = EditorGUILayout.IntField(this.inputTileWidth, GUILayout.Width(60));
ExtraEditorGUI.AbovePrefixLabel(TileLang.ParticularText("Property", "Tile Height (px)"));
this.inputTileHeight = EditorGUILayout.IntField(this.inputTileHeight, GUILayout.Width(60));
}
if (EditorGUI.EndChangeCheck())
{
this.ClearExpandedAutotileAtlas();
// Automatically load uncompressed version of autotile artwork if it has
// not already been loaded.
if (this.inputNewAutotileArtworkUncompressed == null)
{
this.LoadUncompressedAutotileArtwork(this.inputNewAutotileArtwork);
}
}
GUILayout.Space(10);
//this.alpha = GUILayout.Toggle(this.alpha, "Alpha Blending");
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Procedural"),
TileLang.Text("Autotile brushes are always procedural, however atlas brushes of an autotile atlas can be non-procedural if desired.")
)) {
this.inputProcedural = GUILayout.Toggle(this.inputProcedural, content);
}
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Clamp Edges"),
TileLang.Text("Indicates if outer edges should always be clamped. Often not appropriate when secondary tile acts as ground.")
)) {
if (this.autotileTileset.AutotileLayout == AutotileLayout.Extended && this.inputBorderSize > 0)
{
this.inputClampEdges = GUILayout.Toggle(this.inputClampEdges, content);
}
}
GUILayout.EndVertical();
}
/// <summary>
/// Draw "Paint Around Existing Tiles" toggle.
/// </summary>
/// <remarks>
/// <para>This method should be called within horizontally flowing layout.</para>
/// </remarks>
protected void DrawPaintAroundExistingTilesOption()
{
if (!this.SupportsPaintAroundExistingTiles)
{
throw new InvalidOperationException("This tool does not support the 'Paint Around Existing Tiles' option. Consider overriding `SupportsPaintAroundExistingTiles`.");
}
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.GetActive(RotorzEditorStyles.Skin.RectanglePaintAround, ToolUtility.PaintAroundExistingTiles),
TileLang.ParticularText("Property", "Paint Around Existing Tiles")
)) {
Rect position = GUILayoutUtility.GetRect(33, 24);
ToolUtility.PaintAroundExistingTiles = RotorzEditorGUI.HoverToggle(position, content, ToolUtility.PaintAroundExistingTiles, RotorzEditorStyles.Instance.FlatButtonNoMargin);
}
}
private void DrawVariationShifter()
{
Rect position = GUILayoutUtility.GetRect(17, 0);
position.x += 2;
position.height = 27;
Rect plusButtonPosition = new Rect(position.x, position.y - 4, 17, 17);
using (var content = ControlContent.Basic("", this._shiftToNextVariationTooltip)) {
if (RotorzEditorGUI.HoverButton(plusButtonPosition, content))
{
++this.VariationShiftCount;
}
}
Rect minusButtonPosition = new Rect(position.x, position.yMax - 14, 17, 17);
using (var content = ControlContent.Basic("", this._shiftToPrevVariationTooltip)) {
if (RotorzEditorGUI.HoverButton(minusButtonPosition, content))
{
--this.VariationShiftCount;
}
}
if (Event.current.type == EventType.Repaint)
{
Color restoreColor = GUI.color;
if (!GUI.enabled)
{
GUI.color = new Color(1f, 1f, 1f, 0.4f);
}
plusButtonPosition.x += 6;
plusButtonPosition.y += 5;
plusButtonPosition.width = 5;
plusButtonPosition.height = 7;
GUI.DrawTextureWithTexCoords(plusButtonPosition, RotorzEditorStyles.Skin.VariationOffsetSelector, new Rect(0f, 0.5f, 1f, 0.5f));
minusButtonPosition.x += 6;
minusButtonPosition.y += 5;
minusButtonPosition.width = 5;
minusButtonPosition.height = 7;
GUI.DrawTextureWithTexCoords(minusButtonPosition, RotorzEditorStyles.Skin.VariationOffsetSelector, new Rect(0f, 0f, 1f, 0.5f));
GUI.color = restoreColor;
}
}
private void DrawCreatorSection()
{
GUILayout.Label(TileLang.Text("Brushes"), EditorStyles.boldLabel);
{
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Brushes Folder")
)) {
this.propertyBrushesFolderRelativePath.stringValue = RotorzEditorGUI.RelativeAssetPathTextField(content, this.propertyBrushesFolderRelativePath.stringValue, false);
}
GUILayout.Space(3);
Rect totalButtonPosition = EditorGUI.IndentedRect(EditorGUILayout.GetControlRect(true, 20));
Rect buttonPosition = totalButtonPosition;
buttonPosition.x += EditorGUIUtility.labelWidth;
buttonPosition.width = (buttonPosition.width - EditorGUIUtility.labelWidth) / 2f - 2;
if (GUI.Button(buttonPosition, TileLang.OpensWindow(TileLang.ParticularText("Action", "Browse"))))
{
this.BrushesFolder_Browse_Clicked();
}
buttonPosition.x = buttonPosition.xMax + 4;
if (GUI.Button(buttonPosition, TileLang.ParticularText("Action", "Reset")))
{
this.BrushesFolder_Reset_Clicked();
}
}
GUILayout.Label(TileLang.Text("Tilesets"), EditorStyles.boldLabel);
{
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Opaque Material Template")
)) {
EditorGUILayout.PropertyField(this.propertyOpaqueTilesetMaterialTemplate, content);
}
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Transparent Material Template")
)) {
EditorGUILayout.PropertyField(this.propertyTransparentTilesetMaterialTemplate, content);
}
RotorzEditorGUI.InfoBox(TileLang.Text("Default materials are created when no material templates are specified."));
}
}
private void DrawPreferredLanguageField()
{
EditorGUILayout.BeginHorizontal();
// "Preferred Language (BETA)"
using (var content = ControlContent.Basic(TileLang.Text("Preferred Language (BETA)"))) {
EditorGUI.BeginChangeCheck();
this.preferredCultureIndex = EditorGUILayout.Popup(content, this.preferredCultureIndex, this.availableCultureLabels);
if (EditorGUI.EndChangeCheck())
{
var selectedCulture = this.availableCultures[this.preferredCultureIndex];
PackageLanguageManager.SetPreferredCulture(selectedCulture);
}
}
GUILayout.Space(32);
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.RefreshIcon,
TileLang.ParticularText("Action", "Refresh")
)) {
Rect refreshButtonPosition = GUILayoutUtility.GetLastRect();
refreshButtonPosition.x = refreshButtonPosition.xMax - 31 + 3;
refreshButtonPosition.y = refreshButtonPosition.y - 1;
refreshButtonPosition.width = 31;
refreshButtonPosition.height = 21;
if (RotorzEditorGUI.HoverButton(refreshButtonPosition, content))
{
PackageLanguageManager.ReloadAll();
}
}
EditorGUILayout.EndHorizontal();
string translators = TileLang.Text("__Translators__").Trim();
if (!string.IsNullOrEmpty(translators) && translators != "-" && translators != "__Translators__")
{
string message = string.Format(
/* list of special people names */
TileLang.Text("Special Thanks: {0}"),
translators
);
EditorGUILayout.HelpBox(message, MessageType.None);
}
}
private void DrawHelpButton()
{
using (var content = ControlContent.Basic(RotorzEditorStyles.Skin.ContextHelp)) {
Rect position = GUILayoutUtility.GetRect(content, RotorzEditorStyles.Instance.ToolbarButtonPadded);
if (EditorInternalUtility.DropdownMenu(position, content, RotorzEditorStyles.Instance.ToolbarButtonPadded))
{
var helpMenu = new EditorMenu();
helpMenu.AddCommand(TileLang.ParticularText("Action", "Show Tips"))
.Checked(ControlContent.TrailingTipsVisible)
.Action(() => {
ControlContent.TrailingTipsVisible = !ControlContent.TrailingTipsVisible;
});
--position.y;
helpMenu.ShowAsDropdown(position);
}
}
}
/// <inheritdoc/>
public override void DrawSecondaryMenuButton(Rect position)
{
EditorGUI.BeginDisabledGroup(this.TilesetBrush.Tileset == null);
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.GotoTileset,
TileLang.FormatActionWithShortcut(
TileLang.ParticularText("Action", "Goto Tileset"), "F3"
)
)) {
if (RotorzEditorGUI.HoverButton(position, content))
{
this.OnViewTileset();
GUIUtility.ExitGUI();
}
}
EditorGUI.EndDisabledGroup();
}
/// <inheritdoc/>
public override void OnToolOptionsGUI()
{
Rect position;
GUILayout.BeginHorizontal();
this.DrawStandardOptionsGUI();
GUILayout.FlexibleSpace();
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.GetActive(RotorzEditorStyles.Skin.RectangleFill, ToolUtility.FillCenter),
TileLang.ParticularText("Property", "Fill Center")
)) {
position = GUILayoutUtility.GetRect(21 + 12, 19 + 5);
if (RotorzEditorGUI.HoverToggle(position, content, ToolUtility.FillCenter, RotorzEditorStyles.Instance.FlatButtonNoMargin))
{
ToolUtility.FillCenter = true;
}
}
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.GetActive(RotorzEditorStyles.Skin.RectangleOutline, !ToolUtility.FillCenter),
TileLang.ParticularText("Property", "Draw Outline")
)) {
position = GUILayoutUtility.GetRect(21 + 12, 19 + 5);
if (RotorzEditorGUI.HoverToggle(position, content, !ToolUtility.FillCenter, RotorzEditorStyles.Instance.FlatButtonNoMargin))
{
ToolUtility.FillCenter = false;
}
}
RotorzEditorGUI.VerticalSeparatorLight();
// "Paint Around Existing Tiles"
this.DrawPaintAroundExistingTilesOption();
GUILayout.Space(3);
GUILayout.EndHorizontal();
ExtraEditorGUI.SeparatorLight();
}
/// <inheritdoc/>
public override void DrawSecondaryMenuButton(Rect position)
{
var brushRecord = BrushDatabase.Instance.FindRecord(this.AliasBrush.target);
EditorGUI.BeginDisabledGroup(brushRecord == null || brushRecord.IsMaster);
{
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.GotoTarget,
TileLang.FormatActionWithShortcut(
TileLang.ParticularText("Action", "Goto Target Brush"), "F3"
)
)) {
if (RotorzEditorGUI.HoverButton(position, content))
{
this.ShowTargetBrushInDesigner();
GUIUtility.ExitGUI();
}
}
}
EditorGUI.EndDisabledGroup();
}
private void DrawDialogButtons()
{
if (GUILayout.Button(TileLang.ParticularText("Action", "OK"), ExtraEditorStyles.Instance.BigButton))
{
this.OnButtonOK();
}
GUILayout.Space(3);
if (GUILayout.Button(TileLang.ParticularText("Action", "Cancel"), ExtraEditorStyles.Instance.BigButton))
{
this.OnButtonCancel();
}
if (this.onDefineOrientation2 != null)
{
GUILayout.FlexibleSpace();
Rect togglePosition = GUILayoutUtility.GetRect(0, 34);
togglePosition.x += (togglePosition.width - 60) / 2;
togglePosition.width = 60;
using (var toggleContent = ControlContent.Basic(
image: this.RotationalSymmetry
? RotorzEditorStyles.Skin.ToggleRotationalSymmetryOn
: RotorzEditorStyles.Skin.ToggleRotationalSymmetry
,
tipText: TileLang.ParticularText("Action", "Toggle Rotational Symmetry")
)) {
this.RotationalSymmetry = RotorzEditorGUI.HoverToggle(togglePosition, toggleContent, this.RotationalSymmetry, GUI.skin.button);
}
}
GUILayout.FlexibleSpace();
if (GUILayout.Button(TileLang.ParticularText("Action", "Invert"), ExtraEditorStyles.Instance.BigButton))
{
this.OnButtonInvert();
}
}
private void OnGUI_Presets()
{
GUILayout.Space(10);
EditorGUILayout.PrefixLabel(TileLang.ParticularText("Property", "Preset"));
EditorGUI.BeginChangeCheck();
using (var valueContent = ControlContent.Basic(this.currentPreset.name)) {
s_SelectedPresetGuid.Value = CustomPopupGUI.Popup(GUIContent.none, s_SelectedPresetGuid.Value, valueContent, this.PopulatePresetMenu);
}
if (EditorGUI.EndChangeCheck())
{
this.SetSelectedPreset(s_SelectedPresetGuid.Value);
}
EditorGUILayout.Space();
EditorGUILayout.PrefixLabel(TileLang.ParticularText("Property", "Preset Name"));
this.newPresetName = EditorGUILayout.TextField(this.newPresetName);
if (GUILayout.Button(TileLang.ParticularText("Action", "Save Preset")))
{
this.OnButton_SavePreset();
GUIUtility.ExitGUI();
}
// Do not allow deletion of factory default preset.
EditorGUI.BeginDisabledGroup(this.selectedPreset == null);
if (GUILayout.Button(TileLang.ParticularText("Action", "Delete Preset")))
{
this.OnButton_DeletePreset();
GUIUtility.ExitGUI();
}
EditorGUI.EndDisabledGroup();
GUILayout.FlexibleSpace();
ControlContent.TrailingTipsVisible = GUILayout.Toggle(ControlContent.TrailingTipsVisible, TileLang.ParticularText("Action", "Show Tips"));
GUILayout.Space(10);
}
private void DrawAtlasParametersGUI()
{
EditorGUIUtility.fieldWidth = 105f;
GUILayout.BeginVertical();
{
EditorGUI.BeginChangeCheck();
{
ExtraEditorGUI.AbovePrefixLabel(TileLang.ParticularText("Property", "Tile Width (px)"));
this.tileWidth = EditorGUILayout.IntField(this.tileWidth, GUILayout.Width(60f));
ExtraEditorGUI.AbovePrefixLabel(TileLang.ParticularText("Property", "Tile Height (px)"));
this.tileHeight = EditorGUILayout.IntField(this.tileHeight, GUILayout.Width(60f));
}
if (EditorGUI.EndChangeCheck())
{
this.clearPreviews = true;
}
GUILayout.Space(10f);
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Alpha Blending")
)) {
this.enableAlphaBlending = EditorGUILayout.ToggleLeft(content, this.enableAlphaBlending);
}
if (s_SelectedAutotileLayout == AutotileLayout.Extended && s_BorderSize > 0)
{
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Clamp Edges"),
TileLang.Text("Indicates if outer edges should always be clamped. Often not appropriate when secondary tile acts as ground.")
)) {
s_EnableClampEdges = EditorGUILayout.ToggleLeft(content, s_EnableClampEdges);
}
}
}
GUILayout.EndVertical();
}
private void DrawStrippingSection()
{
// "Stripping Preset"
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Stripping Preset"),
TileLang.Text("Custom level of stripping can be applied to tile system upon build.")
)) {
EditorGUILayout.PropertyField(this.propertyStrippingPreset, content);
}
// "Stripping Preset Toggles"
if (!this.propertyStrippingPreset.hasMultipleDifferentValues)
{
var targetSystems = this.targets.Cast <TileSystem>().ToArray();
int mixedMask = RotorzEditorGUI.GetMixedStrippingOptionsMask(targetSystems);
StrippingPreset preset = targetSystems[0].StrippingPreset;
int options = targetSystems[0].StrippingOptions & ~mixedMask;
EditorGUI.showMixedValue = this.propertyStrippingOptionMask.hasMultipleDifferentValues;
int diff = RotorzEditorGUI.StrippingOptions(preset, options, mixedMask);
if (diff != 0 && preset == StrippingPreset.Custom)
{
int addBits = diff & ~options;
int removeBits = diff & options;
Undo.RecordObjects(this.targets, TileLang.ParticularText("Action", "Modify Stripping Options"));
foreach (var tileSystem in targetSystems)
{
tileSystem.StrippingOptions = (tileSystem.StrippingOptions & ~removeBits) | addBits;
EditorUtility.SetDirty(tileSystem);
}
}
EditorGUI.showMixedValue = false;
}
GUILayout.Space(5);
}
private void DrawFlagFields(int fromIndex, int toIndex)
{
GUILayout.BeginVertical(GUILayout.Width(190));
string[] labels = this.tabs[s_SelectedTab].FlagLabels;
for (int flagIndex = fromIndex; flagIndex <= toIndex; ++flagIndex)
{
GUILayout.BeginHorizontal();
using (var content = ControlContent.Basic(
/* 0: number of flag */
string.Format(TileLang.Text("Flag #{0}"), flagIndex + 1)
)) {
labels[flagIndex] = EditorGUILayout.TextField(content, labels[flagIndex] ?? "", RotorzEditorStyles.Instance.TextFieldRoundEdge)
.Replace(";", "");
}
if (string.IsNullOrEmpty(labels[flagIndex]))
{
GUILayout.Label(GUIContent.none, RotorzEditorStyles.Instance.TextFieldRoundEdgeCancelButtonEmpty);
}
else
{
if (GUILayout.Button(GUIContent.none, RotorzEditorStyles.Instance.TextFieldRoundEdgeCancelButton))
{
labels[flagIndex] = string.Empty;
GUIUtility.keyboardControl = 0;
GUIUtility.ExitGUI();
}
}
GUILayout.EndHorizontal();
}
GUILayout.EndVertical();
}
/// <summary>
/// Draw standard options GUI using layout engine. This method should be called
/// within a horizontally flowing layout.
/// </summary>
/// <example>
/// <code language="csharp"><![CDATA[
/// GUILayout.BeginHorizontal();
/// {
/// DrawStandardOptionsGUI();
/// }
/// GUILayout.EndHorizontal();
/// ]]></code>
/// </example>
protected void DrawStandardOptionsGUI()
{
Rect position = GUILayoutUtility.GetRect(77, 0);
position.y -= 3;
// Draw "Rotation" selector interface.
EditorGUI.BeginChangeCheck();
ToolUtility.Rotation = RotorzEditorGUI.RotationSelector(new Rect(position.x + 3, position.y, 39, 36), ToolUtility.Rotation);
if (EditorGUI.EndChangeCheck())
{
SceneView.RepaintAll();
}
using (var content = ControlContent.Basic(
RotorzEditorStyles.Skin.GetActive(RotorzEditorStyles.Skin.Randomize, ToolUtility.RandomizeVariations),
TileLang.ParticularText("Property", "Randomize Variations")
)) {
Rect togglePosition = position;
togglePosition.x += 3 + 39 + 5;
togglePosition.y += 1;
togglePosition.width = 32;
togglePosition.height = 30;
ToolUtility.RandomizeVariations = RotorzEditorGUI.HoverToggle(togglePosition, content, ToolUtility.RandomizeVariations);
}
if (this.EnableVariationShifting)
{
EditorGUI.BeginDisabledGroup(this.TemporarilyDisableVariationShifting);
this.DrawVariationShifter();
EditorGUI.EndDisabledGroup();
}
RotorzEditorGUI.VerticalSeparatorLight();
}
private void OnSection_BuildOptions()
{
float initialLabelWidth = EditorGUIUtility.labelWidth;
GUILayout.Space(3);
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Combine Method")
)) {
EditorGUILayout.PropertyField(this.propertyCombineMethod, content);
}
if (!this.propertyCombineMethod.hasMultipleDifferentValues)
{
if ((BuildCombineMethod)this.propertyCombineMethod.intValue == BuildCombineMethod.CustomChunkInTiles)
{
GUILayout.BeginHorizontal();
++EditorGUI.indentLevel;
{
EditorGUIUtility.labelWidth = 65;
EditorGUILayout.PrefixLabel(TileLang.ParticularText("Property", "Height"));
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(this.propertyCombineChunkHeight, GUIContent.none);
if (EditorGUI.EndChangeCheck())
{
this.propertyCombineChunkHeight.intValue = Mathf.Max(1, this.propertyCombineChunkHeight.intValue);
}
EditorGUILayout.PrefixLabel(TileLang.ParticularText("Property", "Width"));
EditorGUI.BeginChangeCheck();
EditorGUILayout.PropertyField(this.propertyCombineChunkWidth, GUIContent.none);
if (EditorGUI.EndChangeCheck())
{
this.propertyCombineChunkWidth.intValue = Mathf.Max(1, this.propertyCombineChunkWidth.intValue);
}
EditorGUIUtility.labelWidth = initialLabelWidth;
}
--EditorGUI.indentLevel;
GUILayout.EndHorizontal();
}
if ((BuildCombineMethod)this.propertyCombineMethod.intValue != BuildCombineMethod.None)
{
++EditorGUI.indentLevel;
{
this.propertyCombineIntoSubmeshes.boolValue = EditorGUILayout.ToggleLeft(TileLang.ParticularText("Property", "Combine into submeshes"), this.propertyCombineIntoSubmeshes.boolValue);
if (ControlContent.TrailingTipsVisible)
{
ExtraEditorGUI.TrailingTip(TileLang.Text("Determines whether to use submeshes, or an individual mesh for each material."));
}
}
--EditorGUI.indentLevel;
RotorzEditorGUI.InfoBox(TileLang.Text("Avoid generation of meshes with vertices in excess of 64k."), MessageType.Warning);
}
}
EditorGUILayout.Space();
using (var content = ControlContent.WithTrailableTip(
TileLang.ParticularText("Property", "Vertex Snap Threshold"),
TileLang.Text("Increase threshold to snap vertices that are more widely spread.")
)) {
EditorGUILayout.PropertyField(this.propertyVertexSnapThreshold, content);
if (!this.propertyVertexSnapThreshold.hasMultipleDifferentValues)
{
if (this.propertyVertexSnapThreshold.floatValue == 0f)
{
EditorGUILayout.HelpBox(TileLang.Text("No snapping occurs when threshold is 0."), MessageType.Warning, true);
}
}
ExtraEditorGUI.TrailingTip(content);
}
using (var content = ControlContent.WithTrailableTip(
TileLang.ParticularText("Property", "Static Snapping"),
TileLang.Text("Applies vertex snapping to static tiles to avoid tiny gaps due to numerical inaccuracies. Vertex snapping is always applied to 'smooth' tiles.")
)) {
EditorGUILayout.PropertyField(this.propertyStaticVertexSnapping, content);
ExtraEditorGUI.TrailingTip(content);
}
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Generate Lightmap UVs")
)) {
EditorGUILayout.PropertyField(this.propertyGenerateSecondUVs, content);
if (this.propertyGenerateSecondUVs.boolValue)
{
++EditorGUI.indentLevel;
s_ToggleBuildOptions_AdvancedUV2 = EditorGUILayout.Foldout(s_ToggleBuildOptions_AdvancedUV2, TileLang.ParticularText("Section", "Advanced"));
if (s_ToggleBuildOptions_AdvancedUV2)
{
float hardAngle = this.propertySecondUVsHardAngle.floatValue;
float packMargin = this.propertySecondUVsPackMargin.floatValue * 1024f;
float angleError = this.propertySecondUVsAngleError.floatValue * 100f;
float areaError = this.propertySecondUVsAreaError.floatValue * 100f;
using (var content2 = ControlContent.WithTrailableTip(
TileLang.ParticularText("Property", "Hard Angle"),
TileLang.Text("Angle between neighbor triangles that will generate seam.")
)) {
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = this.propertySecondUVsHardAngle.hasMultipleDifferentValues;
hardAngle = EditorGUILayout.Slider(content, hardAngle, 0f, 180f);
if (EditorGUI.EndChangeCheck())
{
this.propertySecondUVsHardAngle.floatValue = Mathf.Ceil(hardAngle);
}
ExtraEditorGUI.TrailingTip(content2);
}
using (var content2 = ControlContent.WithTrailableTip(
TileLang.ParticularText("Property", "Pack Margin"),
TileLang.Text("Measured in pixels, assuming mesh will cover an entire 1024x1024 lightmap.")
)) {
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = this.propertySecondUVsPackMargin.hasMultipleDifferentValues;
packMargin = EditorGUILayout.Slider(content, packMargin, 1f, 64f);
if (EditorGUI.EndChangeCheck())
{
this.propertySecondUVsPackMargin.floatValue = Mathf.Ceil(packMargin) / 1024f;
}
ExtraEditorGUI.TrailingTip(content2);
}
using (var content2 = ControlContent.WithTrailableTip(
TileLang.ParticularText("Property", "Angle Error"),
TileLang.Text("Measured in percents. Angle error measures deviation of UV angles from geometry angles. Area error measure deviation of UV triangles area from geometry triangles if they were uniformly scaled.")
)) {
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = this.propertySecondUVsAngleError.hasMultipleDifferentValues;
angleError = EditorGUILayout.Slider(content, angleError, 1f, 75f);
if (EditorGUI.EndChangeCheck())
{
this.propertySecondUVsAngleError.floatValue = Mathf.Ceil(angleError) / 100f;
}
ExtraEditorGUI.TrailingTip(content2);
}
using (var content2 = ControlContent.Basic(
TileLang.ParticularText("Property", "Area Error")
)) {
EditorGUI.BeginChangeCheck();
EditorGUI.showMixedValue = this.propertySecondUVsAreaError.hasMultipleDifferentValues;
areaError = EditorGUILayout.Slider(content2, areaError, 1f, 75f);
if (EditorGUI.EndChangeCheck())
{
this.propertySecondUVsAreaError.floatValue = Mathf.Ceil(areaError) / 100f;
}
}
EditorGUI.showMixedValue = false;
}
--EditorGUI.indentLevel;
}
}
using (var content = ControlContent.WithTrailableTip(
TileLang.ParticularText("Property", "Pre-generate Procedural"),
TileLang.Text("Increases size of scene but allows brushes to be stripped from builds.")
)) {
EditorGUILayout.PropertyField(this.propertyPregenerateProcedural, content);
ExtraEditorGUI.TrailingTip(content);
}
RotorzEditorGUI.InfoBox(TileLang.Text("Stripping capabilities are reduced when procedural tiles are present but are not pre-generated since they are otherwise generated at runtime."), MessageType.Info);
GUILayout.Space(5);
using (var content = ControlContent.Basic(
TileLang.ParticularText("Property", "Reduce Box Colliders"),
TileLang.Text("Reduces count of box colliders by coalescing adjacent colliders.")
)) {
EditorGUILayout.PropertyField(this.propertyReduceColliders, content);
}
}
